[Pseudo Probe] Make .pseudo_probe GC-able

[MaskRay]

Summary

• Add the SHF_LINK_ORDER flag so that the .pseudo_probe section is discarded when the associated text section is discarded.
• Add unique ID so that with clang -ffunction-sections -fno-unique-section-names, there is one separate .pseudo_probe for each text section (disambiguated by .section ....,unique,id in assembly)

The changes allow .pseudo_probe GC even if we don't place instrumented functions
in an IR comdat (see getOrCreateFunctionComdat in SampleProfileProbe.cpp).

[hoy]

Thanks for working on this! It looks better than using function name for deduplication and gc.

llvm/lib/MC/MCObjectFileInfo.cpp

1179

I think the type should inherit the type of PseudoProbeSection.

1180

Should the pseudo probe section be a comdat only if the text section is a comdat?

[MaskRay]

Thanks for the quick review!

llvm/lib/MC/MCObjectFileInfo.cpp

1179

getSection is a MCELFSection method. We'd need cast<MCELFSection>(PseudoProbeSection)->getType() which is a bit too complex. Generally SHT_PROGBITS is the most common ELF section type and the type is checked by pseudo-probe-emit.ll. I hope that writing the type verbatim isn't too bad...

1180

The const MCSymbol *Group = ElfSec.getGroup() condition ensures that the .pseudo_probe section is in a section group only when the text section is in a section group. When GroupName is empty, getELFSection does not use a section group.

[hoy]

llvm/lib/MC/MCObjectFileInfo.cpp

1180

So IIUC, when GroupName is empty, IsComdat=true doesn't really make a difference right?

[MaskRay]

llvm/lib/MC/MCObjectFileInfo.cpp

1180

Right. ELF has the concept of section groups. GRP_COMDAT is a special/mostly common section group.

Actually, in our use cases IsComdat is a no-op. We always create text sections before these metadata sections. If the text section has created a section group with the GRP_COMDAT flag, new getELFSection calls, whether or not IsComdat, does not change the fact.

[hoy]

LGTM, thanks.

llvm/lib/MC/MCObjectFileInfo.cpp

MCObjectFileInfo::getKCFITrapSection(const MCSection &TextSec) const {
   return Ctx->getELFSection(".kcfi_traps", ELF::SHT_PROGBITS, Flags, 0,
                             GroupName,
                             /*IsComdat=*/true, ElfSec.getUniqueID(),
                             cast<MCSymbolELF>(TextSec.getBeginSymbol()));
 }
 
 MCSection *
 MCObjectFileInfo::getPseudoProbeSection(const MCSection &TextSec) const {
-  if (Ctx->getObjectFileType() == MCContext::IsELF) {
-    const auto &ElfSec = static_cast<const MCSectionELF &>(TextSec);
-    // Create a separate section for probes that comes with a comdat function.
-    if (const MCSymbol *Group = ElfSec.getGroup()) {
-      auto *S = static_cast<MCSectionELF *>(PseudoProbeSection);
-      auto Flags = S->getFlags() | ELF::SHF_GROUP;
-      return Ctx->getELFSection(S->getName(), S->getType(), Flags,
-                                S->getEntrySize(), Group->getName(),
-                                /*IsComdat=*/true);
-    }
+  if (Ctx->getObjectFileType() != MCContext::IsELF)
+    return PseudoProbeSection;
+
+  unsigned Flags = ELF::SHF_LINK_ORDER;
+  StringRef GroupName;
+    GroupName = Group->getName();
+    Flags |= ELF::SHF_GROUP;
   }
-  return PseudoProbeSection;
+
+  return Ctx->getELFSection(PseudoProbeSection->getName(), ELF::SHT_PROGBITS,
+                            Flags, 0, GroupName, true, ElfSec.getUniqueID(),
+                            cast<MCSymbolELF>(TextSec.getBeginSymbol()));
 }
 
 MCSection *
 MCObjectFileInfo::getPseudoProbeDescSection(StringRef FuncName) const {
   if (Ctx->getObjectFileType() == MCContext::IsELF) {
     // Create a separate comdat group for each function's descriptor in order
     // for the linker to deduplicate. The duplication, must be from different
     // tranlation unit, can come from:

llvm/test/Transforms/SampleProfile/pseudo-probe-emit.ll

 ; REQUIRES: x86_64-linux
 ; RUN: opt < %s -passes=pseudo-probe -function-sections -S -o %t
 ; RUN: FileCheck %s < %t --check-prefix=CHECK-IL
 ; RUN: llc %t -stop-after=pseudo-probe-inserter -o - | FileCheck %s --check-prefix=CHECK-MIR
 ; RUN: llc %t -function-sections -filetype=asm -o %t1
 ; RUN: FileCheck %s < %t1 --check-prefix=CHECK-ASM
 ; RUN: llc %t -function-sections -filetype=obj -o %t2
-; RUN: llvm-objdump --section-headers  %t2 | FileCheck %s --check-prefix=CHECK-OBJ
+; RUN: llvm-readelf -S  %t2 | FileCheck %s --check-prefix=CHECK-SEC
 ; RUN: llvm-mc %t1 -filetype=obj -o %t3
-; RUN: llvm-objdump --section-headers  %t3 | FileCheck %s --check-prefix=CHECK-OBJ
+; RUN: llvm-readelf -S  %t3 | FileCheck %s --check-prefix=CHECK-SEC
+
+; RUN: llc %t -function-sections -unique-section-names=0 -filetype=obj -o %t4
+; RUN: llvm-readelf -S  %t4 | FileCheck %s --check-prefix=CHECK-SEC2
 
 ;; Check the generation of pseudoprobe intrinsic call.
 
 @a = dso_local global i32 0, align 4
 
 define void @foo(i32 %x) !dbg !3 {
 bb0:
   %cmp = icmp eq i32 %x, 0

 ; Check pseudo_probe metadata attached to the direct call instruction.
 ; CHECK-IL: call void @bar(i32 1), !dbg ![[#PROBE1:]]
 ; CHECK-MIR: PSEUDO_PROBE [[#GUID2]], 3, 2, 0
 ; CHECK-ASM: .pseudoprobe [[#GUID2]] 3 2 0 foo2
   call void @bar(i32 1)
   ret void
 }
 
+$foo3 = comdat any
+
+define void @foo3(i32 %x) comdat {
+entry:
+  ret void
+}
+
 ; CHECK-IL: Function Attrs: nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite)
 ; CHECK-IL-NEXT: declare void @llvm.pseudoprobe(i64, i64, i32, i64)
 
 ; CHECK-IL: ![[#FOO:]] = distinct !DISubprogram(name: "foo"
 ; CHECK-IL: ![[#FAKELINE]] = !DILocation(line: 0, scope: ![[#FOO]])
 ; CHECK-IL: ![[#REALLINE]] = !DILocation(line: 2, scope: ![[#DISC0:]])
 ; CHECK-IL: ![[#DISC0]] = !DILexicalBlockFile(scope: ![[#FOO]], file: ![[#]], discriminator: 0)
 ; CHECK-IL: ![[#PROBE0]] = !DILocation(line: 2, column: 20, scope: ![[#SCOPE0:]])

 ; CHECK-ASM-NEXT: .byte  3
 ; CHECK-ASM-NEXT: .ascii  "foo"
 ; CHECK-ASM-NEXT: .section  .pseudo_probe_desc,"G",@progbits,.pseudo_probe_desc_foo2,comdat
 ; CHECK-ASM-NEXT: .quad [[#GUID2]]
 ; CHECK-ASM-NEXT: .quad [[#HASH2:]]
 ; CHECK-ASM-NEXT: .byte 4
 ; CHECK-ASM-NEXT: .ascii  "foo2"
 
-; CHECK-OBJ-COUNT-2: .pseudo_probe_desc
-; CHECK-OBJ: .pseudo_probe
-; CHECK-OBJ-NOT: .rela.pseudo_probe
+; CHECK-SEC:          [Nr] Name              Type     {{.*}} ES Flg Lk Inf Al
+; CHECK-SEC:          [ 3] .text.foo         PROGBITS {{.*}} 00  AX  0   0 16
+; CHECK-SEC:          [ 5] .text.foo2        PROGBITS {{.*}} 00  AX  0   0 16
+; CHECK-SEC:          [ 8] .text.foo3        PROGBITS {{.*}} 00  AXG 0   0 16
+; CHECK-SEC-COUNT-3:       .pseudo_probe_desc
+; CHECK-SEC:                .pseudo_probe    PROGBITS {{.*}} 00   L  3   0  1
+; CHECK-SEC-NEXT:           .pseudo_probe    PROGBITS {{.*}} 00   L  5   0  1
+; CHECK-SEC-NEXT:           .pseudo_probe    PROGBITS {{.*}} 00   LG 8   0  1
+; CHECK-SEC-NOT:     .rela.pseudo_probe
+
+; CHECK-SEC2:         [Nr] Name              Type     {{.*}} ES Flg Lk Inf Al
+; CHECK-SEC2:         [ 3] .text             PROGBITS {{.*}} 00  AX  0   0 16
+; CHECK-SEC2:         [ 5] .text             PROGBITS {{.*}} 00  AX  0   0 16
+; CHECK-SEC2:         [ 8] .text             PROGBITS {{.*}} 00  AXG 0   0 16
+; CHECK-SEC2-COUNT-3:      .pseudo_probe_desc
+; CHECK-SEC2:               .pseudo_probe    PROGBITS {{.*}} 00   L  3   0  1
+; CHECK-SEC2-NEXT:          .pseudo_probe    PROGBITS {{.*}} 00   L  5   0  1
+; CHECK-SEC2-NEXT:          .pseudo_probe    PROGBITS {{.*}} 00   LG 8   0  1
+; CHECK-SEC2-NOT:     .rela.pseudo_probe
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!9, !10}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1)
 !1 = !DIFile(filename: "test.c", directory: "")
 !2 = !{}
 !3 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !5, unit: !0, retainedNodes: !2)