[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
; RUN: llc < %s -mtriple=x86_64 -unique-section-names=0 -data-sections 2>&1 \
; RUN: | FileCheck %s
;; Several sections are created via inline assembly. We add checks
;; for these lines as we want to use --implicit-check-not to reduce the
;; number of checks in this file.
; CHECK: .section .asm_mergeable1,"aMS",@progbits,2
; CHECK-NEXT: .section .asm_nonmergeable1,"a",@progbits
; CHECK-NEXT: .section .asm_mergeable2,"aMS",@progbits,2
; CHECK-NEXT: .section .asm_nonmergeable2,"a",@progbits
;; Test implicit section assignment for symbols
; CHECK: .section .data,"aw",@progbits,unique,1
; CHECK: uniquified:
;; Create a uniquified symbol (as -unique-section-names=0) to test the uniqueID
;; interaction with mergeable symbols.
@uniquified = global i32 1
;; Test implicit section assignment for symbols to ensure that the symbols
;; have the expected properties.
; CHECK: .section .rodata,"a",@progbits,unique,2
; CHECK: implicit_nonmergeable:
; CHECK: .section .rodata.cst4,"aM",@progbits,4
; CHECK: implicit_rodata_cst4:
; CHECK: .section .rodata.cst8,"aM",@progbits,8
; CHECK: implicit_rodata_cst8:
; CHECK: .section .rodata.str4.4,"aMS",@progbits,4
; CHECK: implicit_rodata_str4_4:
@implicit_nonmergeable = constant [ 2 x i16 ] [ i16 1 , i16 1 ]
@implicit_rodata_cst4 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ]
@implicit_rodata_cst8 = unnamed_addr constant [ 2 x i32 ] [ i32 1 , i32 1 ]
@implicit_rodata_str4_4 = unnamed_addr constant [ 2 x i32 ] [ i32 1 , i32 0 ]
;; Basic checks that mergeable globals are placed into multiple distinct
;; sections with the same name and a compatible entry size.
; CHECK: .section .explicit_basic,"aM",@progbits,4,unique,3
; CHECK: explicit_basic_1:
; CHECK: explicit_basic_2:
;; Assign a mergeable global to a non-existing section.
@explicit_basic_1 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit_basic"
;; Assign a compatible mergeable global to the previous section.
@explicit_basic_2 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit_basic"
; CHECK: .section .explicit_basic,"aM",@progbits,8,unique,4
; CHECK: explicit_basic_3:
; CHECK: explicit_basic_4:
;; Assign a symbol with an incompatible entsize (different size) to a section with the same name.
@explicit_basic_3 = unnamed_addr constant [ 2 x i32 ] [ i32 1 , i32 1 ] , section ".explicit_basic"
;; Assign a compatible mergeable global to the previous section.
@explicit_basic_4 = unnamed_addr constant [ 2 x i32 ] [ i32 1 , i32 1 ] , section ".explicit_basic"
; CHECK: .section .explicit_basic,"aMS",@progbits,4,unique,5
; CHECK: explicit_basic_5:
; CHECK: explicit_basic_6:
;; Assign a symbol with an incompatible entsize (string vs non-string) to a section with the same name.
@explicit_basic_5 = unnamed_addr constant [ 2 x i32 ] [ i32 1 , i32 0 ] , section ".explicit_basic"
;; Assign a compatible mergeable global to the previous section.
@explicit_basic_6 = unnamed_addr constant [ 2 x i32 ] [ i32 1 , i32 0 ] , section ".explicit_basic"
; CHECK: .section .explicit_basic,"a",@progbits
; CHECK: explicit_basic_7:
;; Assign a symbol with an incompatible entsize (non-mergeable) to a mergeable section created explicitly.
@explicit_basic_7 = constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit_basic"
; CHECK: .section .explicit_initially_nonmergeable,"a",@progbits
; CHECK: explicit_basic_8:
; CHECK: .section .explicit_initially_nonmergeable,"aM",@progbits,4,unique,6
; CHECK: explicit_basic_9:
;; Assign a mergeble symbol to a section that initially had a non-mergeable symbol explicitly assigned to it.
@explicit_basic_8 = constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit_initially_nonmergeable"
@explicit_basic_9 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit_initially_nonmergeable"
; CHECK: .section .explicit_initially_nonmergeable,"a",@progbits
; CHECK: explicit_basic_10:
; CHECK: .section .explicit_initially_nonmergeable,"aM",@progbits,4,unique,6
; CHECK: explicit_basic_11:
;; Assign compatible globals to the previously created sections.
@explicit_basic_10 = constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit_initially_nonmergeable"
@explicit_basic_11 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit_initially_nonmergeable"
;; Check that mergeable symbols can be explicitly assigned to "default" sections.
; CHECK: .section .rodata.cst16,"a",@progbits,unique,7
; CHECK: explicit_default_1:
;; Assign an incompatible (non-mergeable) symbol to a "default" mergeable section.
@explicit_default_1 = constant [ 2 x i64 ] [ i64 1 , i64 1 ] , section ".rodata.cst16"
; CHECK: .section .rodata.cst16,"aM",@progbits,16
; CHECK: explicit_default_2:
;; Assign a compatible global to a "default" mergeable section.
@explicit_default_2 = unnamed_addr constant [ 2 x i64 ] [ i64 1 , i64 1 ] , section ".rodata.cst16"
; CHECK: .section .debug_str,"MS",@progbits,1
; CHECK: explicit_default_3:
;; Non-allocatable "default" sections can have allocatable mergeable symbols with compatible entry sizes assigned to them.
@explicit_default_3 = unnamed_addr constant [ 2 x i8 ] [ i8 1 , i8 0 ] , section ".debug_str"
; CHECK: .section .debug_str,"a",@progbits,unique,8
; CHECK: explicit_default_4:
;; Non-allocatable "default" sections cannot have allocatable mergeable symbols with incompatible (non-mergeable) entry sizes assigned to them.
@explicit_default_4 = constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".debug_str"
;; Test implicit section assignment for globals with associated globals.
; CHECK: .section .rodata.cst4,"aMo",@progbits,4,implicit_rodata_cst4,unique,9
; CHECK: implicit_rodata_cst4_assoc:
; CHECK: .section .rodata.cst8,"aMo",@progbits,8,implicit_rodata_cst4,unique,10
; CHECK: implicit_rodata_cst8_assoc:
@implicit_rodata_cst4_assoc = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , !associated !4
@implicit_rodata_cst8_assoc = unnamed_addr constant [ 2 x i32 ] [ i32 1 , i32 1 ] , !associated !4
;; Check that globals with associated globals that are explicitly assigned
;; to a section have been placed into distinct sections with the same name, but
;; different entry sizes.
; CHECK: .section .explicit,"aMo",@progbits,4,implicit_rodata_cst4,unique,11
; CHECK: explicit_assoc_1:
; CHECK: .section .explicit,"aMo",@progbits,4,implicit_rodata_cst4,unique,12
; CHECK: explicit_assoc_2:
; CHECK: .section .explicit,"aMo",@progbits,8,implicit_rodata_cst4,unique,13
; CHECK: explicit_assoc_3:
@explicit_assoc_1 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit" , !associated !4
@explicit_assoc_2 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit" , !associated !4
@explicit_assoc_3 = unnamed_addr constant [ 2 x i32 ] [ i32 1 , i32 1 ] , section ".explicit" , !associated !4
!4 = ! { [ 2 x i16 ] * @implicit_rodata_cst4 }
;; Test implicit section assignment for globals in distinct comdat groups.
; CHECK: .section .rodata.cst4,"aGM",@progbits,4,f,comdat,unique,14
; CHECK: implicit_rodata_cst4_comdat:
; CHECK: .section .rodata.cst8,"aGM",@progbits,8,g,comdat,unique,15
; CHECK: implicit_rodata_cst8_comdat:
;; Check that globals in distinct comdat groups that are explicitly assigned
;; to a section have been placed into distinct sections with the same name, but
;; different entry sizes. Due to the way that MC currently works the unique ID
;; does not have any effect here, although it appears in the assembly. The unique ID's
;; appear incorrect as comdats are not taken into account when looking up the unique ID
;; for a mergeable section. However, as they have no effect it doesn't matter that they
;; are incorrect.
; CHECK: .section .explicit_comdat_distinct,"aM",@progbits,4,unique,16
; CHECK: explicit_comdat_distinct_supply_uid:
; CHECK: .section .explicit_comdat_distinct,"aGM",@progbits,4,f,comdat,unique,16
; CHECK: explicit_comdat_distinct1:
; CHECK: .section .explicit_comdat_distinct,"aGM",@progbits,4,g,comdat,unique,16
; CHECK: explicit_comdat_distinct2:
; CHECK: .section .explicit_comdat_distinct,"aGM",@progbits,8,h,comdat,unique,17
; CHECK: explicit_comdat_distinct3:
$ f = comdat any
$ g = comdat any
$ h = comdat any
@implicit_rodata_cst4_comdat = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , comdat ( $ f )
@implicit_rodata_cst8_comdat = unnamed_addr constant [ 2 x i32 ] [ i32 1 , i32 1 ] , comdat ( $ g )
@explicit_comdat_distinct_supply_uid = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit_comdat_distinct"
@explicit_comdat_distinct1 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit_comdat_distinct" , comdat ( $ f )
@explicit_comdat_distinct2 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit_comdat_distinct" , comdat ( $ g )
@explicit_comdat_distinct3 = unnamed_addr constant [ 2 x i32 ] [ i32 1 , i32 1 ] , section ".explicit_comdat_distinct" , comdat ( $ h )
;; Test implicit section assignment for globals in the same comdat group.
; CHECK: .section .rodata.cst4,"aGM",@progbits,4,i,comdat,unique,18
; CHECK: implicit_rodata_cst4_same_comdat:
; CHECK: .section .rodata.cst8,"aGM",@progbits,8,i,comdat,unique,19
; CHECK: implicit_rodata_cst8_same_comdat:
;; Check that globals in the same comdat group that are explicitly assigned
;; to a section have been placed into distinct sections with the same name, but
;; different entry sizes. Due to the way that MC currently works the unique ID
;; does not have any effect here, although it appears in the assembly. The unique ID's
;; appear incorrect as comdats are not taken into account when looking up the unique ID
;; for a mergeable section. However, as they have no effect it doesn't matter that they
;; are incorrect.
; CHECK: .section .explicit_comdat_same,"aM",@progbits,4,unique,20
; CHECK: explicit_comdat_same_supply_uid:
; CHECK: .section .explicit_comdat_same,"aGM",@progbits,4,i,comdat,unique,20
; CHECK: explicit_comdat_same1:
; CHECK: explicit_comdat_same2:
; CHECK: .section .explicit_comdat_same,"aGM",@progbits,8,i,comdat,unique,21
; CHECK: explicit_comdat_same3:
$ i = comdat any
@implicit_rodata_cst4_same_comdat = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , comdat ( $ i )
@implicit_rodata_cst8_same_comdat = unnamed_addr constant [ 2 x i32 ] [ i32 1 , i32 1 ] , comdat ( $ i )
@explicit_comdat_same_supply_uid = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit_comdat_same"
@explicit_comdat_same1 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit_comdat_same" , comdat ( $ i )
@explicit_comdat_same2 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".explicit_comdat_same" , comdat ( $ i )
@explicit_comdat_same3 = unnamed_addr constant [ 2 x i32 ] [ i32 1 , i32 1 ] , section ".explicit_comdat_same" , comdat ( $ i )
;; Check interaction between symbols that are explicitly assigned
;; to a section and implicitly assigned symbols.
; CHECK: .section .rodata.str1.1,"aMS",@progbits,1
; CHECK: implicit_rodata_str1_1:
; CHECK: explicit_implicit_1:
;; Assign a compatible global to an existing mergeable section created implicitly.
@implicit_rodata_str1_1 = unnamed_addr constant [ 2 x i8 ] [ i8 1 , i8 0 ]
@explicit_implicit_1 = unnamed_addr constant [ 2 x i8 ] [ i8 1 , i8 0 ] , section ".rodata.str1.1"
; CHECK: .section .rodata.str1.1,"a",@progbits,unique,22
; CHECK: explicit_implicit_2:
;; Assign an incompatible symbol (non-mergeable) to an existing mergeable section created implicitly.
@explicit_implicit_2 = constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".rodata.str1.1"
; CHECK: .section .rodata.str1.1,"aMS",@progbits,1
; CHECK: explicit_implicit_3:
; CHECK: .section .rodata.str1.1,"a",@progbits,unique,22
; CHECK: explicit_implicit_4:
;; Assign compatible globals to the previously created sections.
@explicit_implicit_3 = unnamed_addr constant [ 2 x i8 ] [ i8 1 , i8 0 ] , section ".rodata.str1.1"
@explicit_implicit_4 = constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".rodata.str1.1"
; CHECK: .section .rodata.str2.2,"aMS",@progbits,2
; CHECK: explicit_implicit_5:
; CHECK: implicit_rodata_str2_2:
;; Implicitly assign a compatible global to an existing mergeable section created explicitly.
@explicit_implicit_5 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 0 ] , section ".rodata.str2.2"
@implicit_rodata_str2_2 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 0 ]
;; Check the interaction with inline asm.
; CHECK: .section .asm_mergeable1,"aMS",@progbits,2
; CHECK: explicit_asm_1:
; CHECK: .section .asm_nonmergeable1,"a",@progbits
; CHECK: explicit_asm_2:
; CHECK: .section .asm_mergeable1,"aM",@progbits,4,unique,23
; CHECK: explicit_asm_3:
; CHECK: .section .asm_nonmergeable1,"aMS",@progbits,2,unique,24
; CHECK: explicit_asm_4:
; CHECK: .section .asm_mergeable2,"aM",@progbits,4,unique,25
; CHECK: explicit_asm_5:
; CHECK: .section .asm_nonmergeable2,"aMS",@progbits,2,unique,26
; CHECK: explicit_asm_6:
; CHECK: .section .asm_mergeable2,"aMS",@progbits,2
; CHECK: explicit_asm_7:
; CHECK: .section .asm_nonmergeable2,"a",@progbits
; CHECK: explicit_asm_8:
module asm ".section .asm_mergeable1,\22aMS\22,@progbits,2"
module asm ".section .asm_nonmergeable1,\22a\22,@progbits"
module asm ".section .asm_mergeable2,\22aMS\22,@progbits,2"
module asm ".section .asm_nonmergeable2,\22a\22,@progbits"
;; Assign compatible symbols to sections created using inline asm.
@explicit_asm_1 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 0 ] , section ".asm_mergeable1"
@explicit_asm_2 = constant [ 2 x i16 ] [ i16 1 , i16 0 ] , section ".asm_nonmergeable1"
;; Assign incompatible globals to the same sections.
@explicit_asm_3 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".asm_mergeable1"
@explicit_asm_4 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 0 ] , section ".asm_nonmergeable1"
;; Assign incompatible globals to sections created using inline asm.
@explicit_asm_5 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 1 ] , section ".asm_mergeable2"
@explicit_asm_6 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 0 ] , section ".asm_nonmergeable2"
;; Assign compatible globals to the same sections.
@explicit_asm_7 = unnamed_addr constant [ 2 x i16 ] [ i16 1 , i16 0 ] , section ".asm_mergeable2"
@explicit_asm_8 = constant [ 2 x i16 ] [ i16 1 , i16 0 ] , section ".asm_nonmergeable2"
;; A .note.GNU-stack section is created implicitly. We add a check for this as we want to use
;; --implicit-check-not to reduce the number of checks in this file.
; CHECK: .section ".note.GNU-stack","",@progbits
;; --no-integrated-as avoids the use of ",unique," for compatibility with older binutils.
;; Error if an incompatible symbol is explicitly placed into a mergeable section.
Add -fbinutils-version= to gate ELF features on the specified binutils version
There are two use cases.
Assembler
We have accrued some code gated on MCAsmInfo::useIntegratedAssembler(). Some
features are supported by latest GNU as, but we have to use
MCAsmInfo::useIntegratedAs() because the newer versions have not been widely
adopted (e.g. SHF_LINK_ORDER 'o' and 'unique' linkage in 2.35, --compress-debug-sections= in 2.26).
Linker
We want to use features supported only by LLD or very new GNU ld, or don't want
to work around older GNU ld. We currently can't represent that "we don't care
about old GNU ld". You can find such workarounds in a few other places, e.g.
Mips/MipsAsmprinter.cpp PowerPC/PPCTOCRegDeps.cpp X86/X86MCInstrLower.cpp
AArch64 TLS workaround for R_AARCH64_TLSLD_MOVW_DTPREL_* (PR ld/18276),
R_AARCH64_TLSLE_LDST8_TPREL_LO12 (https://bugs.llvm.org/show_bug.cgi?id=36727 https://sourceware.org/bugzilla/show_bug.cgi?id=22969)
Mixed SHF_LINK_ORDER and non-SHF_LINK_ORDER components (supported by LLD in D84001;
GNU ld feature request https://sourceware.org/bugzilla/show_bug.cgi?id=16833 may take a while before available).
This feature allows to garbage collect some unused sections (e.g. fragmented .gcc_except_table).
This patch adds `-fbinutils-version=` to clang and `-binutils-version` to llc.
It changes one codegen place in SHF_MERGE to demonstrate its usage.
`-fbinutils-version=2.35` means the produced object file does not care about GNU
ld<2.35 compatibility. When `-fno-integrated-as` is specified, the produced
assembly can be consumed by GNU as>=2.35, but older versions may not work.
`-fbinutils-version=none` means that we can use all ELF features, regardless of
GNU as/ld support.
Both clang and llc need `parseBinutilsVersion`. Such command line parsing is
usually implemented in `llvm/lib/CodeGen/CommandFlags.cpp` (LLVMCodeGen),
however, ClangCodeGen does not depend on LLVMCodeGen. So I add
`parseBinutilsVersion` to `llvm/lib/Target/TargetMachine.cpp` (LLVMTarget).
Differential Revision: https://reviews.llvm.org/D85474
2021-01-27 04:28:23 +08:00
; RUN: not llc < %s -mtriple=x86_64 --no-integrated-as -binutils-version=2.34 2>&1 \
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
; RUN: | FileCheck %s --check-prefix=NO-I-AS-ERR
; NO-I-AS-ERR: error: Symbol 'explicit_default_1' from module '<stdin>' required a section with entry-size=0 but was placed in section '.rodata.cst16' with entry-size=16: Explicit assignment by pragma or attribute of an incompatible symbol to this section?
; NO-I-AS-ERR: error: Symbol 'explicit_default_4' from module '<stdin>' required a section with entry-size=0 but was placed in section '.debug_str' with entry-size=1: Explicit assignment by pragma or attribute of an incompatible symbol to this section?
; NO-I-AS-ERR: error: Symbol 'explicit_implicit_2' from module '<stdin>' required a section with entry-size=0 but was placed in section '.rodata.str1.1' with entry-size=1: Explicit assignment by pragma or attribute of an incompatible symbol to this section?
; NO-I-AS-ERR: error: Symbol 'explicit_implicit_4' from module '<stdin>' required a section with entry-size=0 but was placed in section '.rodata.str1.1' with entry-size=1: Explicit assignment by pragma or attribute of an incompatible symbol to this section?
Add -fbinutils-version= to gate ELF features on the specified binutils version
There are two use cases.
Assembler
We have accrued some code gated on MCAsmInfo::useIntegratedAssembler(). Some
features are supported by latest GNU as, but we have to use
MCAsmInfo::useIntegratedAs() because the newer versions have not been widely
adopted (e.g. SHF_LINK_ORDER 'o' and 'unique' linkage in 2.35, --compress-debug-sections= in 2.26).
Linker
We want to use features supported only by LLD or very new GNU ld, or don't want
to work around older GNU ld. We currently can't represent that "we don't care
about old GNU ld". You can find such workarounds in a few other places, e.g.
Mips/MipsAsmprinter.cpp PowerPC/PPCTOCRegDeps.cpp X86/X86MCInstrLower.cpp
AArch64 TLS workaround for R_AARCH64_TLSLD_MOVW_DTPREL_* (PR ld/18276),
R_AARCH64_TLSLE_LDST8_TPREL_LO12 (https://bugs.llvm.org/show_bug.cgi?id=36727 https://sourceware.org/bugzilla/show_bug.cgi?id=22969)
Mixed SHF_LINK_ORDER and non-SHF_LINK_ORDER components (supported by LLD in D84001;
GNU ld feature request https://sourceware.org/bugzilla/show_bug.cgi?id=16833 may take a while before available).
This feature allows to garbage collect some unused sections (e.g. fragmented .gcc_except_table).
This patch adds `-fbinutils-version=` to clang and `-binutils-version` to llc.
It changes one codegen place in SHF_MERGE to demonstrate its usage.
`-fbinutils-version=2.35` means the produced object file does not care about GNU
ld<2.35 compatibility. When `-fno-integrated-as` is specified, the produced
assembly can be consumed by GNU as>=2.35, but older versions may not work.
`-fbinutils-version=none` means that we can use all ELF features, regardless of
GNU as/ld support.
Both clang and llc need `parseBinutilsVersion`. Such command line parsing is
usually implemented in `llvm/lib/CodeGen/CommandFlags.cpp` (LLVMCodeGen),
however, ClangCodeGen does not depend on LLVMCodeGen. So I add
`parseBinutilsVersion` to `llvm/lib/Target/TargetMachine.cpp` (LLVMTarget).
Differential Revision: https://reviews.llvm.org/D85474
2021-01-27 04:28:23 +08:00
;; For GNU as before 2.35,
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
;; Don't create mergeable sections for globals with an explicit section name.
; RUN: echo '@explicit = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit"' > %t.no_i_as.ll
Add -fbinutils-version= to gate ELF features on the specified binutils version
There are two use cases.
Assembler
We have accrued some code gated on MCAsmInfo::useIntegratedAssembler(). Some
features are supported by latest GNU as, but we have to use
MCAsmInfo::useIntegratedAs() because the newer versions have not been widely
adopted (e.g. SHF_LINK_ORDER 'o' and 'unique' linkage in 2.35, --compress-debug-sections= in 2.26).
Linker
We want to use features supported only by LLD or very new GNU ld, or don't want
to work around older GNU ld. We currently can't represent that "we don't care
about old GNU ld". You can find such workarounds in a few other places, e.g.
Mips/MipsAsmprinter.cpp PowerPC/PPCTOCRegDeps.cpp X86/X86MCInstrLower.cpp
AArch64 TLS workaround for R_AARCH64_TLSLD_MOVW_DTPREL_* (PR ld/18276),
R_AARCH64_TLSLE_LDST8_TPREL_LO12 (https://bugs.llvm.org/show_bug.cgi?id=36727 https://sourceware.org/bugzilla/show_bug.cgi?id=22969)
Mixed SHF_LINK_ORDER and non-SHF_LINK_ORDER components (supported by LLD in D84001;
GNU ld feature request https://sourceware.org/bugzilla/show_bug.cgi?id=16833 may take a while before available).
This feature allows to garbage collect some unused sections (e.g. fragmented .gcc_except_table).
This patch adds `-fbinutils-version=` to clang and `-binutils-version` to llc.
It changes one codegen place in SHF_MERGE to demonstrate its usage.
`-fbinutils-version=2.35` means the produced object file does not care about GNU
ld<2.35 compatibility. When `-fno-integrated-as` is specified, the produced
assembly can be consumed by GNU as>=2.35, but older versions may not work.
`-fbinutils-version=none` means that we can use all ELF features, regardless of
GNU as/ld support.
Both clang and llc need `parseBinutilsVersion`. Such command line parsing is
usually implemented in `llvm/lib/CodeGen/CommandFlags.cpp` (LLVMCodeGen),
however, ClangCodeGen does not depend on LLVMCodeGen. So I add
`parseBinutilsVersion` to `llvm/lib/Target/TargetMachine.cpp` (LLVMTarget).
Differential Revision: https://reviews.llvm.org/D85474
2021-01-27 04:28:23 +08:00
; RUN: llc < %t.no_i_as.ll -mtriple=x86_64 --no-integrated-as -binutils-version=2.34 2>&1 \
; RUN: | FileCheck %s --check-prefix=NO-I-AS-OLD
; NO-I-AS-OLD: .section .explicit,"a",@progbits
; RUN: llc < %t.no_i_as.ll -mtriple=x86_64 --no-integrated-as -binutils-version=2.35 2>&1 \
; RUN: | FileCheck %s --check-prefix=NO-I-AS-NEW
; RUN: llc < %t.no_i_as.ll -mtriple=x86_64 --no-integrated-as -binutils-version=none 2>&1 \
; RUN: | FileCheck %s --check-prefix=NO-I-AS-NEW
; NO-I-AS-NEW: .section .explicit,"aM",@progbits,4,unique,1
