f972e4d343
* Placing 'G' before 'M' (SHF_MERGE) can be misleading as the sh_entsize argument goes before the section group name, if a reader doesn't know that the order of extra arguments is not affected by the order of flags. * 'a', 'w', and 'x' indicate basic permission-related flags. Separating them with 'G' is kinda ugly. Simplify code and move 'G' after 'o'. The new output is more similar to GCC.
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,"aMS",@progbits,1,unique,[[#U:8]]
|
|
; CHECK: explicit_default_3:
|
|
|
|
;; Non-allocatable "default" sections can be re-emitted with allocatable flag and uniqued
|
|
@explicit_default_3 = unnamed_addr constant [2 x i8] [i8 1, i8 0], section ".debug_str"
|
|
|
|
; CHECK: .section .debug_str,"a",@progbits,unique,[[#U+1]]
|
|
; 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,[[#U+2]]
|
|
; CHECK: implicit_rodata_cst4_assoc:
|
|
; CHECK: .section .rodata.cst8,"aMo",@progbits,8,implicit_rodata_cst4,unique,[[#U+3]]
|
|
; 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,[[#U+4]]
|
|
; CHECK: explicit_assoc_1:
|
|
; CHECK: .section .explicit,"aMo",@progbits,4,implicit_rodata_cst4,unique,[[#U+5]]
|
|
; CHECK: explicit_assoc_2:
|
|
; CHECK: .section .explicit,"aMo",@progbits,8,implicit_rodata_cst4,unique,[[#U+6]]
|
|
; 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 = !{ptr @implicit_rodata_cst4}
|
|
|
|
;; Test implicit section assignment for globals in distinct comdat groups.
|
|
; CHECK: .section .rodata.cst4,"aMG",@progbits,4,f,comdat,unique,[[#U+7]]
|
|
; CHECK: implicit_rodata_cst4_comdat:
|
|
; CHECK: .section .rodata.cst8,"aMG",@progbits,8,g,comdat,unique,[[#U+8]]
|
|
; 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,[[#U+9]]
|
|
; CHECK: explicit_comdat_distinct_supply_uid:
|
|
; CHECK: .section .explicit_comdat_distinct,"aMG",@progbits,4,f,comdat,unique,[[#U+10]]
|
|
; CHECK: explicit_comdat_distinct1:
|
|
; CHECK: .section .explicit_comdat_distinct,"aMG",@progbits,4,g,comdat,unique,[[#U+10]]
|
|
; CHECK: explicit_comdat_distinct2:
|
|
; CHECK: .section .explicit_comdat_distinct,"aMG",@progbits,8,h,comdat,unique,[[#U+11]]
|
|
; 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,"aMG",@progbits,4,i,comdat,unique,[[#U+12]]
|
|
; CHECK: implicit_rodata_cst4_same_comdat:
|
|
; CHECK: .section .rodata.cst8,"aMG",@progbits,8,i,comdat,unique,[[#U+13]]
|
|
; 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,[[#U+14]]
|
|
; CHECK: explicit_comdat_same_supply_uid:
|
|
; CHECK: .section .explicit_comdat_same,"aMG",@progbits,4,i,comdat,unique,[[#U+15]]
|
|
; CHECK: explicit_comdat_same1:
|
|
; CHECK: explicit_comdat_same2:
|
|
; CHECK: .section .explicit_comdat_same,"aMG",@progbits,8,i,comdat,unique,[[#U+16]]
|
|
; 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,[[#U+17]]
|
|
; 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,[[#U+17]]
|
|
; 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,[[#U+18]]
|
|
; CHECK: explicit_asm_3:
|
|
; CHECK: .section .asm_nonmergeable1,"aMS",@progbits,2,unique,[[#U+19]]
|
|
; CHECK: explicit_asm_4:
|
|
; CHECK: .section .asm_mergeable2,"aM",@progbits,4,unique,[[#U+20]]
|
|
; CHECK: explicit_asm_5:
|
|
; CHECK: .section .asm_nonmergeable2,"aMS",@progbits,2,unique,[[#U+21]]
|
|
; 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
|