[hot-cold-split] Name split functions with ".cold" suffix

[tejohnson]

Summary

The current default of appending "_"+entry block label to the new
extracted cold function breaks demangling. Change this to ".cold" for hot
cold splitting (other uses of CodeExtractor still use old naming), since
the demangler knows how to handle suffixes starting with ".". This
is also consistent with how gcc names the split cold functions.

[sebpop]

lib/Transforms/Utils/CodeExtractor.cpp

682

In the case of more than one region extracted from a function, this code may create functions with identical names which would create link problems.

[tejohnson]

lib/Transforms/Utils/CodeExtractor.cpp

682

Will the hot cold split pass extract more than one cold function from a single function?

[sebpop]

lib/Transforms/Utils/CodeExtractor.cpp

682

Yes with https://reviews.llvm.org/D53588

[tejohnson]

lib/Transforms/Utils/CodeExtractor.cpp

682

Ok I see. It would make sense then to append a unique id, which could be the header name. Also we may in general want to change the "_" here to a "." so that the demangler handles it appropriately, regardless of whether we change the suffix after that deliminator.

I did see in my internal project that a lot of the cold split funcs actually ended with "_" without any header label - I need to go back and investigate - do we have empty header names in some cases? Because if so, with splitting into multiple funcs we will also end up with name collisions. Let me take another look...

[tejohnson]

lib/Transforms/Utils/CodeExtractor.cpp

682

When the IR is generated by a release built clang, the bb labels are empty. So that will cause issues with your D53588 patch, since all outlined funcs will be named original name + "_". So they need to use some other id when the name is empty. Perhaps the client of CodeExtractor needs to supply a unique id (for hot cold split you could just enumerate the split out functions for each original function and use that as a unique id).

[tejohnson]

lib/Transforms/Utils/CodeExtractor.cpp

682

Ok I reworked the patch a bit:

1. Always use "." as the delimiter for the suffix instead of "_" to enable demangling
2. If the label is empty and no suffix passed in from client, use "extracted" after the "." (the demangler needs something after the "." to handle it correctly).
3. Pass in "cold."+Count from the hot cold splitting pass as the suffix, where Count is currently hardwired to 1 but after D53588 can be changed to be a monotonically increasing count of the functions split from a single function.

I will upload the patch momentarily.

I just realized though, that we will still have problems if the hot cold split pass is ever run multiple times, which after D53437 is only an issue with the ThinLTO newPM. I will send a separate patch to fix that, that will need to land before this one.

[xbolva00]

Does the pass groups hot code together? is it in your plans?

[tejohnson]

In D53534#1273164, @xbolva00 wrote:

Does the pass groups hot code together? is it in your plans?

@sebpop, @vsk or @hiraditya can probably answer this. I'm not working on the core hot cold splitting algorithm, just some issues I'm finding as I try it. But presumably the linker should be grouping the split hot functions together and the split cold functions together, when building with -ffunction-sections and PGO which should put them in the .text.hot and .text.unlikely sections, respectively.

[tejohnson]

1. Always use "." as the delimiter for the suffix instead of "_" to enable demangling
2. If the label is empty and no suffix passed in from client, use "extracted" after the "." (the demangler needs something after the "." to handle it correctly).
3. Pass in "cold."+Count from the hot cold splitting pass as the suffix, where Count is currently hardwired to 1 but after D53588 can be changed to be a monotonically increasing count of the functions split from a single function.

Unfortunately change 1) required many test changes.

[sebpop]

The change looks good with some minor changes. Thanks!

lib/Transforms/IPO/HotColdSplitting.cpp

345

Given the commit message: Pass in "cold."+Count
I think the above statement is missing the dot after cold:

/* Suffix */ "cold." + std::to_string(Count));

424

I like this change, makes it very easy to get unique function names.

test/Transforms/HotColdSplit/split-cold-2.ll

7

I was expecting to see an integer appended to "cold" like so "fun.cold.1"

[tejohnson]

lib/Transforms/IPO/HotColdSplitting.cpp

345

Indeed, this was missing the ".", fixed.

test/Transforms/HotColdSplit/split-cold-2.ll

7

Yep, it was passing because of the partial match working. I added the ".1" (which in fact would have caught the oversight you pointed out earlier in the code!).

[tejohnson]

Address comments

[vsk]

In D53534#1273174, @tejohnson wrote:

In D53534#1273164, @xbolva00 wrote:

Does the pass groups hot code together? is it in your plans?

@sebpop, @vsk or @hiraditya can probably answer this. I'm not working on the core hot cold splitting algorithm, just some issues I'm finding as I try it. But presumably the linker should be grouping the split hot functions together and the split cold functions together, when building with -ffunction-sections and PGO which should put them in the .text.hot and .text.unlikely sections, respectively.

The pass currently does not group hot or cold code together. Teresa's explanation is correct -- we'll need linker support to do that. On Darwin I have plans to implement this by adding a section modifier (similar to live_support), as this doesn't require creating a new section or messing with order files.

[sebpop]

ok

include/llvm/Transforms/Utils/CodeExtractor.h

class CodeExtractor {
     // If true, varargs functions can be extracted.
     bool AllowVarArgs;
 
     // Bits of intermediate state computed at various phases of extraction.
     SetVector<BasicBlock *> Blocks;
     unsigned NumExitBlocks = std::numeric_limits<unsigned>::max();
     Type *RetTy;
 
+    // Suffix to use when creating extracted function (appended to the original
+    // function name + "."). If empty, the default is to use the entry block
+    // label, if non-empty, otherwise "extracted".
+    std::string Suffix;
+
   public:
     /// Create a code extractor for a sequence of blocks.
     ///
     /// Given a sequence of basic blocks where the first block in the sequence
     /// dominates the rest, prepare a code extractor object for pulling this
     /// sequence out into its new function. When a DominatorTree is also given,
     /// extra checking and transformations are enabled. If AllowVarArgs is true,
     /// vararg functions can be extracted. This is safe, if all vararg handling
     /// code is extracted, including vastart. If AllowAlloca is true, then
     /// extraction of blocks containing alloca instructions would be possible,
     /// however code extractor won't validate whether extraction is legal.
     CodeExtractor(ArrayRef<BasicBlock *> BBs, DominatorTree *DT = nullptr,
                   bool AggregateArgs = false, BlockFrequencyInfo *BFI = nullptr,
                   BranchProbabilityInfo *BPI = nullptr,
-                  bool AllowVarArgs = false, bool AllowAlloca = false);
+                  bool AllowVarArgs = false, bool AllowAlloca = false,
+                  std::string Suffix = "");
 
     /// Create a code extractor for a loop body.
     ///
     /// Behaves just like the generic code sequence constructor, but uses the
     /// block sequence of the loop.
     CodeExtractor(DominatorTree &DT, Loop &L, bool AggregateArgs = false,
                   BlockFrequencyInfo *BFI = nullptr,
-                  BranchProbabilityInfo *BPI = nullptr);
+                  BranchProbabilityInfo *BPI = nullptr,
+                  std::string Suffix = "");
 
     /// Perform the extraction, returning the new function.
     ///
     /// Returns zero when called on a CodeExtractor instance where isEligible
     /// returns false.
     Function *extractCodeRegion();
 
     /// Test whether this code extractor is eligible.

lib/Transforms/IPO/HotColdSplitting.cpp

public:
   bool run(Module &M);
 
 private:
   bool shouldOutlineFrom(const Function &F) const;
   const Function *outlineColdBlocks(Function &F, const DenseSetBB &ColdBlock,
                                     DominatorTree *DT, PostDomTree *PDT);
   Function *extractColdRegion(const SmallVectorImpl<BasicBlock *> &Region,
                               DominatorTree *DT, BlockFrequencyInfo *BFI,
-                              OptimizationRemarkEmitter &ORE);
+                              OptimizationRemarkEmitter &ORE, unsigned Count);
   bool isOutlineCandidate(const SmallVectorImpl<BasicBlock *> &Region,
                           const BasicBlock *Exit) const {
     if (!Exit)
       return false;
 
     // Regions with landing pads etc.
     for (const BasicBlock *BB : Region) {
       if (BB->isEHPad() || BB->hasAddressTaken())
bool HotColdSplitting::shouldOutlineFrom(const Function &F) const {
   if (F.getCallingConv() == CallingConv::Cold)
     return false;
 
   if (PSI->isFunctionEntryCold(&F))
     return false;
   return true;
 }
 
-Function *
-HotColdSplitting::extractColdRegion(const SmallVectorImpl<BasicBlock *> &Region,
-                                    DominatorTree *DT, BlockFrequencyInfo *BFI,
-                                    OptimizationRemarkEmitter &ORE) {
+Function *HotColdSplitting::extractColdRegion(
+    const SmallVectorImpl<BasicBlock *> &Region, DominatorTree *DT,
+    BlockFrequencyInfo *BFI, OptimizationRemarkEmitter &ORE, unsigned Count) {
   assert(!Region.empty());
   LLVM_DEBUG(for (auto *BB : Region)
           llvm::dbgs() << "\nExtracting: " << *BB;);
 
   // TODO: Pass BFI and BPI to update profile information.
-  CodeExtractor CE(Region, DT);
+  CodeExtractor CE(Region, DT, /* AggregateArgs */ false, /* BFI */ nullptr,
+                   /* BPI */ nullptr, /* AllowVarArgs */ false,
+                   /* AllowAlloca */ false,
+                   /* Suffix */ "cold" + std::to_string(Count));
 
   SetVector<Value *> Inputs, Outputs, Sinks;
   CE.findInputsOutputs(Inputs, Outputs, Sinks);
 
   // Do not extract regions that have live exit variables.
   if (Outputs.size() > 0)
     return nullptr;
 
if (PSI->isColdBB(BB, BFI) || !HotBlocks.count(BB)) {
       if (ExitColdRegion) {
         // Do not outline a region with only one block.
         if (ValidColdRegion.size() == 1)
           continue;
 
         ++NumColdSESEFound;
         ValidColdRegion.push_back(ExitColdRegion);
         // Candidate for outlining. FIXME: Continue outlining.
-        return extractColdRegion(ValidColdRegion, DT, BFI, ORE);
+        return extractColdRegion(ValidColdRegion, DT, BFI, ORE, /* Count */ 1);
       }
     }
   }
   return nullptr;
 }
 
 bool HotColdSplitting::run(Module &M) {
   for (auto &F : M) {

lib/Transforms/Utils/CodeExtractor.cpp

buildExtractionBlockSet(ArrayRef<BasicBlock *> BBs, DominatorTree *DT,
   }
 
   return Result;
 }
 
 CodeExtractor::CodeExtractor(ArrayRef<BasicBlock *> BBs, DominatorTree *DT,
                              bool AggregateArgs, BlockFrequencyInfo *BFI,
                              BranchProbabilityInfo *BPI, bool AllowVarArgs,
-                             bool AllowAlloca)
+                             bool AllowAlloca, std::string Suffix)
     : DT(DT), AggregateArgs(AggregateArgs || AggregateArgsOpt), BFI(BFI),
       BPI(BPI), AllowVarArgs(AllowVarArgs),
-      Blocks(buildExtractionBlockSet(BBs, DT, AllowVarArgs, AllowAlloca)) {}
+      Blocks(buildExtractionBlockSet(BBs, DT, AllowVarArgs, AllowAlloca)),
+      Suffix(Suffix) {}
 
 CodeExtractor::CodeExtractor(DominatorTree &DT, Loop &L, bool AggregateArgs,
                              BlockFrequencyInfo *BFI,
-                             BranchProbabilityInfo *BPI)
+                             BranchProbabilityInfo *BPI, std::string Suffix)
     : DT(&DT), AggregateArgs(AggregateArgs || AggregateArgsOpt), BFI(BFI),
       BPI(BPI), AllowVarArgs(false),
       Blocks(buildExtractionBlockSet(L.getBlocks(), &DT,
                                      /* AllowVarArgs */ false,
-                                     /* AllowAlloca */ false)) {}
+                                     /* AllowAlloca */ false)),
+      Suffix(Suffix) {}
 
 /// definedInRegion - Return true if the specified value is defined in the
 /// extracted region.
 static bool definedInRegion(const SetVector<BasicBlock *> &Blocks, Value *V) {
   if (Instruction *I = dyn_cast<Instruction>(V))
     if (Blocks.count(I->getParent()))
       return true;
   return false;
if (AggregateArgs && (inputs.size() + outputs.size() > 0)) {
     StructTy = StructType::get(M->getContext(), paramTy);
     paramTy.clear();
     paramTy.push_back(PointerType::getUnqual(StructTy));
   }
   FunctionType *funcType =
                   FunctionType::get(RetTy, paramTy,
                                     AllowVarArgs && oldFunction->isVarArg());
 
+  std::string SuffixToUse =
+      Suffix.empty()
+          ? (header->getName().empty() ? "extracted" : header->getName().str())
+          : Suffix;
   // Create the new function
   Function *newFunction = Function::Create(
       funcType, GlobalValue::InternalLinkage, oldFunction->getAddressSpace(),
-      oldFunction->getName() + "_" + header->getName(), M);
+      oldFunction->getName() + "." + SuffixToUse, M);
   // If the old function is no-throw, so is the new one.
   if (oldFunction->doesNotThrow())
     newFunction->setDoesNotThrow();
 
   // Inherit the uwtable attribute if we need to.
   if (oldFunction->hasUWTable())
     newFunction->setHasUWTable();
 
   // Inherit all of the target dependent attributes and white-listed

test/Transforms/BlockExtractor/extract-blocks.ll

 ; RUN: echo 'foo bb9' > %t
 ; RUN: echo 'foo bb20' >> %t
 ; RUN: opt -S -extract-blocks -extract-blocks-file=%t %s | FileCheck %s --check-prefix=CHECK-NO-ERASE
 ; RUN: opt -S -extract-blocks -extract-blocks-file=%t -extract-blocks-erase-funcs %s | FileCheck %s --check-prefix=CHECK-ERASE
 
 ; CHECK-NO-ERASE: @foo(
-; CHECK-NO-ERASE: @foo_bb9(
-; CHECK-NO-ERASE: @foo_bb20(
+; CHECK-NO-ERASE: @foo.bb9(
+; CHECK-NO-ERASE: @foo.bb20(
 ; CHECK-ERASE: declare i32 @foo(
-; CHECK-ERASE: @foo_bb9(
-; CHECK-ERASE: @foo_bb20(
+; CHECK-ERASE: @foo.bb9(
+; CHECK-ERASE: @foo.bb20(
 define i32 @foo(i32 %arg, i32 %arg1) {
 bb:
   %tmp5 = icmp sgt i32 %arg, 0
   %tmp8 = icmp sgt i32 %arg1, 0
   %or.cond = and i1 %tmp5, %tmp8
   br i1 %or.cond, label %bb9, label %bb14
 
 bb9:                                              ; preds = %bb

test/Transforms/CodeExtractor/ExtractedFnEntryCount.ll

 
 
 define internal i32 @dummyCaller(i1 %cond) !prof !1 {
 entry:
   %val = call i32 @inlinedFunc(i1 %cond)
   ret i32 %val
 }
 
-; CHECK: @inlinedFunc.1_if.then(i1 %cond) !prof [[COUNT1:![0-9]+]]
+; CHECK: @inlinedFunc.1.if.then(i1 %cond) !prof [[COUNT1:![0-9]+]]
 
 
 !llvm.module.flags = !{!0}
 ; CHECK: [[COUNT1]] = !{!"function_entry_count", i64 250}
 !0 = !{i32 1, !"MaxFunctionCount", i32 1000}
 !1 = !{!"function_entry_count", i64 1000}
 !2 = !{!"branch_weights", i32 250, i32 750}
 !3 = !{!"branch_weights", i32 125, i32 125}

test/Transforms/CodeExtractor/PartialInlineAnd.ll

 declare void @foo(...) local_unnamed_addr #1
 
 ; Function Attrs: nounwind uwtable
 define i32 @dummy_caller(i32 %arg) local_unnamed_addr #0 {
 bb:
 ; CHECK-LABEL: @dummy_caller
 ; CHECK: br i1
 ; CHECK: br i1
-; CHECK: call void @bar.1_
+; CHECK: call void @bar.1.
 ; LIMIT-LABEL: @dummy_caller
 ; LIMIT: br i1
 ; LIMIT-NOT: br
-; LIMIT: call void @bar.1_
+; LIMIT: call void @bar.1.
   %tmp = tail call i32 @bar(i32 %arg)
   ret i32 %tmp
 }
 
 attributes #0 = { nounwind }
 attributes #1 = { nounwind }
 attributes #2 = { nounwind }
 

test/Transforms/CodeExtractor/PartialInlineAndOr.ll

 
 ; Function Attrs: nounwind uwtable
 define i32 @dummy_caller(i32 %arg) local_unnamed_addr #0 {
 bb:
 ; CHECK-LABEL: @dummy_caller
 ; CHECK: br i1
 ; CHECK: br i1
 ; CHECK: br i1
-; CHECK: call void @bar.1_
+; CHECK: call void @bar.1.
 ; LIMIT-LABEL: @dummy_caller
 ; LIMIT-NOT: br i1
 ; LIMIT: call i32 @bar
   %tmp = tail call i32 @bar(i32 %arg)
   ret i32 %tmp
 }
 
 attributes #0 = { nounwind } 
 attributes #1 = { nounwind }
 attributes #2 = { nounwind }
 

test/Transforms/CodeExtractor/PartialInlineAttributes.ll

if.then2:
   br label %if.end
 
 if.end:
   %v2 = phi i32 [ %v, %entry ], [ %sub, %if.then2 ]
   %add = add nsw i32 %v2, 200
   ret i32 %add
 }
 ; CHECK-LABEL: @caller
-; CHECK: call void @callee_most.2_if.then(i32 %v
+; CHECK: call void @callee_most.2.if.then(i32 %v
 ; CHECK: call i32 @callee_noinline(i32 %v)
-; CHECK: call void @callee_writeonly.1_if.then(i32 %v
+; CHECK: call void @callee_writeonly.1.if.then(i32 %v
 define i32 @caller(i32 %v) {
 entry:
   %c1 = call i32 @callee_most(i32 %v)
   %c2 = call i32 @callee_noinline(i32 %v)
   %c3 = call i32 @callee_writeonly(i32 %v)
   ret i32 %c3
 }
 
-; CHECK: define internal void @callee_writeonly.1_if.then(i32 %v, i32* %sub.out) { 
-; CHECK: define internal void @callee_most.2_if.then(i32 %v, i32* %sub.out)  [[FN_ATTRS:#[0-9]+]]
+; CHECK: define internal void @callee_writeonly.1.if.then(i32 %v, i32* %sub.out) { 
+; CHECK: define internal void @callee_most.2.if.then(i32 %v, i32* %sub.out)  [[FN_ATTRS:#[0-9]+]]
 
 ; attributes to preserve
 attributes #0 = {
   inlinehint minsize noduplicate noimplicitfloat norecurse noredzone nounwind
   nonlazybind optsize safestack sanitize_address sanitize_hwaddress sanitize_memory
   sanitize_thread ssp sspreq sspstrong strictfp uwtable "foo"="bar"
   "patchable-function"="prologue-short-redirect" "probe-stack"="_foo_guard" "stack-probe-size"="4096" }
 
 ; CHECK: attributes [[FN_ATTRS]] = { inlinehint minsize noduplicate noimplicitfloat norecurse noredzone nounwind nonlazybind optsize safestack sanitize_address sanitize_hwaddress sanitize_memory sanitize_thread ssp sspreq sspstrong strictfp uwtable "foo"="bar" "patchable-function"="prologue-short-redirect" "probe-stack"="_foo_guard" "stack-probe-size"="4096" }
 
 ; attributes to drop
 attributes #1 = {
   alignstack=16 convergent inaccessiblememonly inaccessiblemem_or_argmemonly naked
   noreturn readonly argmemonly returns_twice speculatable "thunk"
 }

test/Transforms/CodeExtractor/PartialInlineDebug.ll

 if.end:                                           ; preds = %if.then, %entry
   %v2 = phi i32 [ %v, %entry ], [ %mul, %if.then2 ]
   %add = add nsw i32 %v2, 200
   ret i32 %add
 }
 
 ; CHECK-LABEL: @caller
 ; CHECK: codeRepl.i:
-; CHECK-NEXT: call void @callee.2_if.then(i32 %v, i32* %mul.loc.i), !dbg ![[DBG2:[0-9]+]]
+; CHECK-NEXT: call void @callee.2.if.then(i32 %v, i32* %mul.loc.i), !dbg ![[DBG2:[0-9]+]]
 define i32 @caller(i32 %v) !dbg !8 {
 entry:
   %call = call i32 @callee(i32 %v), !dbg !14
   ret i32 %call
 }
 
 
 ; CHECK-LABEL: @callee2

 if.end:
   %v2 = phi i32 [ %v, %entry ], [ %sub, %if.then2 ]
   %add = add nsw i32 %v2, 200
   ret i32 %add
 }
 
 ; CHECK-LABEL: @caller2
 ; CHECK: codeRepl.i:
-; CHECK-NEXT: call void @callee2.1_if.then(i32 %v, i32* %sub.loc.i), !dbg ![[DBG4:[0-9]+]]
+; CHECK-NEXT: call void @callee2.1.if.then(i32 %v, i32* %sub.loc.i), !dbg ![[DBG4:[0-9]+]]
 define i32 @caller2(i32 %v) !dbg !21 {
 entry:
   %call = call i32 @callee2(i32 %v), !dbg !22
   ret i32 %call
 }
 
-; CHECK-LABEL: define internal void @callee2.1_if.then
+; CHECK-LABEL: define internal void @callee2.1.if.then
 ; CHECK: br label %if.then, !dbg ![[DBG5:[0-9]+]]
 
-; CHECK-LABEL: define internal void @callee.2_if.then
+; CHECK-LABEL: define internal void @callee.2.if.then
 ; CHECK: br label %if.then, !dbg ![[DBG6:[0-9]+]]
 
 ; CHECK: ![[DBG1]] = !DILocation(line: 10, column: 7,
 ; CHECK: ![[DBG2]] = !DILocation(line: 10, column: 7,
 ; CHECK: ![[DBG3]] = !DILocation(line: 110, column: 17,
 ; CHECK: ![[DBG4]] = !DILocation(line: 110, column: 17,
 ; CHECK: ![[DBG5]] = !DILocation(line: 110, column: 17,
 ; CHECK: ![[DBG6]] = !DILocation(line: 10, column: 7,

test/Transforms/CodeExtractor/PartialInlineEntryUpdate.ll

 return:             ; preds = %entry
   ret i32 0
 }
 
 define internal i32 @Caller1(i1 %cond, i32* align 2 %align.val) !prof !3{
 entry:
 ; CHECK-LABEL: @Caller1
 ; CHECK: br
-; CHECK: call void @Func.1_ 
+; CHECK: call void @Func.1.
 ; CHECK: br
-; CHECK: call void @Func.1_ 
+; CHECK: call void @Func.1.
   %val = call i32 @Func(i1 %cond, i32* %align.val)
   %val2 = call i32 @Func(i1 %cond, i32* %align.val)
   ret i32 %val
 }
 
 define internal i32 @Caller2(i1 %cond, i32* align 2 %align.val) !prof !2{
 entry:
 ; CHECK-LABEL: @Caller2
 ; CHECK: br
-; CHECK: call void @Func.1_ 
+; CHECK: call void @Func.1.
   %val = call i32 @Func(i1 %cond, i32* %align.val)
   ret i32 %val
 }
 
 ; CHECK: [[REMAINCOUNT]] = !{!"function_entry_count", i64 150}
 !1 = !{!"function_entry_count", i64 200}
 !2 = !{!"function_entry_count", i64 10}
 !3 = !{!"function_entry_count", i64 20}
 

test/Transforms/CodeExtractor/PartialInlineInvokeProducesOutVal.ll

bb5:                                              ; preds = %bb4, %bb1, %bb
   %retval = phi i8* [ %call26, %cont ], [ undef, %bb]
   ret i8* %retval
 }
 
 ; CHECK-LABEL: @dummy_caller
 ; CHECK-LABEL: bb:
 ; CHECK-NEXT:  [[CALL26LOC:%.*]] = alloca i8*
 ; CHECK-LABEL: codeRepl.i:
-; CHECK-NEXT:   call void @bar.1_bb1(i8** [[CALL26LOC]])
+; CHECK-NEXT:   call void @bar.1.bb1(i8** [[CALL26LOC]])
 define i8* @dummy_caller(i32 %arg) {
 bb:
   %tmp = tail call i8* @bar(i32 %arg)
   ret i8* %tmp
 }
 
-; CHECK-LABEL: define internal void @bar.1_bb1
+; CHECK-LABEL: define internal void @bar.1.bb1
 ; CHECK-LABEL: bb1:
 ; CHECK-NEXT:    %call26 = invoke i8* @invoke_callee()
 ; CHECK-NEXT:            to label %cont unwind label %lpad
 ; CHECK-LABEL: cont:
 ; CHECK-NEXT:    store i8* %call26, i8** %call26.out
 ; CHECK-NEXT:    br label %bb5.exitStub
 
 ; Function Attrs: nobuiltin
 declare dso_local noalias nonnull i8* @invoke_callee() local_unnamed_addr #1
 
 declare dso_local i32 @__gxx_personality_v0(...)

test/Transforms/CodeExtractor/PartialInlineLiveAcross.ll

 declare i32 @bar(...) local_unnamed_addr #1
 
 declare void @foo(...) local_unnamed_addr #1
 
 ; Function Attrs: nounwind uwtable
 define i32 @dummy_caller(i32 %arg) local_unnamed_addr #0 {
 ; CHECK-LABEL: @dummy_caller
 ; CHECK: codeRepl.i:
-; CHECK:  call void @test.1_bb2()
+; CHECK:  call void @test.1.bb2()
 ; CHECK-NOT: load
 ; CHECK  br
 
 bb:
   %tmp = tail call i32 @test(i32 %arg)
   ret i32 %tmp
 }
 
-; CHECK-LABEL: define internal void @test.1_bb2()
+; CHECK-LABEL: define internal void @test.1.bb2()
 ; CHECK: .exitStub:
 ; CHECK-NOT:  store i32 %tmp7, i32* %tmp7.out
 ; CHECK: ret
 
 
 attributes #0 = { nounwind uwtable }
 attributes #1 = { nounwind uwtable }
 
 !llvm.module.flags = !{!0}
 !llvm.ident = !{!1}
 
 !0 = !{i32 1, !"wchar_size", i32 4}
 !1 = !{!"clang version 5.0.0 (trunk 303574)"}

test/Transforms/CodeExtractor/PartialInlineNoLiveOut.ll

 
 ; Function Attrs: nounwind uwtable
 declare void @foo(...) local_unnamed_addr #0
 
 ; Function Attrs: nounwind uwtable
 define i32 @dummy_caller(i32 %arg) local_unnamed_addr #0 {
 ; CHECK-LABEL: @dummy_caller
 ; CHECK: codeRepl.i:
-; CHECK:  call void @test.1_bb2()
+; CHECK:  call void @test.1.bb2()
 ; CHECK-NOT: load
 ; CHECK  br
 bb:
   %tmp = tail call i32 @test(i32 %arg)
   ret i32 %tmp
 }
 
-; CHECK-LABEL: define internal void @test.1_bb2()
+; CHECK-LABEL: define internal void @test.1.bb2()
 ; CHECK: .exitStub:
 ; CHECK-NOT:  store i32 %tmp7, i32* %tmp7.out
 ; CHECK: ret
 
 attributes #0 = { nounwind uwtable }
 attributes #1 = { nounwind }
 
 !llvm.module.flags = !{!0}
 !llvm.ident = !{!1}
 
 !0 = !{i32 1, !"wchar_size", i32 4}
 !1 = !{!"clang version 5.0.0 (trunk 303574)"}

test/Transforms/CodeExtractor/PartialInlineOr.ll

 declare void @foo(...) local_unnamed_addr
 
 ; Function Attrs: nounwind uwtable
 define i32 @dummy_caller(i32 %arg) local_unnamed_addr #0 {
 bb:
 ; CHECK-LABEL: @dummy_caller
 ; CHECK: br i1
 ; CHECK: br i1
-; CHECK: call void @bar.2_
+; CHECK: call void @bar.2.
 ; LIMIT-LABEL: @dummy_caller
 ; LIMIT-NOT: br
 ; LIMIT: call i32 @bar(
   %tmp = tail call i32 @bar(i32 %arg)
   ret i32 %tmp
 }
 
 define i32 @bar_multi_ret(i32 %arg) local_unnamed_addr #0 {

 bb5:                                              ; preds = %bb4, %bb1
   %.0 = phi i32 [ 0, %bb4 ], [ 1, %bb1 ], [0, %bb6]
   ret i32 %.0
 }
 
 define i32 @dummy_caller2(i32 %arg) local_unnamed_addr #0 {
 ; CHECK: br i1
 ; CHECK: br i1
-; CHECK: call {{.*}} @bar_multi_ret.1_
+; CHECK: call {{.*}} @bar_multi_ret.1.
   %tmp = tail call i32 @bar_multi_ret(i32 %arg)
   ret i32 %tmp
 }
 
 attributes #0 = { nounwind uwtable }
 attributes #1 = { nounwind }
 
 !llvm.ident = !{!0}
 
 !0 = !{!"clang version 5.0.0 (trunk 300576)"}

test/Transforms/CodeExtractor/PartialInlineOrAnd.ll

 
 ; Function Attrs: nounwind uwtable
 define i32 @dummy_caller(i32 %arg) local_unnamed_addr #0 {
 bb:
 ; CHECK-LABEL: @dummy_caller
 ; CHECK: br i1
 ; CHECK: br i1
 ; CHECK: br i1
-; CHECK: call void @bar.1_
+; CHECK: call void @bar.1.
 ; LIMIT3-LABEL: @dummy_caller
 ; LIMIT3: br i1
 ; LIMIT3: br i1
 ; LIMIT3-NOT: br i1
-; LIMIT3: call void @bar.1_
+; LIMIT3: call void @bar.1.
 ; LIMIT2-LABEL: @dummy_caller
 ; LIMIT2-NOT: br i1
 ; LIMIT2: call i32 @bar(
   %tmp = tail call i32 @bar(i32 %arg)
   ret i32 %tmp
 }
 
 attributes #0 = { nounwind } 
 attributes #1 = { nounwind }
 attributes #2 = { nounwind }
 

test/Transforms/CodeExtractor/PartialInlinePGOMultiRegion.ll

for.end:                                          ; preds = %for.cond2
   %20 = load i32, i32* %sum, align 4
   ret i32 %20
 }
 
 define signext i32 @foo(i32 signext %value, i32 signext %ub) #0 !prof !30 {
 ; CHECK-LABEL: @foo
 ; CHECK-NOT: call signext i32 @bar
 ; CHECK: codeRepl1.i:
-; CHECK: call void @bar.1_if.then
+; CHECK: call void @bar.1.if.then
 ; CHECK: codeRepl.i:
-; CHECK: call void @bar.1_if.then2
+; CHECK: call void @bar.1.if.then2
 entry:
   %value.addr = alloca i32, align 4
   %ub.addr = alloca i32, align 4
   store i32 %value, i32* %value.addr, align 4
   store i32 %ub, i32* %ub.addr, align 4
   %0 = load i32, i32* %value.addr, align 4
   %1 = load i32, i32* %ub.addr, align 4
   %call = call signext i32 @bar(i32 signext %0, i32 signext %1)
   ret i32 %call
 }
 
-; CHECK-LABEL: define internal void @bar.1_if.then2
+; CHECK-LABEL: define internal void @bar.1.if.then2
 ; CHECK: .exitStub:
 ; CHECK: ret void
 
-; CHECK-LABEL: define internal void @bar.1_if.then
+; CHECK-LABEL: define internal void @bar.1.if.then
 ; CHECK: .exitStub:
 ; CHECK: ret void
 
 !llvm.module.flags = !{!0, !1, !2}
 !llvm.ident = !{!29}
 
 !0 = !{i32 1, !"wchar_size", i32 4}
 !1 = !{i32 7, !"PIC Level", i32 2}

test/Transforms/CodeExtractor/PartialInlinePGORegion.ll

for.end:                                          ; preds = %for.cond
   %10 = load i32, i32* %sum, align 4
   ret i32 %10
 }
 
 define signext i32 @foo(i32 signext %value, i32 signext %ub) #0 !prof !30 {
 ; CHECK-LABEL: @foo
 ; CHECK: codeRepl.i:
 ; CHECK-NOT: call signext i32 @bar
-; CHECK: call void @bar.1_if.then
+; CHECK: call void @bar.1.if.then
 entry:
   %value.addr = alloca i32, align 4
   %ub.addr = alloca i32, align 4
   store i32 %value, i32* %value.addr, align 4
   store i32 %ub, i32* %ub.addr, align 4
   %0 = load i32, i32* %value.addr, align 4
   %1 = load i32, i32* %ub.addr, align 4
   %call = call signext i32 @bar(i32 signext %0, i32 signext %1)
   ret i32 %call
 }
 
-; CHECK-LABEL: define internal void @bar.1_if.then
+; CHECK-LABEL: define internal void @bar.1.if.then
 ; CHECK: .exitStub:
 ; CHECK: ret void
 
 !llvm.module.flags = !{!0, !1, !2}
 !llvm.ident = !{!29}
 
 !0 = !{i32 1, !"wchar_size", i32 4}
 !1 = !{i32 7, !"PIC Level", i32 2}

test/Transforms/CodeExtractor/PartialInlineVarArg.ll

 
 define i32 @caller1(i32 %arg) {
 bb:
   %tmp = tail call i32 (i32, ...) @vararg(i32 %arg)
   ret i32 %tmp
 }
 ; CHECK-LABEL: @caller1
 ; CHECK: codeRepl.i:
-; CHECK-NEXT:  call void (i32, i8**, i32, ...) @vararg.3_bb1(i32 %stat1.i, i8** %vargs.i, i32 %arg)
+; CHECK-NEXT:  call void (i32, i8**, i32, ...) @vararg.3.bb1(i32 %stat1.i, i8** %vargs.i, i32 %arg)
 
 define i32 @caller2(i32 %arg, float %arg2) {
 bb:
   %tmp = tail call i32 (i32, ...) @vararg(i32 %arg, i32 10, float %arg2)
   ret i32 %tmp
 }
 
 ; CHECK-LABEL: @caller2
 ; CHECK: codeRepl.i:
-; CHECK-NEXT:  call void (i32, i8**, i32, ...) @vararg.3_bb1(i32 %stat1.i, i8** %vargs.i, i32 %arg, i32 10, float %arg2)
+; CHECK-NEXT:  call void (i32, i8**, i32, ...) @vararg.3.bb1(i32 %stat1.i, i8** %vargs.i, i32 %arg, i32 10, float %arg2)
 
 ; Test case to check that we do not extract a vararg function, if va_end is in
 ; a block that is not outlined.
 define i32 @vararg_not_legal(i32 %count, ...) {
 entry:
   %vargs = alloca i8*, align 8
   %vargs0 = bitcast i8** %vargs to i8*
   %stat1 = load i32, i32* @stat, align 4

 define i32* @caller_with_signext(i32* %foo) {
 entry:
   %call1 = tail call signext i32 (i32*, ...) @vararg2(i32* %foo, i32 signext 8)
   unreachable
 }
 
 ; CHECK-LABEL: @caller_with_signext
 ; CHECK: codeRepl.i:
-; CHECK-NEXT:  call void (i32*, ...) @vararg2.1_cond.end(i32* %foo, i32 signext 8)
+; CHECK-NEXT:  call void (i32*, ...) @vararg2.1.cond.end(i32* %foo, i32 signext 8)

test/Transforms/CodeExtractor/PartialInlineVarArgsDebug.ll

 if.end:                                           ; preds = %if.then, %entry
   %v2 = phi i32 [ %v, %entry ], [ %mul, %if.then ]
   %add = add nsw i32 %v2, 200, !dbg !22
   ret i32 %add, !dbg !23
 }
 
 ; CHECK-LABEL: @caller
 ; CHECK: codeRepl.i:
-; CHECK-NEXT: call void (i32, i32*, ...) @callee.1_if.then(i32 %v, i32* %mul.loc.i, i32 99), !dbg ![[DBG2:[0-9]+]]
+; CHECK-NEXT: call void (i32, i32*, ...) @callee.1.if.then(i32 %v, i32* %mul.loc.i, i32 99), !dbg ![[DBG2:[0-9]+]]
 define i32 @caller(i32 %v) !dbg !8 {
 entry:
   %call = call i32 (i32, ...) @callee(i32 %v, i32 99), !dbg !14
   ret i32 %call, !dbg !15
 }
 
-; CHECK-LABEL: define internal void @callee.1_if.then
+; CHECK-LABEL: define internal void @callee.1.if.then
 ; CHECK: br label %if.then, !dbg ![[DBG3:[0-9]+]]
 
 ; CHECK: ![[DBG1]] = !DILocation(line: 10, column: 7,
 ; CHECK: ![[DBG2]] = !DILocation(line: 10, column: 7,
 ; CHECK: ![[DBG3]] = !DILocation(line: 10, column: 7,
 
 
 !llvm.dbg.cu = !{!0}

test/Transforms/CodeExtractor/SingleCondition.ll

 return:             ; preds = %entry
   ret i32 0
 }
 
 define internal i32 @dummyCaller(i1 %cond, i32* align 2 %align.val) {
 entry:
 ; CHECK-LABEL: @dummyCaller
 ; CHECK: br
-; CHECK: call void @inlinedFunc.1_ 
+; CHECK: call void @inlinedFunc.1.
   %val = call i32 @inlinedFunc(i1 %cond, i32* %align.val)
   ret i32 %val
 }
 

test/Transforms/CodeExtractor/X86/InheritTargetAttributes.ll

entry:
   %val = call <4 x float> @inlinedFunc(i1 %0, <4 x float> %1, <4 x float> %2, <4 x float> %3)
   ret <4 x float> %val
 }
 
 
 attributes #0 = { nounwind readnone }
 attributes #1 = { nounwind uwtable "target-cpu"="x86-64" "target-features"="+sse4.1" }
 
-; CHECK: define {{.*}} @inlinedFunc.1_if.then{{.*}} [[COUNT1:#[0-9]+]]
+; CHECK: define {{.*}} @inlinedFunc.1.if.then{{.*}} [[COUNT1:#[0-9]+]]
 ; CHECK: [[COUNT1]] = { {{.*}} "target-cpu"="x86-64" "target-features"="+sse4.1" }

test/Transforms/CodeExtractor/cost.ll

bb8:                                              ; preds = %bb1, %bb
   ret i32 %tmp9
 }
 
 declare i32 @foo(i32* %arg)
 
 define i32 @dummy_caller(i32* %arg) local_unnamed_addr {
 ; CHECK-LABEL: @dummy_caller
   %tmp = call i32 @outline_region_notlikely(i32* %arg)
-; CHECK:  call void @outline_region_notlikely.2_bb1
+; CHECK:  call void @outline_region_notlikely.2.bb1
   %tmp2 = tail call i32 @outline_region_likely(i32* %arg)
 ; CHECK: %tmp2 = tail call i32 @outline_region_likely(i32* %arg)
   ret i32 %tmp
 
 }
 
-; CHECK-LABEL: define internal void @outline_region_notlikely.2_bb1(i32* %arg) {
+; CHECK-LABEL: define internal void @outline_region_notlikely.2.bb1(i32* %arg) {
 ; CHECK-NEXT: newFuncRoot:
 
 !llvm.module.flags = !{!0}
 !llvm.ident = !{!1}
 
 !0 = !{i32 1, !"wchar_size", i32 4}
 !1 = !{!"clang version 5.0.0 (trunk 304489)"}

test/Transforms/CodeExtractor/cost_meta.ll

 
 define i32 @dummy_caller(i32* %arg) local_unnamed_addr {
 ; CHECK-LABEL: @dummy_caller
   %tmp = call i32 @outline_region_notlikely(i32* %arg)
   ret i32 %tmp
  }
 
 
-; CHECK-LABEL: define internal void @outline_region_notlikely.1_bb1(i32* %arg) {
+; CHECK-LABEL: define internal void @outline_region_notlikely.1.bb1(i32* %arg) {
 ; CHECK-NEXT: newFuncRoot:
 
 declare i32 @foo(i32 * %arg)
 
 !llvm.module.flags = !{!0}
 !llvm.ident = !{!1}
 
 !0 = !{i32 1, !"wchar_size", i32 4}
 !1 = !{!"clang version 5.0.0 (trunk 304489)"}
 !2 = !{!"branch_weights", i32 2000, i32 1}

test/Transforms/CodeExtractor/inline_eh.ll

 }
 
 define internal void @caller(i1 %cond) {
 ; CHECK-LABEL: define {{.*}} @caller
 entry:
 ; CHECK: entry:
 ; CHECK-NEXT: br i1
 ; CHECK: codeRepl.i:
-; CHECK-NEXT: call void @callee.1_{{.*}}()
+; CHECK-NEXT: call void @callee.1.{{.*}}()
   call void @callee(i1 %cond)
   ret void
 }
 
-; CHECK-LABEL: define {{.*}} @callee.1_{{.*}}() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+; CHECK-LABEL: define {{.*}} @callee.1.{{.*}}() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
 ; CHECK: invoke void @bar()
 ; CHECK: landingpad

test/Transforms/CodeExtractor/inline_eh_1.ll

 }
 
 define internal void @caller(i1 %cond) {
 ; CHECK-LABEL: define {{.*}} @caller
 entry:
 ; CHECK: entry:
 ; CHECK-NEXT: br i1
 ; CHECK: codeRepl.i:
-; CHECK-NEXT: call void @callee.1_{{.*}}()
+; CHECK-NEXT: call void @callee.1.{{.*}}()
   call void @callee(i1 %cond)
   ret void
 }
 
-; CHECK-LABEL: define {{.*}} @callee.1_{{.*}}() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK-LABEL: define {{.*}} @callee.1.{{.*}}() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
 ; CHECK: invoke void @bar()
 ; CHECK: cleanuppad
 ; CHECK-NEXT: cleanupret
 ; CHECK: catchswitch
 ; CHECK: catchpad
 ; CHECK-NEXT: catchret

test/Transforms/CodeExtractor/live_shrink.ll

 ; CHECK-LABEL: @_Z3goov()
 bb:
 ; CHECK: bb:
 ; CHECK-NOT: alloca
 ; CHECK-NOT: bitcast
 ; CHECK-NOT: llvm.lifetime
 ; CHECK: br i1
 ; CHECK: codeRepl.i:
-; CHECK: call void @_Z3foov.1_
+; CHECK: call void @_Z3foov.1.
 
   tail call void @_Z3foov()
   ret void
 }
 
-; CHECK-LABEL: define internal void @_Z3foov.1_
+; CHECK-LABEL: define internal void @_Z3foov.1.
 ; CHECK: newFuncRoot:
 ; CHECK-NEXT:  %tmp = alloca %class.A
 ; CHECK-NEXT:  %tmp1 = bitcast %class.A* %tmp to i8*
 ; CHECK-NEXT:  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %tmp1)
 ; CHECK:  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %tmp1)
 ; CHECK-NEXT:  br label %bb5.exitStub
 
 

test/Transforms/CodeExtractor/live_shrink_gep.ll

 ; CHECK-LABEL: @_Z3goov()
 bb:
 ; CHECK: bb:
 ; CHECK-NOT: alloca
 ; CHECK-NOT: getelementptr
 ; CHECK-NOT: llvm.lifetime
 ; CHECK: br i1
 ; CHECK: codeRepl.i:
-; CHECK: call void @_Z3foov.1_
+; CHECK: call void @_Z3foov.1.
   tail call void @_Z3foov()
   ret void
 }
 
-; CHECK-LABEL: define internal void @_Z3foov.1_
+; CHECK-LABEL: define internal void @_Z3foov.1.
 ; CHECK: newFuncRoot:
 ; CHECK-NEXT:  %tmp = alloca %class.A
 ; CHECK-NEXT:  %tmp1 = getelementptr
 ; CHECK-NEXT:  call void @llvm.lifetime.start.p0i8
 ; CHECK:  call void @llvm.lifetime.end.p0i8
 ; CHECK-NEXT:  br label %bb5.exitStub
 
 !llvm.module.flags = !{!0}
 !llvm.ident = !{!1}
 
 !0 = !{i32 1, !"wchar_size", i32 4}
 !1 = !{!"clang version 5.0.0 (trunk 304489)"}
 !2 = !{!3, !3, i64 0}
 !3 = !{!"int", !4, i64 0}
 !4 = !{!"omnipotent char", !5, i64 0}
 !5 = !{!"Simple C++ TBAA"}

test/Transforms/CodeExtractor/live_shrink_hoist.ll

 
 ; Function Attrs: uwtable
 define void @_Z3goov() local_unnamed_addr  {
 bb:
   tail call void @_Z3foov()
   ret void
 }
 
-; CHECK-LABEL: define internal void @_Z3foov.1_
+; CHECK-LABEL: define internal void @_Z3foov.1.
 ; CHECK: bb9:
 ; CHECK: call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %tmp1)
 ; CHECK:  br label %.exitStub
 
 
 
 !llvm.module.flags = !{!0}
 !llvm.ident = !{!1}

test/Transforms/CodeExtractor/live_shrink_multiple.ll

 
 ; Function Attrs: uwtable
 define void @_Z3goov() local_unnamed_addr  {
 bb:
   tail call void @_Z3foov()
   ret void
 }
 
-; CHECK-LABEL: define internal void @_Z3foov.1_
+; CHECK-LABEL: define internal void @_Z3foov.1.
 ; CHECK: newFuncRoot:
 ; CHECK-NEXT:  alloca 
 ; CHECK-NEXT:  bitcast 
 ; CHECK-NEXT:  call void @llvm.lifetime.start.p0i8
 ; CHECK-NEXT:  alloca
 ; CHECK-NEXT:  bitcast 
 ; CHECK-NEXT:  call void @llvm.lifetime.start.p0i8
 ; CHECK:  call void @llvm.lifetime.end.p0i8

test/Transforms/CodeExtractor/unreachable-block.ll

 ; RUN: opt -S -partial-inliner %s | FileCheck %s
 
 ; CHECK-LABEL: define void @dipsy(
-; CHECK-NEXT:   call void @tinkywinky.1_ontrue()
+; CHECK-NEXT:   call void @tinkywinky.1.ontrue()
 ; CHECK-NEXT:   call void @patatuccio()
 ; CHECK-NEXT:   ret void
 ; CHECK-NEXT: }
 
-; CHECK-LABEL: define internal void @tinkywinky.1_ontrue() {
+; CHECK-LABEL: define internal void @tinkywinky.1.ontrue() {
 ; CHECK-NEXT: newFuncRoot:
 ; CHECK-NEXT:   br label %ontrue
 ; CHECK: onfalse{{.*}}:
 ; CHECK-NEXT:   ret void
 ; CHECK: ontrue:
 ; CHECK-NEXT:   call void @patatino()
 ; CHECK-NEXT:   br label %onfalse{{.*}}
 ; CHECK-NEXT: }

test/Transforms/HotColdSplit/split-cold-2.ll

 ; RUN: opt -hotcoldsplit -pass-remarks=hotcoldsplit -S < %s 2>&1 | FileCheck %s
 ; RUN: opt -passes=hotcoldsplit -pass-remarks=hotcoldsplit -S < %s 2>&1 | FileCheck %s
 
 ; Make sure this compiles. This test used to fail with an invalid phi node: the
 ; two predecessors were outlined and the SSA representation was invalid.
 
-; CHECK: remark: <unknown>:0:0: fun split cold code into fun_if.else
+; CHECK: remark: <unknown>:0:0: fun split cold code into fun.cold
 ; CHECK-LABEL: @fun
 ; CHECK: codeRepl:
-; CHECK-NEXT: call void @fun_if.else
+; CHECK-NEXT: call void @fun.cold
 
 define void @fun() {
 entry:
   br i1 undef, label %if.then, label %if.else
 
 if.then:
   ret void
 

test/Transforms/HotColdSplit/split-out-dbg-val-of-arg.ll

 ; RUN: opt -hotcoldsplit -S < %s | FileCheck %s
 
-; CHECK-LABEL: define {{.*}}@foo_if.end
+; CHECK-LABEL: define {{.*}}@foo.cold
 ; CHECK-NOT: llvm.dbg.value
 
 define void @foo(i32 %arg1) !dbg !6 {
 entry:
   %var = add i32 0, 0, !dbg !11
   br i1 undef, label %if.then, label %if.end, !dbg !12
 
 if.then:                                          ; preds = %entry

test/tools/llvm-extract/extract-block.ll

 ; RUN: llvm-extract -S -bb foo:bb4 %s | FileCheck %s
 
 ; CHECK: declare void @bar()
 define void @bar() {
 bb:
   ret void
 }
 
 ; CHECK-NOT: @unused()
 define void @unused() {
 bb:
   ret void
 }
 
-; CHECK: @foo_bb4
+; CHECK: @foo.bb4
 ; CHECK: call void @bar()
 ; CHECK: %tmp5
 define i32 @foo(i32 %arg) {
 bb:
   %tmp = alloca i32, align 4
   %tmp1 = alloca i32, align 4
   store i32 %arg, i32* %tmp1, align 4
   %tmp2 = load i32, i32* %tmp1, align 4

test/tools/llvm-extract/extract-multiple-blocks.ll

 ; RUN: llvm-extract -S -bb foo:bb4 -bb foo:bb7 %s | FileCheck %s
 
-; CHECK: @foo_bb4
-; CHECK: @foo_bb7
+; CHECK: @foo.bb4
+; CHECK: @foo.bb7
 define i32 @foo(i32 %arg) {
 bb:
   %tmp = alloca i32, align 4
   %tmp1 = alloca i32, align 4
   store i32 %arg, i32* %tmp1, align 4
   %tmp2 = load i32, i32* %tmp1, align 4
   %tmp3 = icmp sgt i32 %tmp2, 0
   br i1 %tmp3, label %bb4, label %bb7