[CSSPGO][llvm-profgen] Renovate perfscript check and command line input validation

[wlei]

Summary

This include some changes related with PerfReader's the input check and command line change:

1. It appears there might be thousands of leading MMAP-Event line in the perfscript for large workload. For this case, the 4k threshold is not eligible to determine it's a hybrid sample. This change renovated the isHybridPerfScript by going through the script without threshold limitation checking whether there is a non-empty call stack immediately followed by a LBR sample. It will stop once it find a valid one.

2. Added several input validations for the command line switches in PerfReader.

3. Changed the command line show-disassembly to show-disassembly-only, it will print to stdout and exit early which leave an empty output profile.

[wenlei]

llvm/tools/llvm-profgen/PerfReader.h

526

A comment showing expected input would be helpful. For LBR part, do we want to check more than leading 0x?

Should we also detect case where input doesn't have LBR at all? We don't have to do it here, but after we've processed the entire input, if no hybrid sample is found, emit an error too?

[wlei]

llvm/tools/llvm-profgen/PerfReader.h

526

Should we also detect case where input doesn't have LBR at all? We don't have to do it here, but after we've processed the entire input, if no hybrid sample is found, emit an error too?

Do you mean we should have three state for that?

1. LBR + call stack, which is detected in this function.
2. LBR only (when we detect the LBR but Count is zero)
3. no LBRs at all.

For the 3) case, we will emit an error.

[hoy]

llvm/tools/llvm-profgen/ProfiledBinary.cpp

426

nit: isShowDisassemblyEnabled

llvm/tools/llvm-profgen/llvm-profgen.cpp

49

We should probably return here with --show-disassembly and the output file should have the disassemblies instead of a sample profile.

[wenlei]

llvm/tools/llvm-profgen/PerfReader.h

526

Ok now I see the following error for #3, thanks for clarifying. Though I think it handles the case for hybrid sample, but if samples don't have stack, we don't emit error when there's no lbr? But that's probably fine as regular (non-hybrid) one is a TODO anyways.

'Hybrid perf sample is corrupted, No LBR sample line

llvm/tools/llvm-profgen/llvm-profgen.cpp

49

I thought show-disassembly prints the assembly to stdout, while the generated profile goes into output file. However, if we want the tool to show assembly instead of generating profile, we may need to rename the switch to something like show-disassembly-only.

[wlei]

Addressing Hongtao and Wenlei's feedback

[wlei]

llvm/tools/llvm-profgen/PerfReader.h

526

A comment showing expected input would be helpful.

Example added

For LBR part, do we want to check more than leading 0x?

Just separate a function for this and add another condition to check whether '/' exists

but if samples don't have stack, we don't emit error when there's no lbr

I think I miss this. If there is no stack and no lbr, we should emit error earlier. Added in the latest diff, thanks for the remainder.

llvm/tools/llvm-profgen/llvm-profgen.cpp

49

I see, how about we support both?
show-disassembly print to stdout and also generate profile.
show-disassembly-only only print to output file, this can be used for the disassembly output only test.

[hoy]

llvm/tools/llvm-profgen/PerfReader.h

529

Add a test for this?

llvm/tools/llvm-profgen/llvm-profgen.cpp

49

Sounds good, thanks!

[wlei]

Address Hongtao's feedback: added test case for invalid script check

[wlei]

llvm/tools/llvm-profgen/PerfReader.h

529

Just added the invalid-perfscript.test, is that the test you want?
I think we already have the test for hybrid sample since all the profile generation test use hybrid sample as input.

[wenlei]

llvm/tools/llvm-profgen/PerfReader.h

63

typo: PERF_INVALID. Can we keep the enum 0 based?

llvm/tools/llvm-profgen/llvm-profgen.cpp

49

These wrappers and layers in reader and binary feels like we're doing a bit too much for showAssembly. In the end, showAssembly is not the main purpose of the tool. How about simplify it:

• Let's always print showAssembly to stdout. This is more like a verbose log rather than output, so I think it's better to avoid dumping it in the output file.
• Only have show-disassembly-only mode (which is mostly used in combination with probe annotation), add early exit for that, and produce empty output profile.

[wlei]

address reviewers' feedback:
rename showAssembly to show-disassembly-only and change back to print to stdout

llvm/tools/llvm-profgen/PerfReader.h

63

Good catch!

llvm/tools/llvm-profgen/llvm-profgen.cpp

49

thanks for the discussing, fixed！

[wlei]

fix clang-tidy

[wenlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

81

Why do we need to go through PerfReader::getOutputFilename in order to access the output file from command line?

Same for ProfiledBinary::isShowDisassemblyOnlyEnabled etc., can we access the global directly (add extern declaration if needed)? These wrappers seem a bit overkill given they're not really per-binary for per-reader config.

[hoy]

llvm/tools/llvm-profgen/ProfiledBinary.cpp

22

Why need this? Will std::out work?

llvm/tools/llvm-profgen/ProfiledBinary.h

268

Remove this since we are keeping only show-disassembly-only?

[wlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

81

StringRef OutputFilename = PerfReader::getOutputFilename();

yeah, I miss to remove this.

can we access the global directly (add extern declaration if needed)?

I thought to use static function wrapper as the global. Yeah, use an extern global is clearer. Let me change it

[wlei]

address Wenlei and Hongtao's feedback: switch to use global command line variable and some refactoring work

[wlei]

llvm/tools/llvm-profgen/ProfiledBinary.cpp

22

This is redundant, removed.

llvm/tools/llvm-profgen/ProfiledBinary.h

268

Yeah, overlook this, thanks for the reminder.

[wenlei]

llvm/tools/llvm-profgen/ProfiledBinary.cpp

44

This works, but we could make it simpler:

ProfileBinary.cpp:

cl::opt<bool> ShowDisassembly("show-disassembly", cl::ReallyHidden,
                                     cl::init(false), cl::ZeroOrMore,
                                     cl::desc("Print disassembled code."));

llvm-profgen.cpp:

extern cl::opt<bool> ShowDisassembly;

[wlei]

change to extern cl::opt<bool> ShowDisassemblyOnly

[wlei]

llvm/tools/llvm-profgen/ProfiledBinary.cpp

44

Yeah, learned it!

[wenlei]

lgtm, thanks.

[hoy]

LGTM. Maybe update the summary to reflect the command line change? Thanks.

llvm/test/tools/llvm-profgen/disassemble.s

 # REQUIRES: x86-registered-target
 # RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t
-# RUN: llvm-profgen --binary=%t --perfscript=%s --output=%t1 -show-disassembly -x86-asm-syntax=intel | FileCheck %s --match-full-lines
+# RUN: llvm-profgen --binary=%t --perfscript=%s --output=%t1 -show-disassembly-only -x86-asm-syntax=intel
+# RUN: FileCheck %s --input-file %t1 --match-full-lines
 
 # CHECK: Disassembly of section .text [0x0, 0x66]:
 # CHECK: <foo1>:
 # CHECK:        0:  push  rbp
 # CHECK:        1:  mov rbp, rsp
 # CHECK:        4:  sub rsp, 16
 # CHECK:        8:  mov dword ptr [rbp - 4], 0
 # CHECK:        f:  mov edi, 1

llvm/test/tools/llvm-profgen/invalid-perfscript.test

+; RUN: llvm-profgen --perfscript=%s --binary=%S/Inputs/noinline-cs-noprobe.perfbin --output=%t 2>%t1
+; RUN: FileCheck %s --input-file %t1
+
+            4005dc
+            400634
+            400684
+      7f68c5788793
+
+; XFAIL: *

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

-; RUN: llvm-profgen --perfscript=%s  --binary=%S/Inputs/inline-cs-pseudoprobe.perfbin --output=%t --show-pseudo-probe --show-disassembly | FileCheck %s
+; RUN: llvm-profgen --perfscript=%s  --binary=%S/Inputs/inline-cs-pseudoprobe.perfbin --output=%t --show-pseudo-probe --show-disassembly-only
+; RUN: FileCheck %s --input-file %t
 
 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: 138950591924
 ; CHECK: GUID: 15822663052811949562 Name: main
 ; CHECK: Hash: 4294967295

llvm/test/tools/llvm-profgen/symbolize.ll

 ; REQUIRES: x86-registered-target
 ; RUN: llc -filetype=obj %s -o %t
-; RUN: llvm-profgen --binary=%t --perfscript=%s --output=%t1 --show-disassembly -x86-asm-syntax=intel --show-source-locations | FileCheck %s --match-full-lines
+; RUN: llvm-profgen --binary=%t --perfscript=%s --output=%t1 --show-disassembly-only -x86-asm-syntax=intel --show-source-locations
+; RUN: FileCheck %s --input-file %t1 --match-full-lines
 
 ; CHECK: Disassembly of section .text [0x0, 0x4a]:
 ; CHECK: <funcA>:
 ; CHECK:        0:  mov eax, edi                         funcA:0
 ; CHECK:        2:  mov ecx, dword ptr [rip]             funcLeaf:2 @ funcA:1
 ; CHECK:        8:  lea edx, [rcx + 3]                   fib:2 @ funcLeaf:2 @ funcA:1
 ; CHECK:        b:  cmp ecx, 3                           fib:2 @ funcLeaf:2 @ funcA:1
 ; CHECK:        e:  cmovl edx, ecx                       fib:2 @ funcLeaf:2 @ funcA:1

llvm/tools/llvm-profgen/PerfReader.h

if (!std::getline(Fin, CurrentLine)) {
       return;
     }
     LineNumber++;
   }
 };
 
 // The type of perfscript
 enum PerfScriptType {
+  PERF_UNKNOWN = -1,
   PERF_INVILID = 0,
   PERF_LBR = 1,       // Only LBR sample
   PERF_LBR_STACK = 2, // Hybrid sample including call stack and LBR stack.
 };
 
 // The parsed LBR sample entry.
 struct LBREntry {
   uint64_t Source = 0;
   uint64_t Target = 0;

 // counter
 using BinarySampleCounterMap =
     std::unordered_map<ProfiledBinary *, ContextSampleCounterMap>;
 
 // Load binaries and read perf trace to parse the events and samples
 class PerfReader {
 
 public:
-  PerfReader(cl::list<std::string> &BinaryFilenames);
+  PerfReader(cl::list<std::string> &BinaryFilenames,
+             cl::list<std::string> &PerfTraceFilenames);
 
-  // Hybrid sample(call stack + LBRs) profile traces are seprated by double line
-  // break, search for that within the first 4k charactors to avoid going
-  // through the whole file.
-  static bool isHybridPerfScript(StringRef FileName) {
-    auto BufOrError = MemoryBuffer::getFileOrSTDIN(FileName, 4000);
-    if (!BufOrError)
-      exitWithError(BufOrError.getError(), FileName);
-    auto Buffer = std::move(BufOrError.get());
-    if (Buffer->getBuffer().find("\n\n") == StringRef::npos)
+  // A LBR sample is like:
+  // 0x5c6313f/0x5c63170/P/-/-/0  0x5c630e7/0x5c63130/P/-/-/0 ...
+  // A heuristic for fast detection by checking whether a
+  // leading "  0x" and the '/' exist.
+  static bool isLBRSample(StringRef Line) {
+    if (!Line.startswith(" 0x"))
       return false;
+    if (Line.find('/') != StringRef::npos)
       return true;
+    return false;
+  }
+
+  // The raw hybird sample is like
+  // e.g.
+  //            4005dc    # call stack leaf
+  //            400634
+  //            400684    # call stack root
+  // 0x4005c8/0x4005dc/P/-/-/0   0x40062f/0x4005b0/P/-/-/0 ...
+  //          ... 0x4005c8/0x4005dc/P/-/-/0    # LBR Entries
+  // Determine the perfscript contains hybrid samples(call stack + LBRs) by
+  // checking whether there is a non-empty call stack immediately followed by
+  // a LBR sample
+  static PerfScriptType checkPerfScriptType(StringRef FileName) {
+    TraceStream TraceIt(FileName);
+    uint64_t FrameAddr = 0;
+    while (!TraceIt.isAtEoF()) {
+      int32_t Count = 0;
+      while (!TraceIt.isAtEoF() &&
+             !TraceIt.getCurrentLine().ltrim().getAsInteger(16, FrameAddr)) {
+        Count++;
+        TraceIt.advance();
+      }
+      if (!TraceIt.isAtEoF()) {
+        if (isLBRSample(TraceIt.getCurrentLine())) {
+          if (Count > 0)
+            return PERF_LBR_STACK;
+          else
+            return PERF_LBR;
+        }
+        TraceIt.advance();
+      }
+    }
+    return PERF_INVILID;
   }
 
   // The parsed MMap event
   struct MMapEvent {
     uint64_t PID = 0;
     uint64_t BaseAddress = 0;
     uint64_t Size = 0;
     uint64_t Offset = 0;
     StringRef BinaryPath;
   };
 
   /// Load symbols and disassemble the code of a give binary.
   /// Also register the binary in the binary table.
   ///
   ProfiledBinary &loadBinary(const StringRef BinaryPath,
                              bool AllowNameConflict = true);
   void updateBinaryAddress(const MMapEvent &Event);
   PerfScriptType getPerfScriptType() const { return PerfType; }
   // Entry of the reader to parse multiple perf traces
   void parsePerfTraces(cl::list<std::string> &PerfTraceFilenames);
   const BinarySampleCounterMap &getBinarySampleCounters() const {
     return BinarySampleCounters;
   }
+  static StringRef getOutputFilename();
+  static bool ShowDisassemblyOnly() {
+    return ProfiledBinary::isShowDisassemblyOnlyEnabled();
+  }
 
 private:
+  /// Validate the command line input
+  void validateCommandLine(cl::list<std::string> &BinaryFilenames,
+                           cl::list<std::string> &PerfTraceFilenames);
   /// Parse a single line of a PERF_RECORD_MMAP2 event looking for a
   /// mapping between the binary name and its memory layout.
   ///
   void parseMMap2Event(TraceStream &TraceIt);
   // Parse perf events/samples and do aggregation
   void parseAndAggregateTrace(StringRef Filename);
   // Parse either an MMAP event or a perf sample
   void parseEventOrSample(TraceStream &TraceIt);
private:
 
   BinaryMap BinaryTable;
   AddressBinaryMap AddrToBinaryMap; // Used by address-based lookup.
 
 private:
   BinarySampleCounterMap BinarySampleCounters;
   // Samples with the repeating time generated by the perf reader
   AggregatedCounter AggregatedSamples;
-  PerfScriptType PerfType;
+  PerfScriptType PerfType = PERF_UNKNOWN;
 };
 
 } // end namespace sampleprof
 } // end namespace llvm
 
 #endif

llvm/tools/llvm-profgen/PerfReader.cpp

 //===-- PerfReader.cpp - perfscript reader  ---------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "PerfReader.h"
 #include "ProfileGenerator.h"
 
+static cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
+                                           cl::Required,
+                                           cl::desc("Output profile file"));
+static cl::alias OutputA("o", cl::desc("Alias for --output"),
+                         cl::aliasopt(OutputFilename));
 static cl::opt<bool> ShowMmapEvents("show-mmap-events", cl::ReallyHidden,
                                     cl::init(false), cl::ZeroOrMore,
                                     cl::desc("Print binary load events."));
 
 static cl::opt<bool> ShowUnwinderOutput("show-unwinder-output",
                                         cl::ReallyHidden, cl::init(false),
                                         cl::ZeroOrMore,
                                         cl::desc("Print unwinder output"));
while (State.hasNextLBR()) {
     recordBranchCount(Branch, State, Repeat);
   }
   // As samples are aggregated on trie, record them into counter map
   collectSamplesFromFrameTrie(State.getDummyRootPtr());
 
   return true;
 }
 
-PerfReader::PerfReader(cl::list<std::string> &BinaryFilenames) {
+void PerfReader::validateCommandLine(
+    cl::list<std::string> &BinaryFilenames,
+    cl::list<std::string> &PerfTraceFilenames) {
+  // Allow the invalid perfscript if we only use to show binary disassembly
+  if (!ProfiledBinary::isShowDisassemblyOnlyEnabled()) {
+    for (auto &File : PerfTraceFilenames) {
+      if (!llvm::sys::fs::exists(File)) {
+        std::string Msg = "Input perf script(" + File + ") doesn't exist!";
+        exitWithError(Msg);
+      }
+    }
+  }
+  if (BinaryFilenames.size() > 1) {
+    // TODO: remove this if everything is ready to support multiple binaries.
+    exitWithError(
+        "Currently only support one input binary, multiple binaries' "
+        "profile will be merged in one profile and make profile "
+        "summary info inaccurate. Please use `llvm-perfdata` to merge "
+        "profiles from multiple binaries.");
+  }
+  for (auto &Binary : BinaryFilenames) {
+    if (!llvm::sys::fs::exists(Binary)) {
+      std::string Msg = "Input binary(" + Binary + ") doesn't exist!";
+      exitWithError(Msg);
+    }
+  }
+  if (CSProfileGenerator::MaxCompressionSize < -1) {
+    exitWithError("Value of --compress-recursion should >= -1");
+  }
+  if (ProfiledBinary::isShowSourceLocationsEnabled() &&
+      !ProfiledBinary::showDisassembly()) {
+    exitWithError("--show-source-locations should work together with "
+                  "--show-disassembly!");
+  }
+}
+
+PerfReader::PerfReader(cl::list<std::string> &BinaryFilenames,
+                       cl::list<std::string> &PerfTraceFilenames) {
+  validateCommandLine(BinaryFilenames, PerfTraceFilenames);
   // Load the binaries.
   for (auto Filename : BinaryFilenames)
     loadBinary(Filename, /*AllowNameConflict*/ false);
 }
 
 ProfiledBinary &PerfReader::loadBinary(const StringRef BinaryPath,
                                        bool AllowNameConflict) {
   // The binary table is currently indexed by the binary name not the full
   // binary path. This is because the user-given path may not match the one
   // that was actually executed.
   StringRef BinaryName = llvm::sys::path::filename(BinaryPath);
 
   // Call to load the binary in the ctor of ProfiledBinary.
-  auto Ret = BinaryTable.insert({BinaryName, ProfiledBinary(BinaryPath)});
+  auto Ret = BinaryTable.insert(
+      {BinaryName, ProfiledBinary(BinaryPath, OutputFilename)});
 
   if (!Ret.second && !AllowNameConflict) {
     std::string ErrorMsg = "Binary name conflict: " + BinaryPath.str() +
                            " and " + Ret.first->second.getPath().str() + " \n";
     exitWithError(ErrorMsg);
   }
 
   return Ret.first->second;
void PerfReader::parseAndAggregateTrace(StringRef Filename) {
   // Trace line iterator
   TraceStream TraceIt(Filename);
   while (!TraceIt.isAtEoF())
     parseEventOrSample(TraceIt);
 }
 
 void PerfReader::checkAndSetPerfType(
     cl::list<std::string> &PerfTraceFilenames) {
-  bool HasHybridPerf = true;
   for (auto FileName : PerfTraceFilenames) {
-    if (!isHybridPerfScript(FileName)) {
-      HasHybridPerf = false;
-      break;
-    }
-  }
-
-  if (HasHybridPerf) {
-    PerfType = PERF_LBR_STACK;
-  } else {
-    // TODO: Support other type of perf script
-    PerfType = PERF_INVILID;
-  }
-
-  if (BinaryTable.size() > 1) {
-    // TODO: remove this if everything is ready to support multiple binaries.
-    exitWithError("Currently only support one input binary, multiple binaries' "
-                  "profile will be merged in one profile and make profile "
-                  "summary info inaccurate. Please use `perfdata` to merge "
-                  "profiles from multiple binaries.");
+    PerfScriptType Type = checkPerfScriptType(FileName);
+    if (Type == PERF_INVILID)
+      exitWithError("Invalid perf script input!");
+    if (PerfType != PERF_UNKNOWN && PerfType != Type)
+      exitWithError("Inconsistent sample among different perf scripts");
+    PerfType = Type;
   }
 }
 
 void PerfReader::generateRawProfile() {
   if (getPerfScriptType() == PERF_LBR_STACK) {
     // Unwind samples if it's hybird sample
     unwindSamples();
   } else if (getPerfScriptType() == PERF_LBR) {
     // TODO: range overlap computation for regular AutoFDO
   }
 }
 
 void PerfReader::parsePerfTraces(cl::list<std::string> &PerfTraceFilenames) {
   // Check and set current perfscript type
   checkAndSetPerfType(PerfTraceFilenames);
   // Parse perf traces and do aggregation.
   for (auto Filename : PerfTraceFilenames)
     parseAndAggregateTrace(Filename);
 
   generateRawProfile();
 }
 
+StringRef PerfReader::getOutputFilename() { return OutputFilename; }
+
 } // end namespace sampleprof
 } // end namespace llvm

llvm/tools/llvm-profgen/ProfileGenerator.cpp

 //===-- ProfileGenerator.cpp - Profile Generator  ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ProfileGenerator.h"
 
-static cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
-                                           cl::Required,
-                                           cl::desc("Output profile file"));
-
 static cl::opt<SampleProfileFormat> OutputFormat(
     "format", cl::desc("Format of output profile"), cl::init(SPF_Text),
     cl::values(
         clEnumValN(SPF_Binary, "binary", "Binary encoding (default)"),
         clEnumValN(SPF_Compact_Binary, "compbinary", "Compact binary encoding"),
         clEnumValN(SPF_Ext_Binary, "extbinary", "Extensible binary encoding"),
         clEnumValN(SPF_Text, "text", "Text encoding"),
         clEnumValN(SPF_GCC, "gcc",

 }
 
 void ProfileGenerator::write(std::unique_ptr<SampleProfileWriter> Writer,
                              StringMap<FunctionSamples> &ProfileMap) {
   Writer->write(ProfileMap);
 }
 
 void ProfileGenerator::write() {
+  StringRef OutputFilename = PerfReader::getOutputFilename();
   auto WriterOrErr = SampleProfileWriter::create(OutputFilename, OutputFormat);
   if (std::error_code EC = WriterOrErr.getError())
     exitWithError(EC, OutputFilename);
   write(std::move(WriterOrErr.get()), ProfileMap);
 }
 
 void ProfileGenerator::findDisjointRanges(RangeSample &DisjointRanges,
                                           const RangeSample &Ranges) {

llvm/tools/llvm-profgen/ProfiledBinary.h

class ProfiledBinary {
   // A set of return instruction offsets. Used by virtual unwinding.
   std::unordered_set<uint64_t> RetAddrs;
 
   PrologEpilogTracker ProEpilogTracker;
 
   // The symbolizer used to get inline context for an instruction.
   std::unique_ptr<symbolize::LLVMSymbolizer> Symbolizer;
 
+  // Disassembly output file name stream
+  StringRef OutputFilename;
+
+  // Disassembly output stream
+  std::unique_ptr<raw_fd_ostream> AsmOStream;
+
   // Pseudo probe decoder
   PseudoProbeDecoder ProbeDecoder;
 
   bool UsePseudoProbes = false;
 
   void setPreferredBaseAddress(const ELFObjectFileBase *O);
 
   void decodePseudoProbe(const ELFObjectFileBase *Obj);
class ProfiledBinary {
   const FrameLocationStack &getFrameLocationStack(uint64_t Offset) const {
     auto I = Offset2LocStackMap.find(Offset);
     assert(I != Offset2LocStackMap.end() &&
            "Can't find location for offset in the binary");
     return I->second;
   }
 
 public:
-  ProfiledBinary(StringRef Path) : Path(Path), ProEpilogTracker(this) {
+  ProfiledBinary(StringRef Path, StringRef FileName)
+      : Path(Path), ProEpilogTracker(this), OutputFilename(FileName) {
     setupSymbolizer();
     load();
   }
   uint64_t virtualAddrToOffset(uint64_t VitualAddress) const {
     return VitualAddress - BaseAddress;
   }
   uint64_t offsetToVirtualAddr(uint64_t Offset) const {
     return Offset + BaseAddress;
const AddressProbesMap &getAddress2ProbesMap() const {
     return ProbeDecoder.getAddress2ProbesMap();
   }
   const PseudoProbeFuncDesc *getFuncDescForGUID(uint64_t GUID) {
     return ProbeDecoder.getFuncDescForGUID(GUID);
   }
   const PseudoProbeFuncDesc *getInlinerDescForProbe(const PseudoProbe *Probe) {
     return ProbeDecoder.getInlinerDescForProbe(Probe);
   }
+  static bool showDisassembly();
+  static bool isShowDisassemblyOnlyEnabled();
+  static bool isShowSourceLocationsEnabled();
+  static bool isShowPseudoProbeEnabled();
 };
 
 } // end namespace sampleprof
 } // end namespace llvm
 
 #endif

llvm/tools/llvm-profgen/ProfiledBinary.cpp

 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 
 #define DEBUG_TYPE "load-binary"
 
+#ifndef STDOUT_FILENO
+#define STDOUT_FILENO 1
+#endif
+
 using namespace llvm;
 using namespace sampleprof;
 
 static cl::opt<bool> ShowDisassembly("show-disassembly", cl::ReallyHidden,
                                      cl::init(false), cl::ZeroOrMore,
                                      cl::desc("Print disassembled code."));
 
+static cl::opt<bool>
+    ShowDisassemblyOnly("show-disassembly-only", cl::ReallyHidden,
+                        cl::init(false), cl::ZeroOrMore,
+                        cl::desc("Only print disassembled code to the file "
+                                 "specified with the --output"));
+
 static cl::opt<bool> ShowSourceLocations("show-source-locations",
                                          cl::ReallyHidden, cl::init(false),
                                          cl::ZeroOrMore,
                                          cl::desc("Print source locations."));
 
 static cl::opt<bool> ShowPseudoProbe(
     "show-pseudo-probe", cl::ReallyHidden, cl::init(false), cl::ZeroOrMore,
     cl::desc("Print pseudo probe section and disassembled info."));
 
 namespace llvm {
 namespace sampleprof {
 
 static const Target *getTarget(const ObjectFile *Obj) {
   Triple TheTriple = Obj->makeTriple();
static uint64_t getELFImageLMAForSec(const object::ELFSectionRef &Sec) {
   else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Sec.getObject()))
     return getELFImageLMAForSec(ELFObj->getELFFile(), Sec,
                                 ELFObj->getFileName());
   const auto *ELFObj = cast<ELF64BEObjectFile>(Sec.getObject());
   return getELFImageLMAForSec(ELFObj->getELFFile(), Sec, ELFObj->getFileName());
 }
 
 void ProfiledBinary::load() {
+  if (ShowDisassemblyOnly) {
+    std::error_code EC;
+    AsmOStream.reset(
+        new raw_fd_ostream(OutputFilename, EC, llvm::sys::fs::OF_Text));
+    if (EC)
+      exitWithError(EC);
+  } else {
+    // output to stdout
+    AsmOStream.reset(new raw_fd_ostream(STDOUT_FILENO, true));
+  }
   // Attempt to open the binary.
   OwningBinary<Binary> OBinary = unwrapOrError(createBinary(Path), Path);
   Binary &Binary = *OBinary.getBinary();
 
   auto *Obj = dyn_cast<ELFObjectFileBase>(&Binary);
   if (!Obj)
     exitWithError("not a valid Elf image", Path);
 
if (SectionName == ".pseudo_probe_desc") {
       ProbeDecoder.buildAddress2ProbeMap(
           reinterpret_cast<const uint8_t *>(Contents.data()), Contents.size());
       // set UsePseudoProbes flag, used for PerfReader
       UsePseudoProbes = true;
     }
   }
 
   if (ShowPseudoProbe)
-    ProbeDecoder.printGUID2FuncDescMap(outs());
+    ProbeDecoder.printGUID2FuncDescMap(*AsmOStream);
 }
 
 bool ProfiledBinary::dissassembleSymbol(std::size_t SI, ArrayRef<uint8_t> Bytes,
                                         SectionSymbolsTy &Symbols,
                                         const SectionRef &Section) {
-
+  auto &OS = *AsmOStream;
   std::size_t SE = Symbols.size();
   uint64_t SectionOffset = Section.getAddress() - PreferredBaseAddress;
   uint64_t SectSize = Section.getSize();
   uint64_t StartOffset = Symbols[SI].Addr - PreferredBaseAddress;
   uint64_t EndOffset = (SI + 1 < SE)
                            ? Symbols[SI + 1].Addr - PreferredBaseAddress
                            : SectionOffset + SectSize;
   if (StartOffset >= EndOffset)
     return true;
 
   std::string &&SymbolName = Symbols[SI].Name.str();
-  if (ShowDisassembly)
-    outs() << '<' << SymbolName << ">:\n";
+  if (showDisassembly())
+    OS << '<' << SymbolName << ">:\n";
 
   uint64_t Offset = StartOffset;
   while (Offset < EndOffset) {
     MCInst Inst;
     uint64_t Size;
     // Disassemble an instruction.
     if (!DisAsm->getInstruction(Inst, Size, Bytes.slice(Offset - SectionOffset),
                                 Offset + PreferredBaseAddress, nulls()))
       return false;
 
-    if (ShowDisassembly) {
+    if (showDisassembly()) {
       if (ShowPseudoProbe) {
-        ProbeDecoder.printProbeForAddress(outs(),
-                                          Offset + PreferredBaseAddress);
+        ProbeDecoder.printProbeForAddress(OS, Offset + PreferredBaseAddress);
       }
-      outs() << format("%8" PRIx64 ":", Offset);
-      size_t Start = outs().tell();
-      IPrinter->printInst(&Inst, Offset + Size, "", *STI.get(), outs());
+      OS << format("%8" PRIx64 ":", Offset);
+      size_t Start = OS.tell();
+      IPrinter->printInst(&Inst, Offset + Size, "", *STI.get(), OS);
       if (ShowSourceLocations) {
-        unsigned Cur = outs().tell() - Start;
+        unsigned Cur = OS.tell() - Start;
         if (Cur < 40)
-          outs().indent(40 - Cur);
+          OS.indent(40 - Cur);
         InstructionPointer Inst(this, Offset);
-        outs() << getReversedLocWithContext(symbolize(Inst));
+        OS << getReversedLocWithContext(symbolize(Inst));
       }
-      outs() << "\n";
+      OS << "\n";
     }
 
     const MCInstrDesc &MCDesc = MII->get(Inst.getOpcode());
 
     // Populate a vector of the symbolized callsite at this location
     InstructionPointer IP(this, Offset);
     Offset2LocStackMap[Offset] = symbolize(IP, true);
 
     // Populate address maps.
     CodeAddrs.push_back(Offset);
     if (MCDesc.isCall())
       CallAddrs.insert(Offset);
     else if (MCDesc.isReturn())
       RetAddrs.insert(Offset);
 
     Offset += Size;
   }
 
-  if (ShowDisassembly)
-    outs() << "\n";
+  if (showDisassembly())
+    OS << "\n";
 
   FuncStartAddrMap[StartOffset] = Symbols[SI].Name.str();
   return true;
 }
 
 void ProfiledBinary::setUpDisassembler(const ELFObjectFileBase *Obj) {
   const Target *TheTarget = getTarget(Obj);
   std::string TripleName = TheTriple.getTriple();
void ProfiledBinary::setUpDisassembler(const ELFObjectFileBase *Obj) {
 
   int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
   IPrinter.reset(TheTarget->createMCInstPrinter(
       Triple(TripleName), AsmPrinterVariant, *AsmInfo, *MII, *MRI));
   IPrinter->setPrintBranchImmAsAddress(true);
 }
 
 void ProfiledBinary::disassemble(const ELFObjectFileBase *Obj) {
+  auto &OS = *AsmOStream;
   // Set up disassembler and related components.
   setUpDisassembler(Obj);
 
   // Create a mapping from virtual address to symbol name. The symbols in text
   // sections are the candidates to dissassemble.
   std::map<SectionRef, SectionSymbolsTy> AllSymbols;
   StringRef FileName = Obj->getFileName();
   for (const SymbolRef &Symbol : Obj->symbols()) {
     const uint64_t Addr = unwrapOrError(Symbol.getAddress(), FileName);
     const StringRef Name = unwrapOrError(Symbol.getName(), FileName);
     section_iterator SecI = unwrapOrError(Symbol.getSection(), FileName);
     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);
 
-  if (ShowDisassembly)
-    outs() << "\nDisassembly of " << FileName << ":\n";
+  if (showDisassembly())
+    OS << "\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())
       continue;
 
     uint64_t ImageLoadAddr = PreferredBaseAddress;
     uint64_t SectionOffset = Section.getAddress() - ImageLoadAddr;
     uint64_t SectSize = Section.getSize();
     if (!SectSize)
       continue;
 
     // Register the text section.
     TextSections.insert({SectionOffset, SectSize});
 
-    if (ShowDisassembly) {
+    if (showDisassembly()) {
       StringRef SectionName = unwrapOrError(Section.getName(), FileName);
-      outs() << "\nDisassembly of section " << SectionName;
-      outs() << " [" << format("0x%" PRIx64, SectionOffset) << ", "
-             << format("0x%" PRIx64, SectionOffset + SectSize) << "]:\n\n";
+      OS << "\nDisassembly of section " << SectionName;
+      OS << " [" << format("0x%" PRIx64, SectionOffset) << ", "
     }
 
     // Get the section data.
     ArrayRef<uint8_t> Bytes =
         arrayRefFromStringRef(unwrapOrError(Section.getContents(), FileName));
 
     // Get the list of all the symbols in this section.
     SectionSymbolsTy &Symbols = AllSymbols[Section];
LineLocation Line(CallerFrame.Line - CallerFrame.StartLine,
                           CallerFrame.Discriminator));
     FrameLocation Callsite(FunctionName.str(), Line);
     CallStack.push_back(Callsite);
   }
 
   return CallStack;
 }
 
+bool ProfiledBinary::showDisassembly() {
+  return ShowDisassembly || ShowDisassemblyOnly;
+}
+
+bool ProfiledBinary::isShowDisassemblyOnlyEnabled() {
+  return ShowDisassemblyOnly;
+}
+
+bool ProfiledBinary::isShowSourceLocationsEnabled() {
+  return ShowSourceLocations;
+}
+
+bool ProfiledBinary::isShowPseudoProbeEnabled() { return ShowPseudoProbe; }
+
 InstructionPointer::InstructionPointer(ProfiledBinary *Binary, uint64_t Address,
                                        bool RoundToNext)
     : Binary(Binary), Address(Address) {
   Index = Binary->getIndexForAddr(Address);
   if (RoundToNext) {
     // we might get address which is not the code
     // it should round to the next valid address
     this->Address = Binary->getAddressforIndex(Index);

llvm/tools/llvm-profgen/llvm-profgen.cpp

int main(int argc, const char *argv[]) {
   // Initialize targets and assembly printers/parsers.
   InitializeAllTargetInfos();
   InitializeAllTargetMCs();
   InitializeAllDisassemblers();
 
   cl::ParseCommandLineOptions(argc, argv, "llvm SPGO profile generator\n");
 
   // Load binaries and parse perf events and samples
-  PerfReader Reader(BinaryFilenames);
+  PerfReader Reader(BinaryFilenames, PerfTraceFilenames);
+  if (Reader.ShowDisassemblyOnly())
+    return EXIT_SUCCESS;
   Reader.parsePerfTraces(PerfTraceFilenames);
 
   std::unique_ptr<ProfileGenerator> Generator = ProfileGenerator::create(
       Reader.getBinarySampleCounters(), Reader.getPerfScriptType());
   Generator->generateProfile();
   Generator->write();
 
   return EXIT_SUCCESS;
 }