[llvm-profgen] An option to dump disasm of specified symbols

[hoy]

Summary

For large app, dumping disasm of the whole program can be slow and result in gianant output. Adding a switch to dump specific symbols only.

[wlei]

Thanks for the change!

Nit: probably we can add an early check in validateCommandLine to make sure ShowDisassemblyOnly must be true if ShowSymbols is not empty.

[wenlei]

Second what Lei said, adding a check in validateCommandLine would be helpful.

llvm/tools/llvm-profgen/ProfiledBinary.cpp

42

nit: show-symbols -> disassemble-functions. this only works for function.

[hoy]

In D110079#3010460, @wlei wrote:

Thanks for the change!

Nit: probably we can add an early check in validateCommandLine to make sure ShowDisassemblyOnly must be true if ShowSymbols is not empty.

Sounds good.

llvm/tools/llvm-profgen/ProfiledBinary.cpp

42

Makes sense.

[hoy]

Updating D110079: [llvm-profgen] An option to dump disasm of specified symbols

llvm/test/tools/llvm-profgen/pseudoprobe-decoding.test

 ; RUN: llvm-profgen --format=text --perfscript=%s  --binary=%S/Inputs/inline-cs-pseudoprobe.perfbin --output=%t --show-pseudo-probe --show-disassembly-only | FileCheck %s
+; RUN: llvm-profgen --format=text --perfscript=%s  --binary=%S/Inputs/inline-cs-pseudoprobe.perfbin --output=%t --show-pseudo-probe --show-disassembly-only --disassemble-functions=main,foo  | FileCheck %s -check-prefix=SYM
 
 PERF_RECORD_MMAP2 2854748/2854748: [0x400000(0x1000) @ 0 00:1d 123291722 526021]: r-xp /home/inline-cs-pseudoprobe.perfbin
 
 ; CHECK: Pseudo Probe Desc:
 ; CHECK: GUID: 6699318081062747564 Name: foo
 ; CHECK: Hash: 563088904013236
 ; CHECK: GUID: 15822663052811949562 Name: main
 ; CHECK: Hash: 281479271677951

 ; CHECK-NEXT:      84f: addl  $1, %ecx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 7  Type: Block  Inlined: @ main:2
 ; CHECK-NEXT:      85e: movl  $2098432, %edi
 
 ; CHECK:       [Probe]: FUNC: foo Index: 9  Type: DirectCall  Inlined: @ main:2
 ; CHECK-NEXT:      865: callq 0x930
 
+; SYM-NOT: <bar>:
+; SYM: <foo>:
+; SYM: <main>:
+
+
 
 ; clang -O3 -fexperimental-new-pass-manager -fuse-ld=lld -fpseudo-probe-for-profiling
 ; -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -Xclang -mdisable-tail-calls
 ; -g test.c  -o a.out
 
 #include <stdio.h>
 
 int bar(int x, int y) {

llvm/tools/llvm-profgen/ProfiledBinary.h

class ProfiledBinary {
   BinarySizeContextTracker FuncSizeTracker;
 
   // The symbolizer used to get inline context for an instruction.
   std::unique_ptr<symbolize::LLVMSymbolizer> Symbolizer;
 
   // String table owning function name strings created from the symbolizer.
   std::unordered_set<std::string> NameStrings;
 
+  // A collection of functions to print disassembly for.
+  StringSet<> DisassembleFunctionSet;
+
   // Pseudo probe decoder
   MCPseudoProbeDecoder ProbeDecoder;
 
   bool UsePseudoProbes = false;
 
   // Whether we need to symbolize all instructions to get function context size.
   bool TrackFuncContextSize = false;
 

llvm/tools/llvm-profgen/ProfiledBinary.cpp

 cl::opt<bool> ShowCanonicalFnName("show-canonical-fname", cl::ReallyHidden,
                                   cl::init(false), cl::ZeroOrMore,
                                   cl::desc("Print canonical function name."));
 
 cl::opt<bool> ShowPseudoProbe(
     "show-pseudo-probe", cl::ReallyHidden, cl::init(false), cl::ZeroOrMore,
     cl::desc("Print pseudo probe section and disassembled info."));
 
+static cl::list<std::string> DisassembleFunctions(
+    "disassemble-functions", cl::CommaSeparated,
+    cl::desc("List of functions to print disassembly for. Accept demangled "
+             "names only. Only work with show-disassembly-only"));
+
 namespace llvm {
 namespace sampleprof {
 
 static const Target *getTarget(const ObjectFile *Obj) {
   Triple TheTriple = Obj->makeTriple();
   std::string Error;
   std::string ArchName;
   const Target *TheTarget =
uint64_t EndOffset = (SI + 1 < SE)
                            : SectionOffset + SectSize;
   if (StartOffset >= EndOffset)
     return true;
 
   StringRef SymbolName =
       ShowCanonicalFnName
           ? FunctionSamples::getCanonicalFnName(Symbols[SI].Name)
           : Symbols[SI].Name;
-  if (ShowDisassemblyOnly)
+  bool ShowDisassembly =
+      ShowDisassemblyOnly && (DisassembleFunctionSet.empty() ||
+                              DisassembleFunctionSet.count(SymbolName));
+  if (ShowDisassembly)
     outs() << '<' << SymbolName << ">:\n";
 
   auto WarnInvalidInsts = [](uint64_t Start, uint64_t End) {
     WithColor::warning() << "Invalid instructions at "
                          << format("%8" PRIx64, Start) << " - "
                          << format("%8" PRIx64, End) << "\n";
   };
 
   uint64_t Offset = StartOffset;
   // Size of a consecutive invalid instruction range starting from Offset -1
   // backwards.
   uint64_t InvalidInstLength = 0;
   while (Offset < EndOffset) {
     MCInst Inst;
     uint64_t Size;
     // Disassemble an instruction.
     bool Disassembled =
         DisAsm->getInstruction(Inst, Size, Bytes.slice(Offset - SectionOffset),
                                Offset + getPreferredBaseAddress(), nulls());
     if (Size == 0)
       Size = 1;
 
-    if (ShowDisassemblyOnly) {
+    if (ShowDisassembly) {
       if (ShowPseudoProbe) {
         ProbeDecoder.printProbeForAddress(outs(),
                                           Offset + getPreferredBaseAddress());
       }
       outs() << format("%8" PRIx64 ":", Offset + getPreferredBaseAddress());
       size_t Start = outs().tell();
       if (Disassembled)
         IPrinter->printInst(&Inst, Offset + Size, "", *STI.get(), outs());
while (Offset < EndOffset) {
     }
 
     Offset += Size;
   }
 
   if (InvalidInstLength)
     WarnInvalidInsts(Offset - InvalidInstLength, Offset - 1);
 
-  if (ShowDisassemblyOnly)
+  if (ShowDisassembly)
     outs() << "\n";
 
   FuncStartAddrMap[StartOffset] = Symbols[SI].Name.str();
   return true;
 }
 
 void ProfiledBinary::setUpDisassembler(const ELFObjectFileBase *Obj) {
   const Target *TheTarget = getTarget(Obj);
for (const SymbolRef &Symbol : Obj->symbols()) {
     if (SecI != Obj->section_end())
       AllSymbols[*SecI].push_back(SymbolInfoTy(Addr, Name, ELF::STT_NOTYPE));
   }
 
   // Sort all the symbols. Use a stable sort to stabilize the output.
   for (std::pair<const SectionRef, SectionSymbolsTy> &SecSyms : AllSymbols)
     stable_sort(SecSyms.second);
 
+  DisassembleFunctionSet.insert(DisassembleFunctions.begin(),
+                                DisassembleFunctions.end());
+  assert((DisassembleFunctionSet.empty() || ShowDisassemblyOnly) &&
+         "Functions to disassemble should be only specified together with "
+         "--show-disassembly-only");
+
   if (ShowDisassemblyOnly)
     outs() << "\nDisassembly of " << FileName << ":\n";
 
   // Dissassemble a text section.
   for (section_iterator SI = Obj->section_begin(), SE = Obj->section_end();
        SI != SE; ++SI) {
     const SectionRef &Section = *SI;
     if (!Section.isText())