Append ".__part.<ID>" to all basic block section symbols.

[tmsriram]

Summary

Every basic block section symbol created by -fbasic-block-sections will contain ".__part." to know that this symbol corresponds to a basic block fragment of the function.

This patch solves two problems:

a) Like D89617, we want function symbols with suffixes to be properly qualified so that external tools like profile aggregators know exactly what this symbol corresponds to.
b) The current basic block naming just adds a ".N" to the symbol name where N is some integer. This collides with how clang creates __cxx_global_var_init.N. clang creates these symbol names to call constructor functions and basic block symbol naming should not use the same style.

I have fixed all the test cases and added an extra test for __cxx_global_var_init breakage.

[rahmanl]

It may be worthwhile to think about removing the second dot from the naming, i.e., foo.__bb.N -> foo.__bbN . The reason is that this further distinguishes the symbol name from symbols like __cxx_global_var_init.N plus it saves one character.

[tmsriram]

In D93082#2449369, @rahmanl wrote:

It may be worthwhile to think about removing the second dot from the naming, i.e., foo.__bb.N -> foo.__bbN . The reason is that this further distinguishes the symbol name from symbols like __cxx_global_var_init.N plus it saves one character.

The -funique-internal-linkage-names option uses ".__uniq." so I wanted to stick to that convention. I am not sure what you mean when you say further distinguishing.

[rahmanl]

In D93082#2450638, @tmsriram wrote:

In D93082#2449369, @rahmanl wrote:

It may be worthwhile to think about removing the second dot from the naming, i.e., foo.__bb.N -> foo.__bbN . The reason is that this further distinguishes the symbol name from symbols like __cxx_global_var_init.N plus it saves one character.

The -funique-internal-linkage-names option uses ".__uniq." so I wanted to stick to that convention. I am not sure what you mean when you say further distinguishing.

My focus is more on how this plays out with -fbasic-block-sections=list=.
With .__bb.N we may end up having four different symbols for a function foo, foo.cold, foo.eh, and foo.__bb.N. How would a symbolizer/tool identify these as basic block sections of the same function? My guess is that it first inspects the last extension. If it's .cold or .eh, then the remainder is the base function name, otherwise, if it's a number, it would have to inspect the prior extension again to make sure it's .__bb (hence my note about distinguishing with __cxx_global_var_init.N.
.__uniq does not have the same problem because there is only one way for the extension.

Another (rather weak) concern is that the prefix __bb may reflect that the section comes from a basic block of the same id. This is only the case in -fbasic-block-sections=all. With =list the section ID number may not be the same as the basic block which begins that section.

[tmsriram]

Use "part" instead of "bb". __part is more descriptive as the symbol can denote one or more basic blocks.

[rahmanl]

Please also replace bb in the description of the patch with part.

[MaskRay]

b) The current basic block naming just adds a ".N" to the symbol name where N is some integer. This collides with how clang creates __cxx_global_var_init.N. clang creates these symbol names to call constructor functions and basic block symbol naming should not use the same style.

This reason alone is not sufficient I guess. __part.N greatly increases .strtab usage. Are there other benefits?

[tmsriram]

In D93082#2469132, @MaskRay wrote:

b) The current basic block naming just adds a ".N" to the symbol name where N is some integer. This collides with how clang creates __cxx_global_var_init.N. clang creates these symbol names to call constructor functions and basic block symbol naming should not use the same style.

This reason alone is not sufficient I guess. __part.N greatly increases .strtab usage. Are there other benefits?

There are exactly two reasons to do this:

1. The simple naming collides with __cxx_global_var_init.N naming, which is a show stopper.
2. External tools need to understand symbol names such as these for profile attribution. D89617 did that unique internal linkage symbols by adding the uniq suffix. This adds the part suffix.

Having said that, let's come to the part of .strtab bloats. Yes, we are aware of that and have gone to great lengths to minimize this for Propeller:

• For e.g. -fbasic-block-sections=labels uses a special section to store these symbols without bloating strtab and symtab
• Propeller uses -fbasic-block-sections=list to selectively create sections which reduces strtab bloat and section table bloat significantly (close to zero for intra-procedural re-ordering)

With full basic block sections, the object size bloat from section table outweighs the bloats from strtab and symtab. However, please note that this is only the object file sizes. In the final binary, after the reordering has taken place, the unwanted symbols (those that are contiguous to the main function) will be deleted (patch pending) and hence this bloats will not carry over to the final binary size. Thanks.

[MaskRay]

.L prefixed symbols will be discarded by the linker in the default mode (none of --discard-none/--discard-locals/--discard-all is specified).
So if you use .L (called PrivateGlobalPrefix in MC), this will work without any linker change (if possible I would hope we just make use of existing conventions instead of adding more linker rules).
For the string __uniq and __part, I am fine with them and actually prefer them if you have measured that they don't cause too mush bloat. The names are clearer than other alternatives like unary coding and special code points (e.g. LLVM IR names make use of \1)

With full basic block sections, the object size bloat from section table outweighs the bloats from strtab and symtab.

sizeof(Elf64_Shdr) = 64. A C++ mangled symbol name can be longer than it, but I don't know the average length.

[MaskRay]

llvm/lib/CodeGen/MachineBasicBlock.cpp

77

Suffix = (Suffix + Twine(".__part.") + Twine(SectionID.Number)).str();

[tmsriram]

In D93082#2469154, @MaskRay wrote:

.L prefixed symbols will be discarded by the linker in the default mode (none of --discard-none/--discard-locals/--discard-all is specified).

Aren't these discarded by the assembler itself?

So if you use .L (called PrivateGlobalPrefix in MC), this will work without any linker change (if possible I would hope we just make use of existing conventions instead of adding more linker rules).

So there is some logic to deleting a basic block symbol. For instance, we will keep a symbol that is discontiguous with the main function as the representative symbol, does that make sense? We can only delete those symbols that end up contiguous with the main function.

For the string __uniq and __part, I am fine with them and actually prefer them if you have measured that they don't cause too mush bloat. The names are clearer than other alternatives like unary coding and special code points (e.g. LLVM IR names make use of \1)

Right, we tried unary encoding for our initial prototype and we didnt like the complicated naming.

The thing is full basic block sections will cause size bloats in several ways, especially section table overheads. strtab and symtab bloats is only one aspect of it. This is why we went with "=list" option for Propeller. Full basic block sections is the generic feature and is very useful for experimenting with various layouts but should be carefully used under size constrained environments.

With full basic block sections, the object size bloat from section table outweighs the bloats from strtab and symtab.

sizeof(Elf64_Shdr) = 64. A C++ mangled symbol name can be longer than it, but I don't know the average length.

[tmsriram]

Address reviewer comments.

[tmsriram]

In D93082#2469154, @MaskRay wrote:

.L prefixed symbols will be discarded by the linker in the default mode (none of --discard-none/--discard-locals/--discard-all is specified).
So if you use .L (called PrivateGlobalPrefix in MC), this will work without any linker change (if possible I would hope we just make use of existing conventions instead of adding more linker rules).
For the string __uniq and __part, I am fine with them and actually prefer them if you have measured that they don't cause too mush bloat. The names are clearer than other alternatives like unary coding and special code points (e.g. LLVM IR names make use of \1)

With full basic block sections, the object size bloat from section table outweighs the bloats from strtab and symtab.

sizeof(Elf64_Shdr) = 64. A C++ mangled symbol name can be longer than it, but I don't know the average length.

This is a good point. We have looked at unary encoding / moving symbol mapping to separate sections. We are brainstorming this and we will keep you posted. Maybe there is a nice compressed representation we can build.

clang/test/CodeGen/basic-block-sections.c

 }
 
 // PLAIN-NOT: section
 // PLAIN: world:
 //
 // BB_WORLD: .section .text.world,"ax",@progbits{{$}}
 // BB_WORLD: world:
 // BB_WORLD: .section .text.world,"ax",@progbits,unique
-// BB_WORLD: world.1:
+// BB_WORLD: world.__part.1:
 // BB_WORLD: .section .text.another,"ax",@progbits
 // BB_ALL: .section .text.another,"ax",@progbits,unique
-// BB_ALL: another.1:
+// BB_ALL: another.__part.1:
 // BB_LIST-NOT: .section .text.another,"ax",@progbits,unique
 // BB_LIST: another:
-// BB_LIST-NOT: another.1:
+// BB_LIST-NOT: another.__part.1:
 //
-// UNIQUE: .section .text.world.world.1,
-// UNIQUE: .section .text.another.another.1,
+// UNIQUE: .section .text.world.world.__part.1,
+// UNIQUE: .section .text.another.another.__part.1,
 // ERROR: error:  unable to load basic block sections function list: '{{[Nn]}}o such file or directory'

lld/test/ELF/lto/basic-block-sections.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: ld.lld %t.o -o %t --lto-basic-block-sections=all --lto-O0 --save-temps
 ; RUN: llvm-readobj -s %t.lto.o | FileCheck --check-prefix=SECNAMES %s
 ; RUN: ld.lld %t.o -o %t --lto-basic-block-sections=all --lto-unique-basic-block-section-names --lto-O0 --save-temps
 ; RUN: llvm-readobj -s %t.lto.o | FileCheck --check-prefix=SECNAMES-FULL %s
 ; RUN: llvm-nm %t | FileCheck --check-prefix=SYMS %s
 
 ; SECNAMES: Name: .text.foo {{.*}}
 ; SECNAMES: Name: .text.foo {{.*}}
 ; SECNAMES: Name: .text.foo {{.*}}
 
 ; SECNAMES-FULL: Name: .text.foo {{.*}}
-; SECNAMES-FULL: Name: .text.foo.foo.1 {{.*}}
-; SECNAMES-FULL: Name: .text.foo.foo.2 {{.*}}
+; SECNAMES-FULL: Name: .text.foo.foo.__part.1 {{.*}}
+; SECNAMES-FULL: Name: .text.foo.foo.__part.2 {{.*}}
 
 ; SYMS: foo
-; SYMS: foo.1
-; SYMS: foo.2
+; SYMS: foo.__part.1
+; SYMS: foo.__part.2
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: nounwind uwtable
 define dso_local void @foo(i32 %b) local_unnamed_addr {
 entry:
   %tobool.not = icmp eq i32 %b, 0

llvm/lib/CodeGen/MachineBasicBlock.cpp

if (!CachedMCSymbol) {
     // label.
     if (MF->hasBBSections() && isBeginSection()) {
       SmallString<5> Suffix;
       if (SectionID == MBBSectionID::ColdSectionID) {
         Suffix += ".cold";
       } else if (SectionID == MBBSectionID::ExceptionSectionID) {
         Suffix += ".eh";
       } else {
-        Suffix += "." + std::to_string(SectionID.Number);
+        // For symbols that represent basic block sections, we add ".__part." to
+        // allow tools like symbolizers to know that this represents a part of
+        // the original function.
+        Suffix = (Suffix + Twine(".__part.") + Twine(SectionID.Number)).str();
       }
       CachedMCSymbol = Ctx.getOrCreateSymbol(MF->getName() + Suffix);
     } else {
       const StringRef Prefix = Ctx.getAsmInfo()->getPrivateLabelPrefix();
       CachedMCSymbol = Ctx.getOrCreateSymbol(Twine(Prefix) + "BB" +
                                              Twine(MF->getFunctionNumber()) +
                                              "_" + Twine(getNumber()));
     }

llvm/test/CodeGen/X86/basic-block-sections-blockaddress-taken.ll

 ; CHECK-NEXT:    cmovneq %rax, %rcx
 ; CHECK-NEXT:    jmpq    *%rcx
 
 bb1:                                                ; preds = %entry
   %2 = call i32 @bar()
   ret void
 ; CHECK:         .section .text,"ax",@progbits,unique,1
 ; CHECK-NEXT:  .Ltmp0:
-; CHECK-NEXT:  foo.1
+; CHECK-NEXT:  foo.__part.1
 ; CHECK-NEXT:    callq   bar
 ;
 
 bb2:                                                ; preds = %entry
   %3 = call i32 @baz()
   ret void
 ; CHECK:         .section .text,"ax",@progbits,unique,2
 ; CHECK-NEXT:  .Ltmp1:
-; CHECK-NEXT:  foo.2
+; CHECK-NEXT:  foo.__part.2
 ; CHECK-NEXT:    callq   baz
 }
 
 declare i32 @bar()
 declare i32 @baz()

llvm/test/CodeGen/X86/basic-block-sections-clusters-branches.ll

 }
 
 declare i32 @bar() #1
 
 declare i32 @baz() #1
 
 ; LINUX-SECTIONS1:      .section  .text.foo,"ax",@progbits
 ; LINUX-SECTIONS1-LABEL:  foo:
-; LINUX-SECTIONS1:    jne foo.1
+; LINUX-SECTIONS1:    jne foo.__part.1
 ; LINUX-SECTIONS1-NOT:    {{jne|je|jmp}}
 ; LINUX-SECTIONS1-LABEL:  # %bb.2:
 ; LINUX-SECTIONS1:    jmp foo.cold
 ; LINUX-SECTIONS1:    .section        .text.foo,"ax",@progbits,unique,1
-; LINUX-SECTIONS1-LABEL:  foo.1:
+; LINUX-SECTIONS1-LABEL:  foo.__part.1:
 ; LINUX-SECTIONS1:    jmp foo.cold
 ; LINUX-SECTIONS1:    .section        .text.split.foo,"ax",@progbits
 ; LINUX-SECTIONS1-LABEL:  foo.cold:
 
 ; LINUX-SECTIONS2:    .section        .text.foo,"ax",@progbits
 ; LINUX-SECTIONS2-LABEL:  foo:
-; LINUX-SECTIONS2:    jne foo.0
+; LINUX-SECTIONS2:    jne foo.__part.0
 ; LINUX-SECTIONS2-NOT:    {{jne|je|jmp}}
 ; LINUX-SECTIONS2-LABEL:  # %bb.2:
 ; LINUX-SECTIONS2:    jmp .LBB0_3
 ; LINUX-SECTIONS2:    .section        .text.foo,"ax",@progbits,unique,1
-; LINUX-SECTIONS2:    foo.0:
+; LINUX-SECTIONS2:    foo.__part.0:
 ; LINUX-SECTIONS2-NOT:    {{jne|je|jmp}}
 ; LINUX-SECTIONS2:    .LBB0_3:

llvm/test/CodeGen/X86/basic-block-sections-clusters-eh.ll

 ; LINUX-SECTIONS1-LABEL:  main:
 ; LINUX-SECTIONS1-NOT:    .section
 ; LINUX-SECTIONS1-LABEL:  .LBB0_4:
 ; LINUX-SECTIONS1-NOT:    .section
 ; LINUX-SECTIONS1-LABEL:  .LBB0_5:
 ; LINUX-SECTIONS1-NOT:    .section
 ; LINUX-SECTIONS1-LABEL:  .LBB0_6:
 ; LINUX-SECTIONS1:    .section  .text.main,"ax",@progbits,unique,1
-; LINUX-SECTIONS1-LABEL:  main.0:
+; LINUX-SECTIONS1-LABEL:  main.__part.0:
 ; LINUX-SECTIONS1:    .section  .text.eh.main,"ax",@progbits
 ; LINUX-SECTIONS1-LABEL:  main.eh:
 ; LINUX-SECTIONS1-NOT:    .section
 ; LINUX-SECTIONS1-LABEL:  .LBB0_3:
 ; LINUX-SECTIONS1-NOT:    .section
 ; LINUX-SECTIONS1:    .section  .text.main,"ax",@progbits
 ; LINUX-SECTIONS1-LABEL:  .Lfunc_end0
 
 
 ; LINUX-SECTIONS2:    .section  .text.main,"ax",@progbits
 ; LINUX-SECTIONS2-LABEL:  main:
 ; LINUX-SECTIONS2-NOT:    .section
 ; LINUX-SECTIONS2-LABEL:  .LBB0_4:
 ; LINUX-SECTIONS2-NOT:    .section
 ; LINUX-SECTIONS2-LABEL:  .LBB0_5:
 ; LINUX-SECTIONS2-NOT:    .section
 ; LINUX-SECTIONS2-LABEL:  .LBB0_6:
 ; LINUX-SECTIONS2:    .section  .text.main,"ax",@progbits,unique,1
-; LINUX-SECTIONS2-LABEL:  main.0:
+; LINUX-SECTIONS2-LABEL:  main.__part.0:
 ; LINUX-SECTIONS2-NOT:    .section
 ; LINUX-SECTIONS2-LABEL:  .LBB0_2:
 ; LINUX-SECTIONS2-NOT:    .section
 ; LINUX-SECTIONS2-LABEL:  .LBB0_3:
 ; LINUX-SECTIONS2:    .section  .text.main,"ax",@progbits
 ; LINUX-SECTIONS2-LABEL:  .Lfunc_end0

llvm/test/CodeGen/X86/basic-block-sections-clusters.ll

 ; LINUX-SECTIONS1:      .section  .text.foo,"ax",@progbits
 ; LINUX-SECTIONS1-NOT:    .section
 ; LINUX-SECTIONS1-LABEL:  foo:
 ; LINUX-SECTIONS1-NOT:    .section
 ; LINUX-SECTIONS1-NOT:    .LBB_END0_{{0-9}}+
 ; LINUX-SECTIONS1-LABEL:  # %bb.2:
 ; LINUX-SECTIONS1-NOT:    .LBB_END0_{{0-9}}+
 ; LINUX-SECTIONS1:    .section        .text.foo,"ax",@progbits,unique,1
-; LINUX-SECTIONS1-LABEL:  foo.1:
+; LINUX-SECTIONS1-LABEL:  foo.__part.1:
 ; LINUX-SECTIONS1-LABEL:  .LBB_END0_1:
-; LINUX-SECTIONS1-NEXT:        .size   foo.1, .LBB_END0_1-foo.1
+; LINUX-SECTIONS1-NEXT:        .size   foo.__part.1, .LBB_END0_1-foo.__part.1
 ; LINUX-SECTIONS1-NOT:    .section
 ; LINUX-SECTIONS1:    .section        .text.split.foo,"ax",@progbits
 ; LINUX-SECTIONS1-LABEL:  foo.cold:
 ; LINUX-SECTIONS1-LABEL:  .LBB_END0_3:
 ; LINUX-SECTIONS1-NEXT:        .size   foo.cold, .LBB_END0_3-foo.cold
 ; LINUX-SECTIONS1:      .section  .text.foo,"ax",@progbits
 ; LINUX-SECTIONS1-LABEL:  .Lfunc_end0:
 ; LINUX-SECTIONS1-NEXT:   .size foo, .Lfunc_end0-foo
 
 ; LINUX-SECTIONS2:    .section        .text.foo,"ax",@progbits
 ; LINUX-SECTIONS2-NOT:    .section
 ; LINUX-SECTIONS2-LABEL:  foo:
 ; LINUX-SECTIONS2-NOT:    .LBB_END0_{{0-9}}+
 ; LINUX-SECTIONS2-NOT:    .section
 ; LINUX-SECTIONS2-LABEL:  # %bb.2:
 ; LINUX-SECTIONS2-NOT:    .LBB_END0_{{0-9}}+
 ; LINUX-SECTIONS2:    .section        .text.foo,"ax",@progbits,unique,1
-; LINUX-SECTIONS2-NEXT:   foo.0:
+; LINUX-SECTIONS2-NEXT:   foo.__part.0:
 ; LINUX-SECTIONS2-NOT:    .LBB_END0_{{0-9}}+
 ; LINUX-SECTIONS2-NOT:    .section
 ; LINUX-SECTIONS2-LABEL:  .LBB0_3:
 ; LINUX-SECTIONS2-LABEL:  .LBB_END0_3:
-; LINUX-SECTIONS2-NEXT:        .size   foo.0, .LBB_END0_3-foo.0
+; LINUX-SECTIONS2-NEXT:        .size   foo.__part.0, .LBB_END0_3-foo.__part.0
 ; LINUX-SECTIONS2:    .section        .text.foo,"ax",@progbits
 ; LINUX-SECTIONS2-NOT:    .LBB_END0_{{0-9}}+
 ; LINUX-SECTIONS2-LABEL:  .Lfunc_end0:
 ; LINUX-SECTIONS2-NEXT:   .size foo, .Lfunc_end0-foo

llvm/test/CodeGen/X86/basic-block-sections-directjumps.ll

 
 declare i32 @_Z3barv() #1
 
 declare i32 @_Z3foov() #1
 
 
 ; LINUX-SECTIONS: .section        .text._Z3bazb,"ax",@progbits
 ; LINUX-SECTIONS: _Z3bazb:
-; LINUX-SECTIONS: jmp _Z3bazb.1
-; LINUX-SECTIONS: .section        .text._Z3bazb._Z3bazb.1,"ax",@progbits
-; LINUX-SECTIONS: _Z3bazb.1:
-; LINUX-SECTIONS: jmp _Z3bazb.2
-; LINUX-SECTIONS: .section        .text._Z3bazb._Z3bazb.2,"ax",@progbits
-; LINUX-SECTIONS: _Z3bazb.2:
-; LINUX-SECTIONS: jmp _Z3bazb.3
+; LINUX-SECTIONS: jmp _Z3bazb.__part.1
+; LINUX-SECTIONS: .section        .text._Z3bazb._Z3bazb.__part.1,"ax",@progbits
+; LINUX-SECTIONS: _Z3bazb.__part.1:
+; LINUX-SECTIONS: jmp _Z3bazb.__part.2
+; LINUX-SECTIONS: .section        .text._Z3bazb._Z3bazb.__part.2,"ax",@progbits
+; LINUX-SECTIONS: _Z3bazb.__part.2:
+; LINUX-SECTIONS: jmp _Z3bazb.__part.3

llvm/test/CodeGen/X86/basic-block-sections-eh.ll

 declare i32 @__gxx_personality_v0(...)
 ; Function Attrs: nounwind readnone
 declare i32 @llvm.eh.typeid.for(i8*) #1
 declare i8* @__cxa_begin_catch(i8*)
 declare void @__cxa_end_catch()
 
 ;LINUX-SECTIONS: .section .text._Z3foob,"ax",@progbits
 ;LINUX-SECTIONS: _Z3foob:
-;LINUX-SECTIONS: .section       .text._Z3foob._Z3foob.{{[0-9]+}},"ax",@progbits
-;LINUX-SECTIONS-LABEL: _Z3foob.{{[0-9]+}}:
+;LINUX-SECTIONS: .section       .text._Z3foob._Z3foob.__part.{{[0-9]+}},"ax",@progbits
+;LINUX-SECTIONS-LABEL: _Z3foob.__part.{{[0-9]+}}:
 ;LINUX-SECTIONS:        calll   __cxa_begin_catch

llvm/test/CodeGen/X86/basic-block-sections-list.ll

 
 13:                                               ; preds = %11, %9
   %14 = load i32, i32* %2, align 4
   ret i32 %14
 }
 
 ; LINUX-SECTIONS: .section        .text._Z3foob,"ax",@progbits
 ; LINUX-SECTIONS: _Z3foob:
-; LINUX-SECTIONS: .section        .text._Z3foob._Z3foob.1,"ax",@progbits
-; LINUX-SECTIONS: _Z3foob.1:
-; LINUX-SECTIONS: .section        .text._Z3foob._Z3foob.2,"ax",@progbits
-; LINUX-SECTIONS: _Z3foob.2:
-; LINUX-SECTIONS: .section        .text._Z3foob._Z3foob.3,"ax",@progbits
-; LINUX-SECTIONS: _Z3foob.3:
+; LINUX-SECTIONS: .section        .text._Z3foob._Z3foob.__part.1,"ax",@progbits
+; LINUX-SECTIONS: _Z3foob.__part.1:
+; LINUX-SECTIONS: .section        .text._Z3foob._Z3foob.__part.2,"ax",@progbits
+; LINUX-SECTIONS: _Z3foob.__part.2:
+; LINUX-SECTIONS: .section        .text._Z3foob._Z3foob.__part.3,"ax",@progbits
+; LINUX-SECTIONS: _Z3foob.__part.3:
 
 ; LINUX-SECTIONS: .section        .text._Z3zipb,"ax",@progbits
 ; LINUX-SECTIONS: _Z3zipb:
-; LINUX-SECTIONS-NOT: .section        .text._Z3zipb._Z3zipb.{{[0-9]+}},"ax",@progbits
-; LINUX-SECTIONS-NOT: _Z3zipb.{{[0-9]+}}:
+; LINUX-SECTIONS-NOT: .section        .text._Z3zipb._Z3zipb.__part.{{[0-9]+}},"ax",@progbits
+; LINUX-SECTIONS-NOT: _Z3zipb.__part.{{[0-9]+}}:

llvm/test/CodeGen/X86/basic-block-sections-listbb.ll

 
 declare i32 @_Z3foov() #1
 
 ; Check that the correct block is found using the call insts for foo and bar.
 ;
 ; LINUX-SECTIONS: .section        .text._Z3bazb,"ax",@progbits
 ; LINUX-SECTIONS: _Z3bazb:
 ; Check that the basic block with id 1 doesn't get a section.
-; LINUX-SECTIONS-NOT: .section        .text._Z3bazb._Z3bazb.{{[0-9]+}},"ax",@progbits
+; LINUX-SECTIONS-NOT: .section        .text._Z3bazb._Z3bazb.__part.{{[0-9]+}},"ax",@progbits
 ; LINUX-SECTIONS-LABEL: # %bb.1:
 ; LINUX-SECTIONS-NEXT:        callq   _Z3barv
-; LINUX-SECTIONS: .section        .text._Z3bazb.[[SECTION_LABEL:_Z3bazb.[0-9]+]],"ax",@progbits
+; LINUX-SECTIONS: .section        .text._Z3bazb.[[SECTION_LABEL:_Z3bazb.__part.[0-9]+]],"ax",@progbits
 ; LINUX-SECTIONS-NEXT: [[SECTION_LABEL]]:
 ; LINUX-SECTIONS-NEXT:        callq   _Z3foov
 ; LINUX-SECTIONS: .LBB_END0_2:
 ; LINUX-SECTIONS-NEXT: .size   [[SECTION_LABEL]], .LBB_END0_2-[[SECTION_LABEL]]
 ; LINUX-SECTIONS: .section        .text._Z3bazb,"ax",@progbits
 ; LINUX-SECTIONS: .Lfunc_end0:
 ; LINUX-SECTIONS-NEXT: .size _Z3bazb, .Lfunc_end0-_Z3bazb

llvm/test/CodeGen/X86/basic-block-sections-mir-parse.mir

bb.3 (%ir-block.9, bbsections 3):
     $rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp
     CFI_INSTRUCTION def_cfa $rsp, 8
     RETQ implicit $eax
 
 ...
 
 # CHECK: _Z3foob:
 # CHECK: .section .text,"ax",@progbits,unique
-# CHECK: _Z3foob.1:
+# CHECK: _Z3foob.__part.1:
 # CHECK: .section .text,"ax",@progbits,unique
-# CHECK: _Z3foob.2:
+# CHECK: _Z3foob.__part.2:
 # CHECK: .section .text,"ax",@progbits,unique
-# CHECK: _Z3foob.3:
+# CHECK: _Z3foob.__part.3:

llvm/test/CodeGen/X86/basic-block-sections-unreachable.ll

 ; Check that basic block section is emitted when a non-entry block has no predecessors.
 ; RUN: llc < %s -mtriple=x86_64 -O0 -basic-block-sections=all | FileCheck %s --check-prefix=CHECK-SECTIONS
 ; RUN: llc < %s -mtriple=x86_64 -O0 | FileCheck %s --check-prefix=CHECK-NOSECTIONS
 define void @foo(i32* %bar) {
   %v = load i32, i32* %bar
   switch i32 %v, label %default [
     i32 0, label %target
   ]
 target:
   ret void
 ;; This is the block which will not have any predecessors. If the block is not garbage collected, it must
 ;; be placed in a basic block section with a corresponding symbol.
 default:
   unreachable
 ; CHECK-NOSECTIONS:     # %bb.2:     # %default
 ; CHECK-SECTIONS:       .section .text,"ax",@progbits,unique,2
-; CHECK-SECTIONS-NEXT:  foo.2:       # %default
+; CHECK-SECTIONS-NEXT:  foo.__part.2:       # %default
 }

llvm/test/CodeGen/X86/basic-block-sections.ll

 
 declare i32 @_Z3barv() #1
 
 declare i32 @_Z3foov() #1
 
 
 ; LINUX-SECTIONS: .section        .text._Z3bazb,"ax",@progbits
 ; LINUX-SECTIONS: _Z3bazb:
-; LINUX-SECTIONS: .section        .text._Z3bazb._Z3bazb.1,"ax",@progbits
-; LINUX-SECTIONS: _Z3bazb.1:
+; LINUX-SECTIONS: .section        .text._Z3bazb.[[SECTION_LABEL_1:_Z3bazb.__part.[0-9]+]],"ax",@progbits
+; LINUX-SECTIONS: [[SECTION_LABEL_1]]:
 ; LINUX-SECTIONS: .LBB_END0_1:
-; LINUX-SECTIONS-NEXT: .size   _Z3bazb.1, .LBB_END0_1-_Z3bazb.1
-; LINUX-SECTIONS: .section        .text._Z3bazb._Z3bazb.2,"ax",@progbits
-; LINUX-SECTIONS: _Z3bazb.2:
+; LINUX-SECTIONS-NEXT: .size  [[SECTION_LABEL_1]], .LBB_END0_1-[[SECTION_LABEL_1]]
+; LINUX-SECTIONS: .section        .text._Z3bazb.[[SECTION_LABEL_2:_Z3bazb.__part.[0-9]+]],"ax",@progbits
+; LINUX-SECTIONS: [[SECTION_LABEL_2]]:
 ; LINUX-SECTIONS: .LBB_END0_2:
-; LINUX-SECTIONS-NEXT: .size   _Z3bazb.2, .LBB_END0_2-_Z3bazb.2
+; LINUX-SECTIONS-NEXT: .size   [[SECTION_LABEL_2]], .LBB_END0_2-[[SECTION_LABEL_2]]

llvm/test/CodeGen/X86/basic-block-sections_2.ll

+; Check that the basic block sections suffix naming does not conflict with __cxx_global_var_init.N naming.
+; How to  generate this file:
+;; class A {
+;;  public:
+;;    A(bool a) { }
+;; };
+;;
+;; extern bool bar(int);
+;; A g_a(bar(5) ? bar(3) : false), g_b(true);
+;;
+;; $ clang -O1 -emit-llvm -S
+;;
+; __cxx_global_var_init has multiple basic blocks which will produce many sections.
+; RUN: llc < %s -mtriple=x86_64-pc-linux -function-sections -basic-block-sections=all -unique-basic-block-section-names | FileCheck %s
+
+; CHECK-LABEL: __cxx_global_var_init:
+; CHECK-LABEL: __cxx_global_var_init.__part.1:
+; CHECK-LABEL: __cxx_global_var_init.1:
+
+%class.A = type { i8 }
+
+$_ZN1AC2Eb = comdat any
+
+@g_a = dso_local global %class.A zeroinitializer, align 1
+@g_b = dso_local global %class.A zeroinitializer, align 1
[e-mail]_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_symcollision.cc, i8* null }]
+
+define internal fastcc void @__cxx_global_var_init() unnamed_addr section ".text.startup" {
+entry:
+  %call = call zeroext i1 @_Z3bari(i32 5)
+  br i1 %call, label %cond.true, label %cond.end
+
+cond.true:                                        ; preds = %entry
+  %call1 = call zeroext i1 @_Z3bari(i32 3)
+  br label %cond.end
+
+cond.end:                                         ; preds = %entry, %cond.true
+  %cond = phi i1 [ %call1, %cond.true ], [ false, %entry ]
+  call void @_ZN1AC2Eb(%class.A* nonnull @g_a, i1 zeroext %cond)
+  ret void
+}
+
+declare dso_local zeroext i1 @_Z3bari(i32) local_unnamed_addr
+
+define linkonce_odr dso_local void @_ZN1AC2Eb(%class.A* %this, i1 zeroext %a) unnamed_addr comdat align 2 {
+entry:
+  ret void
+}
+
+define internal fastcc void @__cxx_global_var_init.1() unnamed_addr  section ".text.startup" {
+entry:
+  call void @_ZN1AC2Eb(%class.A* nonnull @g_b, i1 zeroext true)
+  ret void
+}
+
+define internal void @_GLOBAL__sub_I_symcollision.cc()  section ".text.startup" {
+entry:
+  call fastcc void @__cxx_global_var_init()
+  call fastcc void @__cxx_global_var_init.1()
+  ret void
+}

llvm/test/CodeGen/X86/cfi-basic-block-sections-1.ll

 
 ; SECTIONS_CFI: _Z2f3b:
 ; SECTIONS_CFI: .cfi_startproc
 ; SECTIONS_CFI: .cfi_def_cfa_offset 16
 ; SECTIONS_CFI: .cfi_offset %rbp, -16
 ; SECTIONS_CFI: .cfi_def_cfa_register %rbp
 ; SECTIONS_CFI: .cfi_endproc
 
-; SECTIONS_CFI: _Z2f3b.1:
+; SECTIONS_CFI: _Z2f3b.__part.1:
 ; SECTIONS_CFI-NEXT: .cfi_startproc
 ; SECTIONS_CFI-NEXT: .cfi_def_cfa %rbp, 16
 ; SECTIONS_CFI-NEXT: .cfi_offset %rbp, -16
 ; SECTIONS_CFI: .cfi_endproc
 
-; SECTIONS_CFI: _Z2f3b.2:
+; SECTIONS_CFI: _Z2f3b.__part.2:
 ; SECTIONS_CFI-NEXT: .cfi_startproc
 ; SECTIONS_CFI-NEXT: .cfi_def_cfa %rbp, 16
 ; SECTIONS_CFI-NEXT: .cfi_offset %rbp, -16
 ; SECTIONS_CFI: .cfi_def_cfa
 ; SECTIONS_CFI: .cfi_endproc
 
 
 ; SECTIONS_NOFP_CFI: _Z2f3b:
 ; SECTIONS_NOFP_CFI: .cfi_startproc
 ; SECTIONS_NOFP_CFI: .cfi_def_cfa_offset 16
 ; SECTIONS_NOFP_CFI: .cfi_endproc
 
-; SECTIONS_NOFP_CFI: _Z2f3b.1:
+; SECTIONS_NOFP_CFI: _Z2f3b.__part.1:
 ; SECTIONS_NOFP_CFI-NEXT: .cfi_startproc
 ; SECTIONS_NOFP_CFI-NEXT: .cfi_def_cfa %rsp, 16
 ; SECTIONS_NOFP_CFI: .cfi_endproc
 
-; SECTIONS_NOFP_CFI: _Z2f3b.2:
+; SECTIONS_NOFP_CFI: _Z2f3b.__part.2:
 ; SECTIONS_NOFP_CFI-NEXT: .cfi_startproc
 ; SECTIONS_NOFP_CFI-NEXT: .cfi_def_cfa %rsp, 16
 ; SECTIONS_NOFP_CFI: .cfi_endproc
 
 
 ;; There must be 1 CIE and 3 FDEs.
 
 ; EH_FRAME: CIE

llvm/test/CodeGen/X86/cfi-inserter-basic-block-sections-callee-save-registers.ll

 ;; This test checks if CFI instructions for all callee saved registers are emitted
 ;; correctly with basic block sections.
 ; RUN: llc  %s -mtriple=x86_64 -filetype=asm --basic-block-sections=all --frame-pointer=all -o - | FileCheck --check-prefix=SECTIONS_CFI %s
 
 ; SECTIONS_CFI:       _Z3foob:
 ; SECTIONS_CFI:      .cfi_offset %rbp, -16
 ; SECTIONS_CFI:      .cfi_offset [[RA:%r.+]], -56
 ; SECTIONS_CFI-NEXT: .cfi_offset [[RB:%r.+]], -48
 ; SECTIONS_CFI-NEXT: .cfi_offset [[RC:%r.+]], -40
 ; SECTIONS_CFI-NEXT: .cfi_offset [[RD:%r.+]], -32
 ; SECTIONS_CFI-NEXT: .cfi_offset [[RE:%r.+]], -24
 
-; SECTIONS_CFI:      _Z3foob.1:
+; SECTIONS_CFI:      _Z3foob.__part.1:
 ; SECTIONS_CFI:      .cfi_offset %rbp, -16
 ; SECTIONS_CFI:      .cfi_offset [[RA]], -56
 ; SECTIONS_CFI-NEXT: .cfi_offset [[RB]], -48
 ; SECTIONS_CFI-NEXT: .cfi_offset [[RC]], -40
 ; SECTIONS_CFI-NEXT: .cfi_offset [[RD]], -32
 ; SECTIONS_CFI-NEXT: .cfi_offset [[RE]], -24
 
-; SECTIONS_CFI:      _Z3foob.2:
+; SECTIONS_CFI:      _Z3foob.__part.2:
 ; SECTIONS_CFI:      .cfi_offset %rbp, -16
 ; SECTIONS_CFI:      .cfi_offset [[RA]], -56
 ; SECTIONS_CFI-NEXT: .cfi_offset [[RB]], -48
 ; SECTIONS_CFI-NEXT: .cfi_offset [[RC]], -40
 ; SECTIONS_CFI-NEXT: .cfi_offset [[RD]], -32
 ; SECTIONS_CFI-NEXT: .cfi_offset [[RE]], -24
 
 

llvm/test/CodeGen/X86/gcc_except_table_bb_sections.ll

 ; CHECK-PIC-NEXT:       .cfi_lsda 27, .Lexception0
 
 ; CHECK-LABEL:        .Ltmp0:
 ; CHECK-NEXT:           callq   _Z1fv
 ; CHECK-LABEL:        .Ltmp1:
 
 ; CHECK-NOT:            .cfi_lsda
 
-; CHECK-LABEL:        main.1:
+; CHECK-LABEL:        main.__part.1:
 ; CHECK-NEXT:           .cfi_startproc
 
 ; CHECK-NON-PIC-NEXT:   .cfi_personality 3, __gxx_personality_v0
 ; CHECK-NON-PIC-NEXT:   .cfi_lsda 3, .Lexception1
 
 ; CHECK-PIC-NEXT:       .cfi_personality 155, DW.ref.__gxx_personality_v0
 ; CHECK-PIC-NEXT:       .cfi_lsda 27, .Lexception1
 
 ; CHECK-NOT:            .cfi_lsda
 
-; CHECK-LABEL:        main.2:
+; CHECK-LABEL:        main.__part.2:
 ; CHECK-NEXT:           .cfi_startproc
 
 ; CHECK-NON-PIC-NEXT:   .cfi_personality 3, __gxx_personality_v0
 ; CHECK-NON-PIC-NEXT:   .cfi_lsda 3, .Lexception2
 
 ; CHECK-PIC-NEXT:       .cfi_personality 155, DW.ref.__gxx_personality_v0
 ; CHECK-PIC-NEXT:       .cfi_lsda 27, .Lexception2
 

 ;
 ; CHECK:                .section .gcc_except_table
 ; CHECK-NEXT:           .p2align 2
 ; CHECK-NEXT:         GCC_except_table0:
 ; CHECK-NEXT:         .Lexception0:
 
 ;; Verify @LPStart encoding for NON-PIC mode.
 ; CHECK-NON-PIC-NEXT:   .byte 0                       # @LPStart Encoding = absptr
-; CHECK-NON-PIC-NEXT:   .quad main.2
+; CHECK-NON-PIC-NEXT:   .quad main.__part.2
 
 ;; Verify @LPStart encoding for PIC mode.
 ; CHECK-PIC-NEXT:       .byte 16                      # @LPStart Encoding = pcrel
 ; CHECK-PIC-NEXT:     [[DOT:\.Ltmp[0-9]+]]:
-; CHECK-PIC-NEXT:       .quad main.2-[[DOT]]
+; CHECK-PIC-NEXT:       .quad main.__part.2-[[DOT]]
 
 ;; Verify @TType encoding for NON-PIC mode.
 ; CHECK-NON-PIC-NEXT:   .byte 3                       # @TType Encoding = udata4
 
 ;; Verify @TType encoding for PIC mode.
 ; CHECK-PIC-NEXT:       .byte 156                       # @TType Encoding = indirect pcrel sdata8
 
 ; CHECK-NEXT:           .uleb128 .Lttbase0-.Lttbaseref0
 ; CHECK-NEXT:         .Lttbaseref0:
 ; CHECK-NEXT:           .byte 1                       # Call site Encoding = uleb128
 ; CHECK-NEXT:           .uleb128 .Laction_table_base0-.Lcst_begin0
 ; CHECK-NEXT:         .Lcst_begin0:
 ; CHECK-NEXT:           .uleb128 .Ltmp0-.Lfunc_begin0   # >> Call Site 1 <<
 ; CHECK-NEXT:           .uleb128 .Ltmp1-.Ltmp0          #   Call between .Ltmp0 and .Ltmp1
-; CHECK-NEXT:           .uleb128 .Ltmp2-main.2          #     jumps to .Ltmp2
+; CHECK-NEXT:           .uleb128 .Ltmp2-main.__part.2          #     jumps to .Ltmp2
 ; CHECK-NEXT:           .byte 3                       #   On action: 2
 ; CHECK-NEXT:           .p2align  2
 ; CHECK-NEXT:         .Lexception1:
 
 ; CHECK-NON-PIC-NEXT:   .byte 0                       # @LPStart Encoding = absptr
-; CHECK-NON-PIC-NEXT:   .quad main.2
+; CHECK-NON-PIC-NEXT:   .quad main.__part.2
 
 ; CHECK-PIC-NEXT:       .byte 16                      # @LPStart Encoding = pcrel
 ; CHECK-PIC-NEXT:     [[DOT:\.Ltmp[0-9]+]]:
-; CHECK-PIC-NEXT:       .quad main.2-[[DOT]]
+; CHECK-PIC-NEXT:       .quad main.__part.2-[[DOT]]
 
 ; CHECK-NON-PIC-NEXT:   .byte 3                       # @TType Encoding = udata4
 
 ; CHECK-PIC-NEXT:       .byte 156                       # @TType Encoding = indirect pcrel sdata8
 
 ; CHECK-NEXT:           .uleb128 .Lttbase0-.Lttbaseref1
 ; CHECK-NEXT:         .Lttbaseref1:
 ; CHECK-NEXT:           .byte 1                       # Call site Encoding = uleb128
 ; CHECK-NEXT:           .uleb128 .Laction_table_base0-.Lcst_begin1
 ; CHECK-NEXT:         .Lcst_begin1:
 ; CHECK-NEXT:           .p2align 2
 ; CHECK-NEXT:         .Lexception2:
 
 ; CHECK-NON-PIC-NEXT:   .byte 0                       # @LPStart Encoding = absptr
-; CHECK-NON-PIC-NEXT:   .quad main.2
+; CHECK-NON-PIC-NEXT:   .quad main.__part.2
 
 ; CHECK-PIC-NEXT:       .byte 16                      # @LPStart Encoding = pcrel
 ; CHECK-PIC-NEXT:     [[DOT:\.Ltmp[0-9]+]]:
-; CHECK-PIC-NEXT:       .quad main.2-[[DOT]]
+; CHECK-PIC-NEXT:       .quad main.__part.2-[[DOT]]
 
 ; CHECK-NON-PIC-NEXT:   .byte 3                       # @TType Encoding = udata4
 
 ; CHECK-PIC-NEXT:       .byte 156                       # @TType Encoding = indirect pcrel sdata8
 
 ; CHECK-NEXT:           .uleb128 .Lttbase0-.Lttbaseref2
 ; CHECK-NEXT:         .Lttbaseref2:
 ; CHECK-NEXT:           .byte 1                       # Call site Encoding = uleb128
 ; CHECK-NEXT:           .uleb128 .Laction_table_base0-.Lcst_begin2
 ; CHECK-NEXT:         .Lcst_begin2:
-; CHECK-NEXT:           .uleb128 main.2-main.2          # >> Call Site 2 <<
-; CHECK-NEXT:           .uleb128 .LBB_END0_2-main.2     #   Call between main.2 and .LBB_END0_2
+; CHECK-NEXT:           .uleb128 main.__part.2-main.__part.2          # >> Call Site 2 <<
+; CHECK-NEXT:           .uleb128 .LBB_END0_2-main.__part.2     #   Call between main.__part.2 and .LBB_END0_2
 ; CHECK-NEXT:           .byte 0                       #     has no landing pad
 ; CHECK-NEXT:           .byte 0                       #   On action: cleanup
 ; CHECK-NEXT:         .Laction_table_base0:
 ; CHECK-NEXT:           .byte 0                       # >> Action Record 1 <<
 ; CHECK-NEXT:                                           #   Cleanup
 ; CHECK-NEXT:           .byte 0                       #   No further actions
 ; CHECK-NEXT:           .byte 1                       # >> Action Record 2 <<
 ; CHECK-NEXT:                                           #   Catch TypeInfo 1

llvm/test/DebugInfo/X86/basic-block-sections_1.ll

 ; 4    else
 ; 5      return 0;
 ; 6  }
 
 ; NO-SECTIONS: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000 ".text")
 ; NO-SECTIONS: DW_AT_high_pc [DW_FORM_data4] ({{.*}})
 ; BB-SECTIONS: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000)
 ; BB-SECTIONS-NEXT: DW_AT_ranges [DW_FORM_sec_offset]
-; BB-SECTIONS-NEXT: [{{.*}}) ".text._Z3fooi.1"
-; BB-SECTIONS-NEXT: [{{.*}}) ".text._Z3fooi.2"
-; BB-SECTIONS-NEXT: [{{.*}}) ".text._Z3fooi.3"
+; BB-SECTIONS-NEXT: [{{.*}}) ".text._Z3fooi.__part.1"
+; BB-SECTIONS-NEXT: [{{.*}}) ".text._Z3fooi.__part.2"
+; BB-SECTIONS-NEXT: [{{.*}}) ".text._Z3fooi.__part.3"
 ; BB-SECTIONS-NEXT: [{{.*}}) ".text"
 ; BB-SECTIONS-ASM: _Z3fooi:
 ; BB-SECTIONS-ASM: .Ltmp{{[0-9]+}}:
 ; BB-SECTIONS-ASM-NEXT: .loc 1 2 9 prologue_end
 ; BB-SECTIONS-ASM: .Ltmp{{[0-9]+}}:
 ; BB-SECTIONS-ASM-NEXT: .loc 1 2 7 is_stmt
-; BB-SECTIONS-ASM: _Z3fooi.1:
+; BB-SECTIONS-ASM: _Z3fooi.__part.1:
 ; BB-SECTIONS-ASM: .LBB_END0_{{[0-9]+}}:
-; BB-SECTIONS-ASM: .size  _Z3fooi.1, .LBB_END0_{{[0-9]+}}-_Z3fooi.1
-; BB-SECTIONS-ASM: _Z3fooi.2:
+; BB-SECTIONS-ASM: .size  _Z3fooi.__part.1, .LBB_END0_{{[0-9]+}}-_Z3fooi.__part.1
+; BB-SECTIONS-ASM: _Z3fooi.__part.2:
 ; BB-SECTIONS-ASM: .Ltmp{{[0-9]+}}:
 ; BB-SECTIONS-ASM-NEXT: .LBB_END0_{{[0-9]+}}:
-; BB-SECTIONS-ASM: .size  _Z3fooi.2, .LBB_END0_{{[0-9]+}}-_Z3fooi.2
-; BB-SECTIONS-ASM: _Z3fooi.3:
+; BB-SECTIONS-ASM: .size  _Z3fooi.__part.2, .LBB_END0_{{[0-9]+}}-_Z3fooi.__part.2
+; BB-SECTIONS-ASM: _Z3fooi.__part.3:
 ; BB-SECTIONS-ASM: .Ltmp{{[0-9]+}}:
 ; BB-SECTIONS-ASM-NEXT: .LBB_END0_{{[0-9]+}}:
-; BB-SECTIONS-ASM: .size  _Z3fooi.3, .LBB_END0_{{[0-9]+}}-_Z3fooi.3
+; BB-SECTIONS-ASM: .size  _Z3fooi.__part.3, .LBB_END0_{{[0-9]+}}-_Z3fooi.__part.3
 ; BB-SECTIONS-ASM: .Lfunc_end0:
 ; BB-SECTIONS-ASM: .Ldebug_ranges0:
-; BB-SECTIONS-ASM-NEXT: .quad _Z3fooi.1
+; BB-SECTIONS-ASM-NEXT: .quad _Z3fooi.__part.1
 ; BB-SECTIONS-ASM-NEXT: .quad .LBB_END0_{{[0-9]+}}
-; BB-SECTIONS-ASM-NEXT: .quad _Z3fooi.2
+; BB-SECTIONS-ASM-NEXT: .quad _Z3fooi.__part.2
 ; BB-SECTIONS-ASM-NEXT: .quad .LBB_END0_{{[0-9]+}}
-; BB-SECTIONS-ASM-NEXT: .quad _Z3fooi.3
+; BB-SECTIONS-ASM-NEXT: .quad _Z3fooi.__part.3
 ; BB-SECTIONS-ASM-NEXT: .quad .LBB_END0_{{[0-9]+}}
 ; BB-SECTIONS-ASM-NEXT: .quad .Lfunc_begin0
 ; BB-SECTIONS-ASM-NEXT: .quad .Lfunc_end0
 ; BB-SECTIONS-ASM-NEXT: .quad 0
 ; BB-SECTIONS-ASM-NEXT: .quad 0
 ; BB-SECTIONS-LINE-TABLE:      0x0000000000000000 1 0 1 0 0 is_stmt
 ; BB-SECTIONS-LINE-TABLE-NEXT: 0x0000000000000004 2 9 1 0 0 is_stmt prologue_end
 ; BB-SECTIONS-LINE-TABLE-NEXT: 0x0000000000000009 2 7 1 0 0