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
|