303 lines · plain
1; RUN: llc < %s -mtriple=x86_64 -unique-section-names=0 -data-sections 2>&1 \2; RUN: | FileCheck %s3 4;; Several sections are created via inline assembly. We add checks5;; for these lines as we want to use --implicit-check-not to reduce the6;; number of checks in this file.7; CHECK: .section .asm_mergeable1,"aMS",@progbits,2{{$}}8; CHECK-NEXT: .section .asm_nonmergeable1,"a",@progbits{{$}}9; CHECK-NEXT: .section .asm_mergeable2,"aMS",@progbits,2{{$}}10; CHECK-NEXT: .section .asm_nonmergeable2,"a",@progbits{{$}}11 12;; Test implicit section assignment for symbols13; CHECK: .section .data,"aw",@progbits,unique,114; CHECK: uniquified:15 16;; Create a uniquified symbol (as -unique-section-names=0) to test the uniqueID17;; interaction with mergeable symbols.18@uniquified = global i32 119 20;; Test implicit section assignment for symbols to ensure that the symbols21;; have the expected properties.22; CHECK: .section .rodata,"a",@progbits,unique,223; CHECK: implicit_nonmergeable:24; CHECK: .section .rodata.cst4,"aM",@progbits,4{{$}}25; CHECK: implicit_rodata_cst4:26; CHECK: .section .rodata.cst8,"aM",@progbits,8{{$}}27; CHECK: implicit_rodata_cst8:28; CHECK: .section .rodata.str4.4,"aMS",@progbits,4{{$}}29; CHECK: implicit_rodata_str4_4:30 31@implicit_nonmergeable = constant [2 x i16] [i16 1, i16 1]32@implicit_rodata_cst4 = unnamed_addr constant [2 x i16] [i16 1, i16 1]33@implicit_rodata_cst8 = unnamed_addr constant [2 x i32] [i32 1, i32 1]34@implicit_rodata_str4_4 = unnamed_addr constant [2 x i32] [i32 1, i32 0]35 36;; Basic checks that mergeable globals are placed into multiple distinct37;; sections with the same name and a compatible entry size.38 39; CHECK: .section .explicit_basic,"aM",@progbits,4,unique,340; CHECK: explicit_basic_1:41; CHECK: explicit_basic_2:42 43;; Assign a mergeable global to a non-existing section.44@explicit_basic_1 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_basic"45;; Assign a compatible mergeable global to the previous section.46@explicit_basic_2 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_basic"47 48; CHECK: .section .explicit_basic,"aM",@progbits,8,unique,449; CHECK: explicit_basic_3:50; CHECK: explicit_basic_4:51 52;; Assign a symbol with an incompatible entsize (different size) to a section with the same name.53@explicit_basic_3 = unnamed_addr constant [2 x i32] [i32 1, i32 1], section ".explicit_basic"54;; Assign a compatible mergeable global to the previous section.55@explicit_basic_4 = unnamed_addr constant [2 x i32] [i32 1, i32 1], section ".explicit_basic"56 57; CHECK: .section .explicit_basic,"aMS",@progbits,4,unique,558; CHECK: explicit_basic_5:59; CHECK: explicit_basic_6:60 61;; Assign a symbol with an incompatible entsize (string vs non-string) to a section with the same name.62@explicit_basic_5 = unnamed_addr constant [2 x i32] [i32 1, i32 0], section ".explicit_basic"63;; Assign a compatible mergeable global to the previous section.64@explicit_basic_6 = unnamed_addr constant [2 x i32] [i32 1, i32 0], section ".explicit_basic"65 66; CHECK: .section .explicit_basic,"a",@progbits{{$}}67; CHECK: explicit_basic_7:68 69;; Assign a symbol with an incompatible entsize (non-mergeable) to a mergeable section created explicitly.70@explicit_basic_7 = constant [2 x i16] [i16 1, i16 1], section ".explicit_basic"71 72; CHECK: .section .explicit_initially_nonmergeable,"a",@progbits{{$}}73; CHECK: explicit_basic_8:74; CHECK: .section .explicit_initially_nonmergeable,"aM",@progbits,4,unique,675; CHECK: explicit_basic_9:76 77;; Assign a mergeble symbol to a section that initially had a non-mergeable symbol explicitly assigned to it.78@explicit_basic_8 = constant [2 x i16] [i16 1, i16 1], section ".explicit_initially_nonmergeable"79@explicit_basic_9 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_initially_nonmergeable"80 81; CHECK: .section .explicit_initially_nonmergeable,"a",@progbits{{$}}82; CHECK: explicit_basic_10:83; CHECK: .section .explicit_initially_nonmergeable,"aM",@progbits,4,unique,684; CHECK: explicit_basic_11:85 86;; Assign compatible globals to the previously created sections.87@explicit_basic_10 = constant [2 x i16] [i16 1, i16 1], section ".explicit_initially_nonmergeable"88@explicit_basic_11 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_initially_nonmergeable"89 90;; Check that mergeable symbols can be explicitly assigned to "default" sections.91 92; CHECK: .section .rodata.cst16,"a",@progbits,unique,793; CHECK: explicit_default_1:94 95;; Assign an incompatible (non-mergeable) symbol to a "default" mergeable section.96@explicit_default_1 = constant [2 x i64] [i64 1, i64 1], section ".rodata.cst16"97 98; CHECK: .section .rodata.cst16,"aM",@progbits,16{{$}}99; CHECK: explicit_default_2:100 101;; Assign a compatible global to a "default" mergeable section.102@explicit_default_2 = unnamed_addr constant [2 x i64] [i64 1, i64 1], section ".rodata.cst16"103 104; CHECK: .section .debug_str,"aMS",@progbits,1,unique,[[#U:8]]105; CHECK: explicit_default_3:106 107;; Non-allocatable "default" sections can be re-emitted with allocatable flag and uniqued108@explicit_default_3 = unnamed_addr constant [2 x i8] [i8 1, i8 0], section ".debug_str"109 110; CHECK: .section .debug_str,"a",@progbits,unique,[[#U+1]]111; CHECK: explicit_default_4:112 113;; Non-allocatable "default" sections cannot have allocatable mergeable symbols with incompatible (non-mergeable) entry sizes assigned to them.114@explicit_default_4 = constant [2 x i16] [i16 1, i16 1], section ".debug_str"115 116;; Test implicit section assignment for globals with associated globals.117; CHECK: .section .rodata.cst4,"aMo",@progbits,4,implicit_rodata_cst4,unique,[[#U+2]]118; CHECK: implicit_rodata_cst4_assoc:119; CHECK: .section .rodata.cst8,"aMo",@progbits,8,implicit_rodata_cst4,unique,[[#U+3]]120; CHECK: implicit_rodata_cst8_assoc:121 122@implicit_rodata_cst4_assoc = unnamed_addr constant [2 x i16] [i16 1, i16 1], !associated !4123@implicit_rodata_cst8_assoc = unnamed_addr constant [2 x i32] [i32 1, i32 1], !associated !4124 125;; Check that globals with associated globals that are explicitly assigned126;; to a section have been placed into distinct sections with the same name, but127;; different entry sizes.128; CHECK: .section .explicit,"aMo",@progbits,4,implicit_rodata_cst4,unique,[[#U+4]]129; CHECK: explicit_assoc_1:130; CHECK: .section .explicit,"aMo",@progbits,4,implicit_rodata_cst4,unique,[[#U+5]]131; CHECK: explicit_assoc_2:132; CHECK: .section .explicit,"aMo",@progbits,8,implicit_rodata_cst4,unique,[[#U+6]]133; CHECK: explicit_assoc_3:134 135@explicit_assoc_1 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit", !associated !4136@explicit_assoc_2 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit", !associated !4137@explicit_assoc_3 = unnamed_addr constant [2 x i32] [i32 1, i32 1], section ".explicit", !associated !4138 139!4 = !{ptr @implicit_rodata_cst4}140 141;; Test implicit section assignment for globals in distinct comdat groups.142; CHECK: .section .rodata.cst4,"aMG",@progbits,4,f,comdat,unique,[[#U+7]]143; CHECK: implicit_rodata_cst4_comdat:144; CHECK: .section .rodata.cst8,"aMG",@progbits,8,g,comdat,unique,[[#U+8]]145; CHECK: implicit_rodata_cst8_comdat:146 147;; Check that globals in distinct comdat groups that are explicitly assigned148;; to a section have been placed into distinct sections with the same name, but149;; different entry sizes. Due to the way that MC currently works the unique ID150;; does not have any effect here, although it appears in the assembly. The unique ID's151;; appear incorrect as comdats are not taken into account when looking up the unique ID152;; for a mergeable section. However, as they have no effect it doesn't matter that they153;; are incorrect.154; CHECK: .section .explicit_comdat_distinct,"aM",@progbits,4,unique,[[#U+9]]155; CHECK: explicit_comdat_distinct_supply_uid:156; CHECK: .section .explicit_comdat_distinct,"aMG",@progbits,4,f,comdat,unique,[[#U+10]]157; CHECK: explicit_comdat_distinct1:158; CHECK: .section .explicit_comdat_distinct,"aMG",@progbits,4,g,comdat,unique,[[#U+10]]159; CHECK: explicit_comdat_distinct2:160; CHECK: .section .explicit_comdat_distinct,"aMG",@progbits,8,h,comdat,unique,[[#U+11]]161; CHECK: explicit_comdat_distinct3:162 163$f = comdat any164$g = comdat any165$h = comdat any166 167@implicit_rodata_cst4_comdat = unnamed_addr constant [2 x i16] [i16 1, i16 1], comdat($f)168@implicit_rodata_cst8_comdat = unnamed_addr constant [2 x i32] [i32 1, i32 1], comdat($g)169 170@explicit_comdat_distinct_supply_uid = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_comdat_distinct"171@explicit_comdat_distinct1 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_comdat_distinct", comdat($f)172@explicit_comdat_distinct2 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_comdat_distinct", comdat($g)173@explicit_comdat_distinct3 = unnamed_addr constant [2 x i32] [i32 1, i32 1], section ".explicit_comdat_distinct", comdat($h)174 175;; Test implicit section assignment for globals in the same comdat group.176; CHECK: .section .rodata.cst4,"aMG",@progbits,4,i,comdat,unique,[[#U+12]]177; CHECK: implicit_rodata_cst4_same_comdat:178; CHECK: .section .rodata.cst8,"aMG",@progbits,8,i,comdat,unique,[[#U+13]]179; CHECK: implicit_rodata_cst8_same_comdat:180 181;; Check that globals in the same comdat group that are explicitly assigned182;; to a section have been placed into distinct sections with the same name, but183;; different entry sizes. Due to the way that MC currently works the unique ID184;; does not have any effect here, although it appears in the assembly. The unique ID's185;; appear incorrect as comdats are not taken into account when looking up the unique ID186;; for a mergeable section. However, as they have no effect it doesn't matter that they187;; are incorrect.188; CHECK: .section .explicit_comdat_same,"aM",@progbits,4,unique,[[#U+14]]189; CHECK: explicit_comdat_same_supply_uid:190; CHECK: .section .explicit_comdat_same,"aMG",@progbits,4,i,comdat,unique,[[#U+15]]191; CHECK: explicit_comdat_same1:192; CHECK: explicit_comdat_same2:193; CHECK: .section .explicit_comdat_same,"aMG",@progbits,8,i,comdat,unique,[[#U+16]]194; CHECK: explicit_comdat_same3:195 196$i = comdat any197 198@implicit_rodata_cst4_same_comdat = unnamed_addr constant [2 x i16] [i16 1, i16 1], comdat($i)199@implicit_rodata_cst8_same_comdat = unnamed_addr constant [2 x i32] [i32 1, i32 1], comdat($i)200 201@explicit_comdat_same_supply_uid = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_comdat_same"202@explicit_comdat_same1 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_comdat_same", comdat($i)203@explicit_comdat_same2 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_comdat_same", comdat($i)204@explicit_comdat_same3 = unnamed_addr constant [2 x i32] [i32 1, i32 1], section ".explicit_comdat_same", comdat($i)205 206;; Check interaction between symbols that are explicitly assigned207;; to a section and implicitly assigned symbols.208 209; CHECK: .section .rodata.str1.1,"aMS",@progbits,1{{$}}210; CHECK: implicit_rodata_str1_1:211; CHECK: explicit_implicit_1:212 213;; Assign a compatible global to an existing mergeable section created implicitly.214@implicit_rodata_str1_1 = unnamed_addr constant [2 x i8] [i8 1, i8 0]215@explicit_implicit_1 = unnamed_addr constant [2 x i8] [i8 1, i8 0], section ".rodata.str1.1"216 217; CHECK: .section .rodata.str1.1,"a",@progbits,unique,[[#U+17]]218; CHECK: explicit_implicit_2:219 220;; Assign an incompatible symbol (non-mergeable) to an existing mergeable section created implicitly.221@explicit_implicit_2 = constant [2 x i16] [i16 1, i16 1], section ".rodata.str1.1"222 223; CHECK: .section .rodata.str1.1,"aMS",@progbits,1{{$}}224; CHECK: explicit_implicit_3:225; CHECK: .section .rodata.str1.1,"a",@progbits,unique,[[#U+17]]226; CHECK: explicit_implicit_4:227 228;; Assign compatible globals to the previously created sections.229@explicit_implicit_3 = unnamed_addr constant [2 x i8] [i8 1, i8 0], section ".rodata.str1.1"230@explicit_implicit_4 = constant [2 x i16] [i16 1, i16 1], section ".rodata.str1.1"231 232; CHECK: .section .rodata.str2.2,"aMS",@progbits,2{{$}}233; CHECK: explicit_implicit_5:234; CHECK: implicit_rodata_str2_2:235 236;; Implicitly assign a compatible global to an existing mergeable section created explicitly.237@explicit_implicit_5 = unnamed_addr constant [2 x i16] [i16 1, i16 0], section ".rodata.str2.2"238@implicit_rodata_str2_2 = unnamed_addr constant [2 x i16] [i16 1, i16 0]239 240;; Check the interaction with inline asm.241 242; CHECK: .section .asm_mergeable1,"aMS",@progbits,2{{$}}243; CHECK: explicit_asm_1:244; CHECK: .section .asm_nonmergeable1,"a",@progbits{{$}}245; CHECK: explicit_asm_2:246; CHECK: .section .asm_mergeable1,"aM",@progbits,4,unique,[[#U+18]]247; CHECK: explicit_asm_3:248; CHECK: .section .asm_nonmergeable1,"aMS",@progbits,2,unique,[[#U+19]]249; CHECK: explicit_asm_4:250; CHECK: .section .asm_mergeable2,"aM",@progbits,4,unique,[[#U+20]]251; CHECK: explicit_asm_5:252; CHECK: .section .asm_nonmergeable2,"aMS",@progbits,2,unique,[[#U+21]]253; CHECK: explicit_asm_6:254; CHECK: .section .asm_mergeable2,"aMS",@progbits,2{{$}}255; CHECK: explicit_asm_7:256; CHECK: .section .asm_nonmergeable2,"a",@progbits{{$}}257; CHECK: explicit_asm_8:258 259module asm ".section .asm_mergeable1,\22aMS\22,@progbits,2"260module asm ".section .asm_nonmergeable1,\22a\22,@progbits"261module asm ".section .asm_mergeable2,\22aMS\22,@progbits,2"262module asm ".section .asm_nonmergeable2,\22a\22,@progbits"263 264;; Assign compatible symbols to sections created using inline asm.265@explicit_asm_1 = unnamed_addr constant [2 x i16] [i16 1, i16 0], section ".asm_mergeable1"266@explicit_asm_2 = constant [2 x i16] [i16 1, i16 0], section ".asm_nonmergeable1"267;; Assign incompatible globals to the same sections.268@explicit_asm_3 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".asm_mergeable1"269@explicit_asm_4 = unnamed_addr constant [2 x i16] [i16 1, i16 0], section ".asm_nonmergeable1"270 271;; Assign incompatible globals to sections created using inline asm.272@explicit_asm_5 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".asm_mergeable2"273@explicit_asm_6 = unnamed_addr constant [2 x i16] [i16 1, i16 0], section ".asm_nonmergeable2"274;; Assign compatible globals to the same sections.275@explicit_asm_7 = unnamed_addr constant [2 x i16] [i16 1, i16 0], section ".asm_mergeable2"276@explicit_asm_8 = constant [2 x i16] [i16 1, i16 0], section ".asm_nonmergeable2"277 278;; A .note.GNU-stack section is created implicitly. We add a check for this as we want to use279;; --implicit-check-not to reduce the number of checks in this file.280; CHECK: .section ".note.GNU-stack","",@progbits{{$}}281 282;; --no-integrated-as avoids the use of ",unique," for compatibility with older binutils.283 284;; Error if an incompatible symbol is explicitly placed into a mergeable section.285; RUN: not llc < %s -mtriple=x86_64 --no-integrated-as -binutils-version=2.34 2>&1 \286; RUN: | FileCheck %s --check-prefix=NO-I-AS-ERR287; 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?288; 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?289; 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?290; 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?291 292;; For GNU as before 2.35,293;; Don't create mergeable sections for globals with an explicit section name.294; RUN: echo '@explicit = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit"' > %t.no_i_as.ll295; RUN: llc < %t.no_i_as.ll -mtriple=x86_64 --no-integrated-as -binutils-version=2.34 2>&1 \296; RUN: | FileCheck %s --check-prefix=NO-I-AS-OLD297; NO-I-AS-OLD: .section .explicit,"a",@progbits{{$}}298; RUN: llc < %t.no_i_as.ll -mtriple=x86_64 --no-integrated-as -binutils-version=2.35 2>&1 \299; RUN: | FileCheck %s --check-prefix=NO-I-AS-NEW300; RUN: llc < %t.no_i_as.ll -mtriple=x86_64 --no-integrated-as -binutils-version=none 2>&1 \301; RUN: | FileCheck %s --check-prefix=NO-I-AS-NEW302; NO-I-AS-NEW: .section .explicit,"aM",@progbits,4,unique,1303