maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lld/test/COFF/icf-circular.test

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

82 lines
2.6 KiB
Plaintext
Raw Normal View History

COFF: Add a test for ICF and circular references. ICF is a feature to merge sections not by name (which is the regular COMDAT merging) but by contents. If two or more sections have the identical contents and relocations, ICF merges them to save space. Accessors or templated functions tend to have the same contents, and ICF can hold them. If we consider sections as vertices and relocations as edges, the problem is to find as many isomorphic graphs as possile from input graphs. MSVC linker is smart enough to identify isomorphic graphs even if they contain circles (GNU gold cannot handle circles according to http://research.google.com/pubs/pub36912.html, so this is impressive). Circular references are not uncommon in COFF object files. One example is .pdata. .pdata sections contain exception handler info for functions, so they naturally have relocations for the functions. The functions in turn have references to the .pdata sections so that the functions and their .pdata are linked together. As a result, they form circles. This is a test case for circular graphs. LLD is not able to handle this test case yet. I'll add code soon. llvm-svn: 245827
2015-08-24 16:11:53 +08:00
# RUN: yaml2obj < %s > %t.obj
# RUN: lld-link /entry:foo /out:%t.exe /subsystem:console /include:bar \
COFF: Enable ICF by default. MSVC linker enables ICF as long as /opt:ref is eanbled, so do we. llvm-svn: 247817
2015-09-17 00:41:38 +08:00
# RUN: /verbose %t.obj > %t.log 2>&1
COFF: Add a test for ICF and circular references. ICF is a feature to merge sections not by name (which is the regular COMDAT merging) but by contents. If two or more sections have the identical contents and relocations, ICF merges them to save space. Accessors or templated functions tend to have the same contents, and ICF can hold them. If we consider sections as vertices and relocations as edges, the problem is to find as many isomorphic graphs as possile from input graphs. MSVC linker is smart enough to identify isomorphic graphs even if they contain circles (GNU gold cannot handle circles according to http://research.google.com/pubs/pub36912.html, so this is impressive). Circular references are not uncommon in COFF object files. One example is .pdata. .pdata sections contain exception handler info for functions, so they naturally have relocations for the functions. The functions in turn have references to the .pdata sections so that the functions and their .pdata are linked together. As a result, they form circles. This is a test case for circular graphs. LLD is not able to handle this test case yet. I'll add code soon. llvm-svn: 245827
2015-08-24 16:11:53 +08:00
# RUN: FileCheck %s < %t.log
ICF: Improve ICF to reduce more sections than before. This is a patch to make LLD to be on par with MSVC in terms of ICF effectiveness. MSVC produces a 27.14MB executable when linking LLD. LLD previously produced a 27.61MB when self-linking. Now the size is reduced to 27.11MB. Note that without ICF the size is 29.63MB. In r247387, I implemented an algorithm that handles section graphs as cyclic graphs and merge them using SCC. The algorithm did not always work as intended as I demonstrated in r247721. The new algortihm implemented in this patch is different from the previous one. If you are interested the details, you want to read the file comment of ICF.cpp. llvm-svn: 247770
2015-09-16 11:26:31 +08:00
# CHECK: Selected foo
# CHECK: Removed bar
COFF: Add a test for ICF and circular references. ICF is a feature to merge sections not by name (which is the regular COMDAT merging) but by contents. If two or more sections have the identical contents and relocations, ICF merges them to save space. Accessors or templated functions tend to have the same contents, and ICF can hold them. If we consider sections as vertices and relocations as edges, the problem is to find as many isomorphic graphs as possile from input graphs. MSVC linker is smart enough to identify isomorphic graphs even if they contain circles (GNU gold cannot handle circles according to http://research.google.com/pubs/pub36912.html, so this is impressive). Circular references are not uncommon in COFF object files. One example is .pdata. .pdata sections contain exception handler info for functions, so they naturally have relocations for the functions. The functions in turn have references to the .pdata sections so that the functions and their .pdata are linked together. As a result, they form circles. This is a test case for circular graphs. LLD is not able to handle this test case yet. I'll add code soon. llvm-svn: 245827
2015-08-24 16:11:53 +08:00
[yaml2obj] Updating LLD tests to account for LLVM r273915 This removed the -format flag from yaml2obj in favor of YAML tags. llvm-svn: 273920
2016-06-28 04:17:08 +08:00
--- !COFF
COFF: Add a test for ICF and circular references. ICF is a feature to merge sections not by name (which is the regular COMDAT merging) but by contents. If two or more sections have the identical contents and relocations, ICF merges them to save space. Accessors or templated functions tend to have the same contents, and ICF can hold them. If we consider sections as vertices and relocations as edges, the problem is to find as many isomorphic graphs as possile from input graphs. MSVC linker is smart enough to identify isomorphic graphs even if they contain circles (GNU gold cannot handle circles according to http://research.google.com/pubs/pub36912.html, so this is impressive). Circular references are not uncommon in COFF object files. One example is .pdata. .pdata sections contain exception handler info for functions, so they naturally have relocations for the functions. The functions in turn have references to the .pdata sections so that the functions and their .pdata are linked together. As a result, they form circles. This is a test case for circular graphs. LLD is not able to handle this test case yet. I'll add code soon. llvm-svn: 245827
2015-08-24 16:11:53 +08:00
header:
Machine: IMAGE_FILE_MACHINE_AMD64
Characteristics: []
sections:
- Name: '.text$mn'
Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_LNK_COMDAT, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
Alignment: 16
SectionData: 4883EC28E8000000004883C428C3
Relocations:
- VirtualAddress: 5
SymbolName: foo
Type: IMAGE_REL_AMD64_REL32
COFF: Fix ICF regression. This patch fixes a regression introduced by r247964. Relocations that are referring the same symbol should be considered equal, but they were not if they were pointing to non-section chunks. llvm-svn: 248132
2015-09-21 04:19:12 +08:00
- VirtualAddress: 10
SymbolName: __ImageBase
Type: IMAGE_REL_AMD64_REL32
COFF: Add a test for ICF and circular references. ICF is a feature to merge sections not by name (which is the regular COMDAT merging) but by contents. If two or more sections have the identical contents and relocations, ICF merges them to save space. Accessors or templated functions tend to have the same contents, and ICF can hold them. If we consider sections as vertices and relocations as edges, the problem is to find as many isomorphic graphs as possile from input graphs. MSVC linker is smart enough to identify isomorphic graphs even if they contain circles (GNU gold cannot handle circles according to http://research.google.com/pubs/pub36912.html, so this is impressive). Circular references are not uncommon in COFF object files. One example is .pdata. .pdata sections contain exception handler info for functions, so they naturally have relocations for the functions. The functions in turn have references to the .pdata sections so that the functions and their .pdata are linked together. As a result, they form circles. This is a test case for circular graphs. LLD is not able to handle this test case yet. I'll add code soon. llvm-svn: 245827
2015-08-24 16:11:53 +08:00
- Name: '.text$mn'
Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_LNK_COMDAT, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
Alignment: 16
SectionData: 4883EC28E8000000004883C428C3
Relocations:
- VirtualAddress: 5
SymbolName: bar
Type: IMAGE_REL_AMD64_REL32
COFF: Fix ICF regression. This patch fixes a regression introduced by r247964. Relocations that are referring the same symbol should be considered equal, but they were not if they were pointing to non-section chunks. llvm-svn: 248132
2015-09-21 04:19:12 +08:00
- VirtualAddress: 10
SymbolName: __ImageBase
Type: IMAGE_REL_AMD64_REL32
COFF: Add a test for ICF and circular references. ICF is a feature to merge sections not by name (which is the regular COMDAT merging) but by contents. If two or more sections have the identical contents and relocations, ICF merges them to save space. Accessors or templated functions tend to have the same contents, and ICF can hold them. If we consider sections as vertices and relocations as edges, the problem is to find as many isomorphic graphs as possile from input graphs. MSVC linker is smart enough to identify isomorphic graphs even if they contain circles (GNU gold cannot handle circles according to http://research.google.com/pubs/pub36912.html, so this is impressive). Circular references are not uncommon in COFF object files. One example is .pdata. .pdata sections contain exception handler info for functions, so they naturally have relocations for the functions. The functions in turn have references to the .pdata sections so that the functions and their .pdata are linked together. As a result, they form circles. This is a test case for circular graphs. LLD is not able to handle this test case yet. I'll add code soon. llvm-svn: 245827
2015-08-24 16:11:53 +08:00
symbols:
- Name: '.text$mn'
Value: 0
SectionNumber: 1
SimpleType: IMAGE_SYM_TYPE_NULL
ComplexType: IMAGE_SYM_DTYPE_NULL
StorageClass: IMAGE_SYM_CLASS_STATIC
SectionDefinition:
Length: 14
NumberOfRelocations: 1
NumberOfLinenumbers: 0
CheckSum: 1682752513
Number: 0
Selection: IMAGE_COMDAT_SELECT_NODUPLICATES
- Name: '.text$mn'
Value: 0
SectionNumber: 2
SimpleType: IMAGE_SYM_TYPE_NULL
ComplexType: IMAGE_SYM_DTYPE_NULL
StorageClass: IMAGE_SYM_CLASS_STATIC
SectionDefinition:
Length: 14
NumberOfRelocations: 1
NumberOfLinenumbers: 0
CheckSum: 1682752513
Number: 0
Selection: IMAGE_COMDAT_SELECT_NODUPLICATES
- Name: foo
Value: 0
SectionNumber: 1
SimpleType: IMAGE_SYM_TYPE_NULL
ComplexType: IMAGE_SYM_DTYPE_FUNCTION
StorageClass: IMAGE_SYM_CLASS_EXTERNAL
- Name: bar
Value: 0
SectionNumber: 2
SimpleType: IMAGE_SYM_TYPE_NULL
ComplexType: IMAGE_SYM_DTYPE_FUNCTION
StorageClass: IMAGE_SYM_CLASS_EXTERNAL
COFF: Fix ICF regression. This patch fixes a regression introduced by r247964. Relocations that are referring the same symbol should be considered equal, but they were not if they were pointing to non-section chunks. llvm-svn: 248132
2015-09-21 04:19:12 +08:00
- Name: __ImageBase
Value: 0
SectionNumber: 0
SimpleType: IMAGE_SYM_TYPE_NULL
ComplexType: IMAGE_SYM_DTYPE_NULL
StorageClass: IMAGE_SYM_CLASS_EXTERNAL
COFF: Add a test for ICF and circular references. ICF is a feature to merge sections not by name (which is the regular COMDAT merging) but by contents. If two or more sections have the identical contents and relocations, ICF merges them to save space. Accessors or templated functions tend to have the same contents, and ICF can hold them. If we consider sections as vertices and relocations as edges, the problem is to find as many isomorphic graphs as possile from input graphs. MSVC linker is smart enough to identify isomorphic graphs even if they contain circles (GNU gold cannot handle circles according to http://research.google.com/pubs/pub36912.html, so this is impressive). Circular references are not uncommon in COFF object files. One example is .pdata. .pdata sections contain exception handler info for functions, so they naturally have relocations for the functions. The functions in turn have references to the .pdata sections so that the functions and their .pdata are linked together. As a result, they form circles. This is a test case for circular graphs. LLD is not able to handle this test case yet. I'll add code soon. llvm-svn: 245827
2015-08-24 16:11:53 +08:00
...