34b60d8a56
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
303 lines
16 KiB
LLVM
303 lines
16 KiB
LLVM
; 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.
|
|
; RUN: not llc < %s -mtriple=x86_64 --no-integrated-as -binutils-version=2.34 2>&1 \
|
|
; 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?
|
|
|
|
;; For GNU as before 2.35,
|
|
;; 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
|
|
; 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
|