[CodeGen] Add text section prefix for COFF object file

[TaoPan]

Summary

Text section prefix is created in CodeGenPrepare, it's file format independent implementation, text section name is written into object file in TargetLoweringObjectFile, it's file format dependent implementation, port code of adding text section prefix to text section name from ELF to COFF.
Different with ELF that use '.' as concatenation character, COFF use '$' as concatenation character. That is, concatenation character is variable, so split concatenation character from text section prefix.
Text section prefix is existing feature of ELF, it can help to reduce icache and itlb misses, it's also make possible aggregate other compilers e.g. v8 created same prefix sections. Furthermore, the recent feature Machine Function Splitter (basic block level text prefix section) is based on text section prefix.

[pengfei]

Can you add more detail for the background on summary?

llvm/test/CodeGen/X86/text-section-prefix.ll

2

What's your checking here?

[rnk]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

623

This is out of scope for the patch, but why is it called a "section prefix" if it goes after the section name? ".text.hot._ZfooEv"

llvm/test/CodeGen/X86/text-section-prefix.ll

2

Please run this test in a few configurations. You can add two RUN lines like:

; RUN: llc -mtriple x86_64-linux-gnu %s -o - | FileCheck %s --check-prefix=ELF
; RUN: llc -mtriple x86_64-linux-gnu -unique-section-names=0 %s -o - | FileCheck %s --check-prefix=ELF-NOUNIQ
; RUN: llc -mtriple x86_64-windows-msvc %s -o - | FileCheck %s --check-prefix=MSVC
; RUN: llc -mtriple x86_64-windows-msvc %s -o - | FileCheck %s --check-prefix=MINGW

Add check lines for the section directives.

[MaskRay]

llvm/test/CodeGen/X86/text-section-prefix.ll

4

You may want some RUN configurations in Transforms/CodeGenPrepare/X86/section.ll

[TaoPan]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

623

Without this modification, ".texthot._ZfooEv", no '.' between .text and hot, as the '.' was removed in CodeGenPrepare.cpp
Please have a look at I just added Summary, key reason is ELF use '.', COFF use '$'.

llvm/test/CodeGen/X86/text-section-prefix.ll

2

I added some description in Summary.

The line of output

.section     .text,xxx

will be changed to

.section     .text**$hot**,xxx

or

.section     .text**$unlikely**,xxx

with this patch on Windows.

2

Thanks for your nice guidance!
I'll try your RUN lines.

4

Thanks! I'll refer to this file.

[pengfei]

llvm/test/CodeGen/X86/text-section-prefix.ll

2

I see. Then you just need to add RUNs as Reid suggested and checks like what in section.ll

[TaoPan]

llvm/test/CodeGen/X86/text-section-prefix.ll

2

ok, I'll add RUNs and checks as Reid and MaskRay suggested, thanks!

[TaoPan]

Fix lit failures and update test case for checking text section prefix.

[pengfei]

llvm/test/CodeGen/X86/text-section-prefix.ll

2

Maybe better to put the test in Transforms/CodeGenPrepare/X86

10

You don't need to distinguish HOT and UNLIKLY since they are in different functions. You just need SECTION-ELF and SECTION-COFF.
You may also need to add

; RUN: llc -mtriple x86_64-linux-gnu -unique-section-names=0 %s -o - | FileCheck %s --check-prefix=ELF-NOUNIQ
; RUN: llc -mtriple x86_64-windows-mingw64 %s -o - | FileCheck %s --check-prefix=MINGW

as Reid suggested.

[TaoPan]

Fix testcase, remove HOT and UNLIKELY, add ELF-NOUNIQ and MINGW

[TaoPan]

llvm/test/CodeGen/X86/text-section-prefix.ll

10

Thanks for your review comments! I removed HOT and UNLIKELY, and added ELF-NOUNIQ and MINGW, could you please have a look?

[pengfei]

LGTM. You'd better wait few days to see if others object. Thanks.

llvm/test/CodeGen/X86/text-section-prefix.ll

10

Nit: It seems no difference between MSVC and MINGW, you can use COFF for both to reduce the duplicated check.

[TaoPan]

Fix testcase: combine MSVC and MINGW into COFF

[TaoPan]

llvm/test/CodeGen/X86/text-section-prefix.ll

10

Thanks! It's good idea, I combined MSVC and MINGW into COFF.

[TaoPan]

git rebase

[rnk]

llvm/test/CodeGen/X86/text-section-prefix.ll

10

They will differ if you use a linkonce_odr comdat function. These are very common in C++, it is worth testing this case. Try:

$foocomdat = comdat any
define linkonce_odr dso_local i32 @foocomdat(i32 %0, i32 %1) comdat {
  %3 = add nsw i32 %1, %0
  ret i32 %3
}

The sections for foocomdat will have a suffix on mingw.

[rnk]

llvm/test/CodeGen/X86/text-section-prefix.ll

10

Perhaps use weak_odr linkage instead, so that it is non-discardable and is not dropped by DCE.

[TaoPan]

Remove redundant blank line

[TaoPan]

llvm/test/CodeGen/X86/text-section-prefix.ll

10

Thanks for your review comment!
I tried you suggested case, and replaced linkonce_odr with weak_odr, I didn't find difference between x86_64-windows-msvc and x86_64-windows-mingw64.
Is the difference related to text section name? I think this patch doesn't change anything except text section name.

[rnk]

llvm/test/CodeGen/X86/text-section-prefix.ll

10

Yes, there should be a difference. Consider:

$ cat t.cpp 
inline int myadd(int x, int y) { return x + y; }
int main() { return myadd(1, 2); }

$ clang -S -O0 --target=x86_64-windows-msvc t.cpp  -o - | grep .text
        .text
        .section        .text,"xr",discard,"?myadd@@YAHHH@Z"

$ clang -S -O0 --target=x86_64-windows-gnu t.cpp  -o - | grep .text
        .text
        .section        .text$_Z5myaddii,"xr",discard,_Z5myaddii

Note how in the gnu environment LLVM appends the symbol name to the section name. Did you add the comdat as well?

[TaoPan]

Change x86_64-windows-mingw64 to x86_64-windows-gnu for mingw format text section name

[TaoPan]

llvm/test/CodeGen/X86/text-section-prefix.ll

10

Thanks for your notice of windows gnu environment and example!
I can make the difference after changing target to x86_64-windows-gnu (referred to your example).
Could you please have a look again?

[TaoPan]

llvm/test/CodeGen/X86/text-section-prefix.ll

2

Sorry! I didn't note and reply this comment previously.
The reason I didn't put the test in Transforms/CodeGenPrepare/X86 is the key modification is in TargetLoweringObjectFile of CodeGen, not in CodeGenPrepare.

[rnk]

I think this is an improvement, so let's go ahead and land it, but I'm not sure this will really work for mingw.

One last think I will note is that COFF linkers will sort input sections by the part of the section name after the dollar sign. There isn't any special treatment of .text$hot / .text$unlikely. They are sorted early and late by their ASCII ordering. That seems to achieve the right behavior, but maybe PGO should use more intentional section prefixes to get the desired ordering.

llvm/test/CodeGen/X86/text-section-prefix.ll

21

@mstorsjo This seems a bit more complicated than I originally thought it would be.

llvm/test/Transforms/CodeGenPrepare/X86/section.ll

47

The section name is .text.unlikely., with a trailing dot. I guess that is the existing behavior, but it seems odd to me. Nevermind.

[mstorsjo]

llvm/test/CodeGen/X86/text-section-prefix.ll

21

Yeah, but I guess this is what we end up with, if we append things this way. I wonder whether this works properly when interacting with GNU ld?

The patch description has very little context about the what/where/why - so this is something that ends up invoked only if building with PGO?

[TaoPan]

llvm/test/CodeGen/X86/text-section-prefix.ll

21

Thanks for your review comments!
COFF support "$" character as a special interpretation in section names for grouped sections. If GNU ld support COFF, it should recognize "$" and works properly.
I added some description to the end of Summary. Yes, it will be invoked only if building with PGO, but the benefit is not limited to PGO, it's also make possible aggregate other compilers e.g. v8 created same prefix sections.

[TaoPan]

llvm/test/Transforms/CodeGenPrepare/X86/section.ll

47

Yes, the existing code
https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp#L633

} else if (HasPrefix)
  Name.push_back('.');

leads to the trailing dot.

[mstorsjo]

llvm/test/CodeGen/X86/text-section-prefix.ll

21

GNU ld does support COFF, but it has its own interpretation of some bits regarding to COMDAT sections, deviating a bit from the spec.

I'll try to test this usecase, before and after this patch, with both lld and GNU ld, to see if there are issues - I hope you're ok with waiting until I've had a change to try it.

[TaoPan]

llvm/test/CodeGen/X86/text-section-prefix.ll

21

Sure, I'm ok with waiting for your test, and thanks for your test!

[mstorsjo]

llvm/test/CodeGen/X86/text-section-prefix.ll

21

Ok, so I've tested this in a few mingw configurations, and it does seem to work, with a few caveats:

If a comdat symbol is marked "unlikely" in one translation unit but not in another one, linking fails with GNU ld (but lld still succeeds). So for GNU ld, it seems like the section suffix ($unlikely$comdatname) needs to be identical in all occurrances of the symbol/section for the comdat deduplication to work. In lld it works as intended via the leader symbol.

For comdats with associated sections, like .text$unlikely$comdatname associated with .xdata$unlikey$comdatname, associativity seems to work fine as long as the suffix, including $unlikely is identical between .text, .pdata and .xdata - which it turns out to be. But maybe it'd be good to have a test explicitly check that it really is the case?

[TaoPan]

Check section order of .text$hot and .text$unlikely

[TaoPan]

llvm/test/CodeGen/X86/text-section-prefix.ll

21

I added test case to llvm/test/CodeGen/X86/mingw-comdats.ll for checking the order of .text$hot$comdatname and .text$unlikely$comdatname with existing sections， could you please have a look?

[mstorsjo]

llvm/test/CodeGen/X86/mingw-comdats.ll

98

I'm not quite sure what this test actually is supposed to test; ordering of sections according to the suffixes doesn't happen at the object file stage, that only happens while linking.

What would be useful, though, would be to add a new function similar to the _Z3fooi one above, with e.g. a unlikely attribute, and check that all of .text/.xdata/.pdata get similar suffixes just like the checks right above on lines 80-83.

[TaoPan]

Update mingw-comdats.ll to check .text$unlikely$comdatname,
.xdata$unlikely$comdatname and .pdata$unlikely$comdatname

[mstorsjo]

In D92073#2436397, @TaoPan wrote:

Update mingw-comdats.ll to check .text$unlikely$comdatname,
.xdata$unlikely$comdatname and .pdata$unlikely$comdatname

Thanks, this aspect looks good to me now, so no more objections from me.

[TaoPan]

llvm/test/CodeGen/X86/mingw-comdats.ll

98

Thanks for your detail guidance!

llvm/include/llvm/ProfileData/ProfileCommon.h

 namespace llvm {
 
 namespace sampleprof {
 
 class FunctionSamples;
 
 } // end namespace sampleprof
 
-inline const char *getHotSectionPrefix() { return ".hot"; }
-inline const char *getUnlikelySectionPrefix() { return ".unlikely"; }
+inline const char *getHotSectionPrefix() { return "hot"; }
+inline const char *getUnlikelySectionPrefix() { return "unlikely"; }
 
 class ProfileSummaryBuilder {
 private:
   /// We keep track of the number of times a count (block count or samples)
   /// appears in the profile. The map is kept sorted in the descending order of
   /// counts.
   std::map<uint64_t, uint32_t, std::greater<uint64_t>> CountFrequencies;
   std::vector<uint32_t> DetailedSummaryCutoffs;

llvm/lib/CodeGen/CodeGenPrepare.cpp

bool CodeGenPrepare::runOnFunction(Function &F) {
   TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
   LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   BPI.reset(new BranchProbabilityInfo(F, *LI));
   BFI.reset(new BlockFrequencyInfo(F, *BPI, *LI));
   PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
   OptSize = F.hasOptSize();
   if (ProfileGuidedSectionPrefix) {
     if (PSI->isFunctionHotInCallGraph(&F, *BFI))
-      F.setSectionPrefix(".hot");
+      F.setSectionPrefix("hot");
     else if (PSI->isFunctionColdInCallGraph(&F, *BFI))
-      F.setSectionPrefix(".unlikely");
+      F.setSectionPrefix("unlikely");
     else if (ProfileUnknownInSpecialSection && PSI->hasPartialSampleProfile() &&
              PSI->isFunctionHotnessUnknown(F))
-      F.setSectionPrefix(".unknown");
+      F.setSectionPrefix("unknown");
   }
 
   /// This optimization identifies DIV instructions that can be
   /// profitably bypassed and carried out with a shorter, faster divide.
   if (!OptSize && !PSI->hasHugeWorkingSetSize() && TLI->isSlowDivBypassed()) {
     const DenseMap<unsigned int, unsigned int> &BypassWidths =
         TLI->getBypassSlowDivWidths();
     BasicBlock* BB = &*F.begin();

llvm/lib/CodeGen/MachineFunctionSplitter.cpp

bool MachineFunctionSplitter::runOnMachineFunction(MachineFunction &MF) {
   // split functions within the same section as specified by the attribute.
   if (!MF.getFunction().getSection().empty())
     return false;
 
   // We don't want to proceed further for cold functions
   // or functions of unknown hotness. Lukewarm functions have no prefix.
   Optional<StringRef> SectionPrefix = MF.getFunction().getSectionPrefix();
   if (SectionPrefix.hasValue() &&
-      (SectionPrefix.getValue().equals(".unlikely") ||
-       SectionPrefix.getValue().equals(".unknown"))) {
+      (SectionPrefix.getValue().equals("unlikely") ||
+       SectionPrefix.getValue().equals("unknown"))) {
     return false;
   }
 
   // Renumbering blocks here preserves the order of the blocks as
   // sortBasicBlocksAndUpdateBranches uses the numeric identifier to sort
   // blocks. Preserving the order of blocks is essential to retaining decisions
   // made by prior passes such as MachineBlockPlacement.
   MF.RenumberBlocks();

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

if (Kind.isMergeableCString()) {
     Name = ".rodata.cst";
     Name += utostr(EntrySize);
   } else {
     Name = getSectionPrefixForGlobal(Kind);
   }
 
   bool HasPrefix = false;
   if (const auto *F = dyn_cast<Function>(GO)) {
     if (Optional<StringRef> Prefix = F->getSectionPrefix()) {
-      Name += *Prefix;
+      raw_svector_ostream(Name) << '.' << *Prefix;
       HasPrefix = true;
     }
   }
 
   if (UniqueSectionName) {
     Name.push_back('.');
     TM.getNameWithPrefix(Name, GO, Mang, /*MayAlwaysUsePrivate*/true);
   } else if (HasPrefix)
if ((EmitUniquedSection && !Kind.isCommon()) || GO->hasComdat()) {
     unsigned UniqueID = MCContext::GenericSectionID;
     if (EmitUniquedSection)
       UniqueID = NextUniqueID++;
 
     if (!ComdatGV->hasPrivateLinkage()) {
       MCSymbol *Sym = TM.getSymbol(ComdatGV);
       StringRef COMDATSymName = Sym->getName();
 
+      if (const auto *F = dyn_cast<Function>(GO))
+        if (Optional<StringRef> Prefix = F->getSectionPrefix())
+          raw_svector_ostream(Name) << '$' << *Prefix;
+
       // Append "$symbol" to the section name *before* IR-level mangling is
       // applied when targetting mingw. This is what GCC does, and the ld.bfd
       // COFF linker will not properly handle comdats otherwise.
       if (getTargetTriple().isWindowsGNUEnvironment())
         raw_svector_ostream(Name) << '$' << ComdatGV->getName();
 
       return getContext().getCOFFSection(Name, Characteristics, Kind,
                                          COMDATSymName, Selection, UniqueID);
static MCSectionWasm *selectWasmSectionForGlobal(
   }
 
   bool UniqueSectionNames = TM.getUniqueSectionNames();
   SmallString<128> Name = getSectionPrefixForGlobal(Kind);
 
   if (const auto *F = dyn_cast<Function>(GO)) {
     const auto &OptionalPrefix = F->getSectionPrefix();
     if (OptionalPrefix)
-      Name += *OptionalPrefix;
+      raw_svector_ostream(Name) << '.' << *OptionalPrefix;
   }
 
   if (EmitUniqueSection && UniqueSectionNames) {
     Name.push_back('.');
     TM.getNameWithPrefix(Name, GO, Mang, true);
   }
   unsigned UniqueID = MCContext::GenericSectionID;
   if (EmitUniqueSection && !UniqueSectionNames) {

llvm/test/CodeGen/X86/machine-function-splitter.ll

 !7 = !{!"NumCounts", i64 3}
 !8 = !{!"NumFunctions", i64 5}
 !9 = !{!"DetailedSummary", !10}
 !10 = !{!11, !12, !13}
 !11 = !{i32 10000, i64 100, i32 1}
 !12 = !{i32 999900, i64 100, i32 1}
 !13 = !{i32 999999, i64 1, i32 2}
 !14 = !{!"function_entry_count", i64 7000}
-!15 = !{!"function_section_prefix", !".hot"}
-!16 = !{!"function_section_prefix", !".unlikely"}
+!15 = !{!"function_section_prefix", !"hot"}
+!16 = !{!"function_section_prefix", !"unlikely"}
 !17 = !{!"branch_weights", i32 7000, i32 0}
 !18 = !{!"branch_weights", i32 3000, i32 4000}
 !19 = !{!"branch_weights", i32 1000, i32 6000}
 !20 = !{!"function_entry_count", i64 10000}
 !21 = !{!"branch_weights", i32 6000, i32 4000}
 !22 = !{!"branch_weights", i32 80, i32 9920}
 !23 = !{!"function_entry_count", i64 7}

llvm/test/CodeGen/X86/mingw-comdats.ll

 
 ; GNU32: .section        .text$_Z3fooi,"xr",discard,__Z3fooi
 ; GNU32: __Z3fooi:
 ; GNU32: .section        .data$gv,"dw",discard,_gv
 ; GNU32: _gv:
 ; GNU32: .long 42
 
 
+define linkonce_odr dso_local i32 @_Z3fooj(i32 %x) !section_prefix !0 {
+entry:
+  %call = tail call i32 @_Z3bari(i32 %x)
+  %0 = load i32, i32* @gv, align 4
+  %add = add nsw i32 %0, %call
+  ret i32 %add
+}
+
 ; Make sure the assembler puts the .xdata and .pdata in sections with the right
 ; names.
 ; GNUOBJ: .text$_Z3fooi
 ; GNUOBJ: .xdata$_Z3fooi
+; GNUOBJ: .text$unlikely$_Z3fooj
+; GNUOBJ: .xdata$unlikely$_Z3fooj
 ; GNUOBJ: .data$gv
 ; GNUOBJ: .pdata$_Z3fooi
+; GNUOBJ: .pdata$unlikely$_Z3fooj
 
 declare dso_local i32 @_Z3bari(i32)
 
 attributes #0 = { norecurse uwtable }
 attributes #1 = { inlinehint uwtable }
+!0 = !{!"function_section_prefix", !"unlikely"}

llvm/test/CodeGen/X86/text-section-prefix.ll

+; RUN: llc -mtriple x86_64-linux-gnu -function-sections %s -o - | FileCheck %s --check-prefix=ELF
+; RUN: llc -mtriple x86_64-linux-gnu -unique-section-names=0 -function-sections %s -o - | FileCheck %s --check-prefix=ELF-NOUNIQ
+; RUN: llc -mtriple x86_64-windows-msvc -function-sections %s -o - | FileCheck %s --check-prefix=COFF-MSVC
+; RUN: llc -mtriple x86_64-windows-gnu -function-sections %s -o - | FileCheck %s --check-prefix=COFF-GNU
+
+define void @foo1(i1 zeroext %0) nounwind !section_prefix !0 {
+;; CHECK hot section name
+; ELF:        .section  .text.hot.foo1,"ax",@progbits
+; ELF-NOUNIQ: .section  .text.hot.,"ax",@progbits,unique,1
+; COFF-MSVC:  .section  .text$hot,"xr",one_only,foo1
+; COFF-GNU:   .section  .text$hot$foo1,"xr",one_only,foo1
+  ret void
+}
+
+define void @foo2(i1 zeroext %0) nounwind !section_prefix !1 {
+;; CHECK unlikely section name
+; ELF:        .section  .text.unlikely.foo2,"ax",@progbits
+; ELF-NOUNIQ: .section  .text.unlikely.,"ax",@progbits,unique,2
+; COFF-MSVC:  .section  .text$unlikely,"xr",one_only,foo2
+; COFF-GNU:   .section  .text$unlikely$foo2,"xr",one_only,foo2
+  ret void
+}
+
+!0 = !{!"function_section_prefix", !"hot"}
+!1 = !{!"function_section_prefix", !"unlikely"}
+

llvm/test/Transforms/CodeGenPrepare/X86/section-samplepgo.ll

 
 ; CHECK: cold_func{{.*}}!section_prefix ![[COLD_ID:[0-9]+]]
 ; The entry and the callsite are both cold
 define void @cold_func() !prof !16 {
   call void @hot_func(), !prof !18
   ret void
 }
 
-; CHECK: ![[HOT_ID]] = !{!"function_section_prefix", !".hot"}
-; CHECK: ![[COLD_ID]] = !{!"function_section_prefix", !".unlikely"}
+; CHECK: ![[HOT_ID]] = !{!"function_section_prefix", !"hot"}
+; CHECK: ![[COLD_ID]] = !{!"function_section_prefix", !"unlikely"}
 !llvm.module.flags = !{!1}
 !1 = !{i32 1, !"ProfileSummary", !2}
 !2 = !{!3, !4, !5, !6, !7, !8, !9, !10}
 !3 = !{!"ProfileFormat", !"SampleProfile"}
 !4 = !{!"TotalCount", i64 10000}
 !5 = !{!"MaxCount", i64 1000}
 !6 = !{!"MaxInternalCount", i64 1}
 !7 = !{!"MaxFunctionCount", i64 1000}

llvm/test/Transforms/CodeGenPrepare/X86/section.ll

 for.end:
   ret void
 }
 
 ; For instrumentation based PGO, we should only look at block counts,
 ; not call site VP metadata (which can exist on value profiled memcpy,
 ; or possibly left behind after static analysis based devirtualization).
 ; CHECK: cold_func1{{.*}}!section_prefix ![[COLD_ID:[0-9]+]]
 ; ASM1: .section .text.unlikely.,"ax",@progbits
 ; ASM2: .section .text.unlikely.cold_func1,"ax",@progbits
 define void @cold_func1() !prof !16 {
   call void @hot_func1(), !prof !17
   call void @hot_func1(), !prof !17
   ret void
 }
 
 ; CHECK: cold_func2{{.*}}!section_prefix ![[COLD_ID]]
 define void @cold_func2() !prof !16 {
   call void @hot_func1(), !prof !17
   call void @hot_func1(), !prof !18
   call void @hot_func1(), !prof !18
   ret void
 }
 
 ; CHECK: cold_func3{{.*}}!section_prefix ![[COLD_ID]]
 define void @cold_func3() !prof !16 {
   call void @hot_func1(), !prof !18
   ret void
 }
 
-; CHECK: ![[HOT_ID]] = !{!"function_section_prefix", !".hot"}
-; CHECK: ![[COLD_ID]] = !{!"function_section_prefix", !".unlikely"}
+; CHECK: ![[HOT_ID]] = !{!"function_section_prefix", !"hot"}
+; CHECK: ![[COLD_ID]] = !{!"function_section_prefix", !"unlikely"}
 !llvm.module.flags = !{!1}
 !1 = !{i32 1, !"ProfileSummary", !2}
 !2 = !{!3, !4, !5, !6, !7, !8, !9, !10}
 !3 = !{!"ProfileFormat", !"InstrProf"}
 !4 = !{!"TotalCount", i64 10000}
 !5 = !{!"MaxCount", i64 1000}
 !6 = !{!"MaxInternalCount", i64 1}
 !7 = !{!"MaxFunctionCount", i64 1000}

llvm/test/Transforms/HotColdSplit/coldentrycount.ll

if.else:
   ret void
 }
 
 declare void @sink() cold
 
 ; CHECK: define {{.*}} @fun.cold.1{{.*}} ![[PROF:[0-9]+]] {{.*}}section_prefix ![[UNLIKELY:[0-9]+]]
 
 ; CHECK: ![[HOTPROF]] = !{!"function_entry_count", i64 100}
-; CHECK: ![[LIKELY]] = !{!"function_section_prefix", !".hot"}
+; CHECK: ![[LIKELY]] = !{!"function_section_prefix", !"hot"}
 ; CHECK: ![[PROF]] = !{!"function_entry_count", i64 0}
-; CHECK: ![[UNLIKELY]] = !{!"function_section_prefix", !".unlikely"}
+; CHECK: ![[UNLIKELY]] = !{!"function_section_prefix", !"unlikely"}
 
 !llvm.module.flags = !{!0}
 !0 = !{i32 1, !"ProfileSummary", !1}
 !1 = !{!2, !3, !4, !5, !6, !7, !8, !9}
 !2 = !{!"ProfileFormat", !"InstrProf"}
 !3 = !{!"TotalCount", i64 10000}
 !4 = !{!"MaxCount", i64 10}
 !5 = !{!"MaxInternalCount", i64 1}
 !6 = !{!"MaxFunctionCount", i64 1000}
 !7 = !{!"NumCounts", i64 3}
 !8 = !{!"NumFunctions", i64 3}
 !9 = !{!"DetailedSummary", !10}
 !10 = !{!11, !12, !13}
 !11 = !{i32 10000, i64 100, i32 1}
 !12 = !{i32 999000, i64 100, i32 1}
 !13 = !{i32 999999, i64 1, i32 2}
 !14 = !{!"function_entry_count", i64 100}
-!15 = !{!"function_section_prefix", !".hot"}
+!15 = !{!"function_section_prefix", !"hot"}
 !16 = !{!"function_entry_count", i64 0}
-!17 = !{!"function_section_prefix", !".unlikely"}
+!17 = !{!"function_section_prefix", !"unlikely"}

llvm/test/Transforms/SampleProfile/section-accurate-samplepgo.ll

define void @bar_not_in_profile() #0 {
   ret void
 }
 
 attributes #0 = { "profile-sample-accurate" "use-sample-profile" }
 attributes #1 = { "use-sample-profile" }
 
 ; CHECK: ![[NOPROFILE_ID]] = !{!"function_entry_count", i64 -1}
 ; CHECK: ![[ZERO_ID]] = !{!"function_entry_count", i64 0}
-; CHECK: ![[COLD_ID]] = !{!"function_section_prefix", !".unlikely"}
+; CHECK: ![[COLD_ID]] = !{!"function_section_prefix", !"unlikely"}
 ; UNKNOWN: ![[NOPROFILE_ID]] = !{!"function_entry_count", i64 -1}
-; UNKNOWN: ![[UNKNOWN_ID]] = !{!"function_section_prefix", !".unknown"}
+; UNKNOWN: ![[UNKNOWN_ID]] = !{!"function_section_prefix", !"unknown"}
 ; ACCURATE: ![[ZERO_ID]] = !{!"function_entry_count", i64 0}
-; ACCURATE: ![[COLD_ID]] = !{!"function_section_prefix", !".unlikely"}
+; ACCURATE: ![[COLD_ID]] = !{!"function_section_prefix", !"unlikely"}
 !llvm.module.flags = !{!1}
 !1 = !{i32 1, !"ProfileSummary", !2}
 !2 = !{!3, !4, !5, !6, !7, !8, !9, !10}
 !3 = !{!"ProfileFormat", !"SampleProfile"}
 !4 = !{!"TotalCount", i64 10000}
 !5 = !{!"MaxCount", i64 1000}
 !6 = !{!"MaxInternalCount", i64 1}
 !7 = !{!"MaxFunctionCount", i64 1000}
 !8 = !{!"NumCounts", i64 3}
 !9 = !{!"NumFunctions", i64 3}
 !10 = !{!"DetailedSummary", !11}
 !11 = !{!12, !13, !14}
 !12 = !{i32 10000, i64 100, i32 1}
 !13 = !{i32 999000, i64 100, i32 1}
 !14 = !{i32 999999, i64 1, i32 2}