[llvm-profgen] Allow unsymbolized profile as perf input

[wlei]

Summary

This change allows the unsymbolized profile as input. The unsymbolized profile is created by llvm-profgen with --skip-symbolization and it's after the sample aggregation but before symbolization , so it has much small file size. It can be used for sample merging and trimming, also is useful for debugging or adding test cases. A switch --unsymbolized-profile=file-patch is added for this.

Format of unsymbolized profile:

[context stack1]    # If it's a CS profile
   number of entries in RangeCounter
   from_1-to_1:count_1
   from_2-to_2:count_2
   ......
   from_n-to_n:count_n
   number of entries in BranchCounter
   src_1->dst_1:count_1
   src_2->dst_2:count_2
   ......
   src_n->dst_n:count_n
 [context stack2]
   ......

[hoy]

Thanks for bringing up the support of raw profile as input. Can you please describe the format of raw profile in the summary and somewhere in the code (RawProfileReader) ?

[wenlei]

llvm/tools/llvm-profgen/PerfReader.cpp

310–311

How about we use PerfInputFile PerfReaderBase::convertPerfDataToTrace(ProfiledBinary *Binary, PerfInputFile &PerfInput), and return a new PerfInput from the function?

719–726

Can we move this a lambda instead of global function since it's only used in readSampleCounters?

If lambda grows too big, we can use member functions too.

728

Some comment showing the expected input for parsing would be helpful.

758

If we use this flag to control profile reading too, we need to update flag description.

775–776

The underlying object created by make_shared stays on heap, but SampleCounters.emplace creates another copy of the object? is that intentional or did I miss anything?

784

Would it better if hash code is lazily generated instead of requiring an explicit call?

getHashCode() {
  if (HashCode == 0) 
     genHashCode()
  ...
}

794–795

So if user specify skip-symbolization and the input is raw profile, we are just reading it in and then writing it out without doing anything?

llvm/tools/llvm-profgen/PerfReader.h

62

nit: all caps is usually only used for macro. For enum, it's better to follow normal variable naming, which is also the convention used in llvm

62–67

These are not mutually exclusive types. e.g. PERFSCRIPT_UNKNOWN can be either PERFSCRIPT_LBR or PERFSCRIPT_LBR_STACK.

Logically there're two things being represented, the format and the content. To avoid exponential combination and to have a clear separation, perhaps use format, content masks instead, or even separate them out?

We can have format = RawProfile|PerfScript|PerfData, and content = LBR|LBRStack|Aggregated.

73–74

nit: it's cleaner to keep it a POD type and remove the ctor. we can use initializer list to create the object.

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

52

I'm not sure if raw profile is a good name. the real raw profile is the perf.data, after some processing we get perf script, and with more processing we get this "raw profile". Perhaps we need a alternative name, unsymbolized profile?

109

nit: createPerfInputFile -> getPerfInputFile

[wlei]

rebase and addressing feedbacks

[wlei]

In D111750#3070920, @hoy wrote:

Thanks for bringing up the support of raw profile as input. Can you please describe the format of raw profile in the summary and somewhere in the code (RawProfileReader) ?

Sounds good. added the format to the head of class.

llvm/tools/llvm-profgen/PerfReader.cpp

310–311

Fixed.

719–726

Moved to a lambda.

728

comments added

758

description updated

784

Here to explicitly call genHashCode is intentional, the reason is we want to avoid making genHashCode a virtual function, i, e, avoid call genHashCode after casting to base class. so we separate like:

derived class:  HashCode = genHashCode();

base class :  getHashCode{return HashCode;}

794–795

Yes, otherwise user give skip-symbolization with unsymbolized profile, it won't have output. And I actually used it during debugging or maybe in the future we can do something after read then output it.

Added a warning to this

llvm/tools/llvm-profgen/PerfReader.h

62

Fixed, thanks!

62–67

Makes sense.Changed to separate them out.

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

52

yeah, it's clearer to use --unsymbolized-profile, changed. The name is a little long then, so add an alias to it.

[wlei]

llvm/tools/llvm-profgen/PerfReader.cpp

775–776

(Seems phabricator lost my comments..)

SampleCounters key is a Hashable<ContextKey> type.

My understanding is emplace will call the ctor of Hashable, it's like:

template <class T> class Hashable {
public:
  std::shared_ptr<T> Data;
  Hashable(const std::shared_ptr<T> &D) : Data(D) {}
...

Hashable only own the shared_ptr, do not own the underlying object, so it should only copy the shared_ptr.

[wenlei]

llvm/tools/llvm-profgen/PerfReader.cpp

358–359

nit: we can do return {PerfTraceFile, PerfFormat::PerfScript, PerfContent::Unknown};

784

Not sure if I understand. Why do we want to avoid call genHashCode after casting to base class?

llvm/tools/llvm-profgen/PerfReader.h

62–67

Now that format and content are separated, perhaps they no longer need to use mask within each? Sorry if I wasn't clear, mask or separate field are two ways to have separation for format and content.

70

We still want to reserve 0 as unknown or invalid?

78–79

Can we use enum types instead of integer?

651

Also comment to explain the difference between CS and non-CS profile?

[wlei]

Updating D111750: [llvm-profgen] Allow unsymbolized profile as perf input

llvm/tools/llvm-profgen/PerfReader.cpp

358–359

Good to know this, thanks

784

Currently we have two type of key, StrKey and ProbeKey and they derived from the base ContextKey.

We have a hash map to store them, like unordered_map<ContextKey, ...>, the logic of insert is like

StrKey* key = ..

hashmap[key] = ...;

In the hashmap, StrKey*/ProbeKey* implicitly be cast to a ContextKey* class then call ContextKey->getHashCode , so getHashCode should be a virtual function which has overhead because StrKey and ProbeKey have different genHashCode.

So to avoid this, we can explicitly call StrKey->genHashCode() before being casting to base and store it into a variable HashCode

then base's getHashCode just read the HasCode, no need a virtual function.

llvm/tools/llvm-profgen/PerfReader.h

62–67

I see, thanks for the clarification.

651

comments updated

[wenlei]

lgtm, thanks.

llvm/tools/llvm-profgen/PerfReader.cpp

784

so getHashCode should be a virtual function which has overhead because StrKey and ProbeKey have different genHashCode.

So to avoid this

Why do we want to avoid this? performance reason? It looks to me that having getHashCode as virtual function is natural and clean.

This pattern perhaps is not related to this patch though.

llvm/tools/llvm-profgen/PerfReader.h

664

nit: this does not align with [context stack1]

[hoy]

llvm/tools/llvm-profgen/PerfReader.cpp

789

Add a test for this?

llvm/tools/llvm-profgen/PerfReader.h

669

What is the main reason of making this type hierarchy? It looks like UnsymbolizedProfileReader doesn't need most of the interfaces PerfReaderBase provides. Conceptually it sounds to me that the two classes function independently, and if we'd like code sharing, UnsymbolizedProfileReader can be made the base class of PerfReaderBase or make a new base class that simply reads in something and outputs an symbolized profile?

[wenlei]

llvm/tools/llvm-profgen/PerfReader.h

669

UnsymbolizedProfileReader can be made the base class of PerfReaderBase

I don't think this is a good idea. Conceptually, PerfReader is not a special kind of UnsymbolizedProfileReader.

[hoy]

llvm/tools/llvm-profgen/PerfReader.h

669

Right, they are independent of each other. PerfReader really deals with perf input. They only share in the raw output writting. A new base class makes more sense?

[wlei]

llvm/tools/llvm-profgen/PerfReader.cpp

784

Yeah, my initial intention is performance reason. I can try it in a separate patch.

789

We have the test, see noinline-cs-noprobe.test.

llvm/tools/llvm-profgen/PerfReader.h

664

updated comments

669

It seems to me the hierarchy should be like

PerfReaderBase.  --->   PerfScriptReader.   ---> LBRPerfReader
                                            ---> HybridPerfReader

                 --->   UnsymbolizedProfileReader

This will make the hierarchy deep though.

[hoy]

llvm/tools/llvm-profgen/PerfReader.h

669

That's the current hierarchy, IIUC? I was wondering if UnsymbolizedProfileReader should inherit from a base class that's not PerfReaderBase. If you look at the implementation of PerfReaderBase, there isn't much UnsymbolizedProfileReader shares. The writing of unsymbolized profile is probably not needed for UnsymbolizedProfileReader.

[wlei]

llvm/tools/llvm-profgen/PerfReader.h

669

Yeah, It's mostly similar to your suggestion. I meant just rename current PerfReaderBase to PerfScriptReader. then we can use PerfReaderBase as the new base.

[wlei]

Refactor the code: separate the perfscript reader logic out of perfreaderbase
and create a new class PerfScriptReader and let LBRPerfReader and HybridPerfreader inherit from it.

[wenlei]

llvm/tools/llvm-profgen/PerfReader.cpp

784

Yes, a separate patch is fine. But I feel we might be over optimizing here unless the perf delta is visible.

llvm/tools/llvm-profgen/PerfReader.h

669

The hierarchy in the latest version looks good to me.

However, I'm wondering if we could move LBRPerfReader::generateRawProfile into PerfScriptReader? That way we could have HybridPerfReader and LBRPerfReader both inherit from PerfScriptReader directly. The LBRPerfReader-> HybridPerfReader hierarchy seems a bit weird, but I understand it was for reusing LBRPerfReader::generateRawProfile. Don't bother if this can cause bigger change.

[hoy]

llvm/tools/llvm-profgen/PerfReader.h

669

I now see what you mean. The renaming sounds good. It separates UnsymbolizedProfileReader which doesn't do anything with perf (perf data or perf script) from the old hierarchy. Perhaps rename the new PerfReaderBase to ProfileReaderBase?

[wlei]

llvm/tools/llvm-profgen/PerfReader.h

669

However, I'm wondering if we could move LBRPerfReader::generateRawProfile into PerfScriptReader?

Sounds good, not a big change.

Perhaps rename the new PerfReaderBase to ProfileReaderBase?

Just want to confirm this, do you mean also change the file name? currently the file is PerfReader.cpp/h. It seems the base class is used to read perf.data, perf script, unsymbolized profile, it has both perf and profile term, I don't have any preference though.

[hoy]

llvm/tools/llvm-profgen/PerfReader.h

669

I see. I’m fine with the PerfReaderBase class name and PerfReader file names to minimize the changes. Perf is the main scenario we support.

[wlei]

move LBRPerfReader::generateUnsymbolizedProfile into PerfScriptReader

[hoy]

lgtm, thanks!

llvm/include/llvm/ProfileData/SampleProf.h

SampleContext(StringRef ContextStr,
     assert(!ContextStr.empty());
     // Note that `[]` wrapped input indicates a full context string, otherwise
     // it's treated as context-less function name only.
     bool HasContext = ContextStr.startswith("[");
     if (!HasContext) {
       State = UnknownContext;
       Name = ContextStr;
     } else {
-      // Remove encapsulating '[' and ']' if any
-      ContextStr = ContextStr.substr(1, ContextStr.size() - 2);
       CSNameTable.emplace_back();
       SampleContextFrameVector &Context = CSNameTable.back();
-      /// Create a context vector from a given context string and save it in
-      /// `Context`.
-      StringRef ContextRemain = ContextStr;
-      StringRef ChildContext;
-      StringRef CalleeName;
-      while (!ContextRemain.empty()) {
-        auto ContextSplit = ContextRemain.split(" @ ");
-        ChildContext = ContextSplit.first;
-        ContextRemain = ContextSplit.second;
-        LineLocation CallSiteLoc(0, 0);
-        decodeContextString(ChildContext, CalleeName, CallSiteLoc);
-        Context.emplace_back(CalleeName, CallSiteLoc);
-      }
-
-      setContext(Context, CState);
-    }
+      createCtxVectorFromStr(ContextStr, Context);
+      setContext(Context, CState);
+    }
+  }
+
+  static void createCtxVectorFromStr(StringRef ContextStr,
+                                     SampleContextFrameVector &Context) {
+    // Remove encapsulating '[' and ']' if any
+    ContextStr = ContextStr.substr(1, ContextStr.size() - 2);
   }
 
   // Promote context by removing top frames with the length of
   // `ContextFramesToRemove`. Note that with array representation of context,
   // the promotion is effectively a slice operation with first
   // `ContextFramesToRemove` elements removed from left.
   void promoteOnPath(uint32_t ContextFramesToRemove) {
     assert(ContextFramesToRemove <= FullContext.size() &&

llvm/test/tools/llvm-profgen/inline-noprobe.test

 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/inline-noprobe.perfscript --binary=%S/Inputs/inline-noprobe.perfbin --output=%t --skip-symbolization
 ; RUN: FileCheck %s --input-file %t --check-prefix=CHECK-RAW-PROFILE
 ; RUN: llvm-profgen --format=text --use-dwarf-correlation --perfscript=%S/Inputs/inline-noprobe.perfscript --binary=%S/Inputs/inline-noprobe.perfbin --output=%t --skip-symbolization
 ; RUN: FileCheck %s --input-file %t --check-prefix=CHECK-RAW-PROFILE
-; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/inline-noprobe.perfscript --binary=%S/Inputs/inline-noprobe.perfbin --output=%t
-; RUN: FileCheck %s --input-file %t --check-prefix=CHECK
+; RUN: llvm-profgen --format=text --unsymbolized-profile=%t --binary=%S/Inputs/inline-noprobe.perfbin --output=%t1
+; RUN: FileCheck %s --input-file %t1 --check-prefix=CHECK
 ; RUN: llvm-profgen --format=text --use-dwarf-correlation --perfscript=%S/Inputs/inline-noprobe.perfscript --binary=%S/Inputs/inline-noprobe.perfbin --output=%t
 ; RUN: FileCheck %s --input-file %t --check-prefix=CHECK
 
 CHECK: main:669:0
 CHECK:  0: 0
 CHECK:  2: 0
 CHECK:  1: foo:669
 CHECK:   2.1: 42

llvm/test/tools/llvm-profgen/inline-noprobe2.test

 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/artificial-branch.perfscript --binary=%S/Inputs/inline-noprobe2.perfbin --output=%t  --skip-symbolization --use-offset=0
 ; RUN: FileCheck %s --input-file %t --check-prefix=CHECK-ARTIFICIAL-BRANCH
 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/inline-noprobe2.perfscript --binary=%S/Inputs/inline-noprobe2.perfbin --output=%t  --skip-symbolization --use-offset=0
 ; RUN: FileCheck %s --input-file %t --check-prefix=CHECK-RAW-PROFILE
-; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/inline-noprobe2.perfscript --binary=%S/Inputs/inline-noprobe2.perfbin --output=%t
-; RUN: FileCheck %s --input-file %t --check-prefix=CHECK
+; RUN: llvm-profgen --format=text --unsymbolized-profile=%t --binary=%S/Inputs/inline-noprobe2.perfbin --output=%t1 --use-offset=0
+; RUN: FileCheck %s --input-file %t1 --check-prefix=CHECK
 
 ; RUN: llvm-profgen --format=extbinary --perfscript=%S/Inputs/inline-noprobe2.perfscript --binary=%S/Inputs/inline-noprobe2.perfbin --output=%t
 ; RUN: llvm-profdata show -show-prof-sym-list -sample %t | FileCheck %s --check-prefix=CHECK-SYM-LIST
 
 ; CHECK-ARTIFICIAL-BRANCH: 3
 ; CHECK-ARTIFICIAL-BRANCH: 400540-400540:1
 ; CHECK-ARTIFICIAL-BRANCH: 400870-400870:2
 ; CHECK-ARTIFICIAL-BRANCH: 400875-4008bf:1

llvm/test/tools/llvm-profgen/noinline-cs-noprobe.test

 ;; The test fails on Windows. Fix it before removing the following requirement.
 ; REQUIRES: x86_64-linux
 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/noinline-cs-noprobe.perfscript --binary=%S/Inputs/noinline-cs-noprobe.perfbin --output=%t --skip-symbolization --profile-summary-cold-count=0
 ; RUN: FileCheck %s --input-file %t --check-prefix=CHECK-UNWINDER
-; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/noinline-cs-noprobe.perfscript --binary=%S/Inputs/noinline-cs-noprobe.perfbin --output=%t --profile-summary-cold-count=0
-; RUN: FileCheck %s --input-file %t
+; RUN: llvm-profgen --format=text --unsymbolized-profile=%t --binary=%S/Inputs/noinline-cs-noprobe.perfbin --output=%t1 --profile-summary-cold-count=0
+; RUN: FileCheck %s --input-file %t1
 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/noinline-cs-noprobe.perfscript --binary=%S/Inputs/noinline-cs-noprobe.perfbin --output=%t --profile-summary-cold-count=0 --ignore-stack-samples
 ; RUN: FileCheck %s --input-file %t --check-prefix=CHECK-STRIP-CTX
 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/noinline-cs-noprobe.aggperfscript --binary=%S/Inputs/noinline-cs-noprobe.perfbin --output=%t --skip-symbolization --profile-summary-cold-count=0
 ; RUN: FileCheck %s --input-file %t --check-prefix=CHECK-AGG-UNWINDER
 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/noinline-cs-noprobe.aggperfscript --binary=%S/Inputs/noinline-cs-noprobe.perfbin --output=%t --profile-summary-cold-count=0
 ; RUN: FileCheck %s --input-file %t --check-prefix=CHECK-AGG
 
 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/noinline-cs-noprobe.perfscript --binary=%S/Inputs/noinline-cs-noprobe.perfbin --output=%t1 --profile-summary-cold-count=0

llvm/tools/llvm-profgen/PerfReader.h

void advance() {
     if (!std::getline(Fin, CurrentLine)) {
       IsAtEoF = true;
       return;
     }
     LineNumber++;
   }
 };
 
-// The type of perfscript
-enum PerfScriptType {
-  PERF_UNKNOWN = 0,
-  PERF_INVALID = 1,
-  PERF_LBR = 2,       // Only LBR sample
-  PERF_LBR_STACK = 3, // Hybrid sample including call stack and LBR stack.
+// The type of input format.
+enum PerfFormat {
+  UnknownFormat = 0,
+  PerfData = 1,            // Raw linux perf.data.
+  PerfScript = 2,          // Perf script create by `perf script` command.
+  UnsymbolizedProfile = 3, // Unsymbolized profile generated by llvm-profgen.
+
+};
+
+// The type of perfscript content.
+enum PerfContent {
+  UnknownContent = 0,
+  LBR = 1,      // Only LBR sample.
+  LBRStack = 2, // Hybrid sample including call stack and LBR stack.
+};
+
+struct PerfInputFile {
+  std::string InputFile;
+  PerfFormat Format = PerfFormat::UnknownFormat;
+  PerfContent Content = PerfContent::UnknownContent;
 };
 
 // The parsed LBR sample entry.
 struct LBREntry {
   uint64_t Source = 0;
   uint64_t Target = 0;
   // An artificial branch stands for a series of consecutive branches starting
   // from the current binary with a transition through external code and
private:
   ProfiledBinary *Binary;
   // Keep track of all untracked callsites
   std::set<uint64_t> UntrackedCallsites;
 };
 
 // Read perf trace to parse the events and samples.
 class PerfReaderBase {
 public:
-  PerfReaderBase(ProfiledBinary *B, StringRef PerfTrace,
-                 PerfScriptType Type = PERF_UNKNOWN)
-      : Binary(B), PerfTraceFile(PerfTrace), PerfType(Type) {
+  PerfReaderBase(ProfiledBinary *B, StringRef PerfTrace)
+      : Binary(B), PerfTraceFile(PerfTrace) {
     // Initialize the base address to preferred address.
     Binary->setBaseAddress(Binary->getPreferredBaseAddress());
   };
   virtual ~PerfReaderBase() = default;
-  static std::unique_ptr<PerfReaderBase>
-  create(ProfiledBinary *Binary, StringRef PerfInputFile, bool IsPerfData);
+  static std::unique_ptr<PerfReaderBase> create(ProfiledBinary *Binary,
+                                                PerfInputFile &PerfInput);
 
-  PerfScriptType getPerfScriptType() const { return PerfType; }
   // Entry of the reader to parse multiple perf traces
-  void parsePerfTraces();
+  virtual void parsePerfTraces() = 0;
   const ContextSampleCounterMap &getSampleCounters() const {
     return SampleCounters;
   }
   bool profileIsCS() { return ProfileIsCS; }
 
 protected:
+  ProfiledBinary *Binary = nullptr;
+  StringRef PerfTraceFile;
+
+  ContextSampleCounterMap SampleCounters;
+  bool ProfileIsCS = false;
+};
+
+// Read perf script to parse the events and samples.
+class PerfScriptReader : public PerfReaderBase {
+public:
+  PerfScriptReader(ProfiledBinary *B, StringRef PerfTrace)
+      : PerfReaderBase(B, PerfTrace){};
+
+  // Entry of the reader to parse multiple perf traces
+  virtual void parsePerfTraces() override;
+  // Generate perf script from perf data
+  static PerfInputFile convertPerfDataToTrace(ProfiledBinary *Binary,
+                                              PerfInputFile &File);
+  // Extract perf script type by peaking at the input
+  static PerfContent checkPerfScriptType(StringRef FileName);
+
+protected:
   // The parsed MMap event
   struct MMapEvent {
     uint64_t PID = 0;
     uint64_t Address = 0;
     uint64_t Size = 0;
     uint64_t Offset = 0;
     StringRef BinaryPath;
   };
-  // Generate perf script from perf data
-  static std::string convertPerfDataToTrace(ProfiledBinary *Binary,
-                                            StringRef PerfData);
+
   // Check whether a given line is LBR sample
   static bool isLBRSample(StringRef Line);
   // Check whether a given line is MMAP event
   static bool isMMap2Event(StringRef Line);
-  // Extract perf script type by peaking at the input
-  static PerfScriptType checkPerfScriptType(StringRef FileName);
   // Parse a single line of a PERF_RECORD_MMAP2 event looking for a
   // mapping between the binary name and its memory layout.
   static bool extractMMap2EventForBinary(ProfiledBinary *Binary, StringRef Line,
                                          MMapEvent &MMap);
   // Update base address based on mmap events
   void updateBinaryAddress(const MMapEvent &Event);
   // Parse mmap event and update binary address
   void parseMMap2Event(TraceStream &TraceIt);
protected:
   bool extractLBRStack(TraceStream &TraceIt,
                        SmallVectorImpl<LBREntry> &LBRStack);
   uint64_t parseAggregatedCount(TraceStream &TraceIt);
   // Parse one sample from multiple perf lines, override this for different
   // sample type
   void parseSample(TraceStream &TraceIt);
   // An aggregated count is given to indicate how many times the sample is
   // repeated.
-  virtual void parseSample(TraceStream &TraceIt, uint64_t Count) = 0;
+  virtual void parseSample(TraceStream &TraceIt, uint64_t Count){};
+  void computeCounterFromLBR(const PerfSample *Sample, uint64_t Repeat);
   // Post process the profile after trace aggregation, we will do simple range
   // overlap computation for AutoFDO, or unwind for CSSPGO(hybrid sample).
-  virtual void generateRawProfile() = 0;
-  void writeRawProfile(StringRef Filename);
-  void writeRawProfile(raw_fd_ostream &OS);
+  virtual void generateUnsymbolizedProfile();
+  void writeUnsymbolizedProfile(StringRef Filename);
+  void writeUnsymbolizedProfile(raw_fd_ostream &OS);
 
-  ProfiledBinary *Binary = nullptr;
-  StringRef PerfTraceFile;
-  ContextSampleCounterMap SampleCounters;
   // Samples with the repeating time generated by the perf reader
   AggregatedCounter AggregatedSamples;
-  PerfScriptType PerfType = PERF_UNKNOWN;
   // Keep track of all invalid return addresses
   std::set<uint64_t> InvalidReturnAddresses;
-
-  bool ProfileIsCS = false;
 };
 
 /*
   The reader of LBR only perf script.
   A typical LBR sample is like:
     40062f 0x4005c8/0x4005dc/P/-/-/0   0x40062f/0x4005b0/P/-/-/0 ...
           ... 0x4005c8/0x4005dc/P/-/-/0
 */
-class LBRPerfReader : public PerfReaderBase {
+class LBRPerfReader : public PerfScriptReader {
 public:
-  LBRPerfReader(ProfiledBinary *Binary, StringRef PerfTrace,
-                PerfScriptType Type = PERF_LBR)
-      : PerfReaderBase(Binary, PerfTrace, Type){};
+  LBRPerfReader(ProfiledBinary *Binary, StringRef PerfTrace)
+      : PerfScriptReader(Binary, PerfTrace){};
   // Parse the LBR only sample.
   virtual void parseSample(TraceStream &TraceIt, uint64_t Count) override;
-  virtual void generateRawProfile() override;
-
-private:
-  void computeCounterFromLBR(const PerfSample *Sample, uint64_t Repeat);
 };
 
 /*
   Hybrid perf script includes a group of hybrid samples(LBRs + call stack),
   which is used to generate CS profile. An example of hybrid sample:
     4005dc    # call stack leaf
     400634
     400684    # call stack root
     0x4005c8/0x4005dc/P/-/-/0   0x40062f/0x4005b0/P/-/-/0 ...
           ... 0x4005c8/0x4005dc/P/-/-/0    # LBR Entries
 */
-class HybridPerfReader : public LBRPerfReader {
+class HybridPerfReader : public PerfScriptReader {
 public:
   HybridPerfReader(ProfiledBinary *Binary, StringRef PerfTrace)
-      : LBRPerfReader(Binary, PerfTrace, PERF_LBR_STACK){};
+      : PerfScriptReader(Binary, PerfTrace){};
   // Parse the hybrid sample including the call and LBR line
   void parseSample(TraceStream &TraceIt, uint64_t Count) override;
-  void generateRawProfile() override;
+  void generateUnsymbolizedProfile() override;
 
 private:
   // Unwind the hybrid samples after aggregration
   void unwindSamples();
 };
 
+/*
+   Format of unsymbolized profile:
+
+    [frame1 @ frame2 @ ...]  # If it's a CS profile
+      number of entries in RangeCounter
+      from_1-to_1:count_1
+      from_2-to_2:count_2
+      ......
+      from_n-to_n:count_n
+      number of entries in BranchCounter
+      src_1->dst_1:count_1
+      src_2->dst_2:count_2
+      ......
+      src_n->dst_n:count_n
+    [frame1 @ frame2 @ ...]  # Next context
+      ......
+
+Note that non-CS profile doesn't have the empty `[]` context.
+*/
+class UnsymbolizedProfileReader : public PerfReaderBase {
+public:
+  UnsymbolizedProfileReader(ProfiledBinary *Binary, StringRef PerfTrace)
+      : PerfReaderBase(Binary, PerfTrace){};
+  void parsePerfTraces() override;
+
+private:
+  void readSampleCounters(TraceStream &TraceIt, SampleCounter &SCounters);
+  void readUnsymbolizedProfile(StringRef Filename);
+
+  std::unordered_set<std::string> ContextStrSet;
+};
+
 } // end namespace sampleprof
 } // end namespace llvm
 
 #endif

llvm/tools/llvm-profgen/PerfReader.cpp

cl::opt<bool> SkipSymbolization("skip-symbolization", cl::init(false),
                                          "output for CS profile generation."));
 
 static cl::opt<bool> ShowMmapEvents("show-mmap-events", cl::init(false),
                                     cl::ZeroOrMore,
                                     cl::desc("Print binary load events."));
 
 static cl::opt<bool>
     UseOffset("use-offset", cl::init(true), cl::ZeroOrMore,
-              cl::desc("Work with `--skip-symbolization` to dump the "
+              cl::desc("Work with `--skip-symbolization` or "
+                       "`--unsymbolized-profile` to write/read the "
                        "offset instead of virtual address."));
 static cl::opt<bool>
     IgnoreStackSamples("ignore-stack-samples", cl::init(false), cl::ZeroOrMore,
                        cl::desc("Ignore call stack samples for hybrid samples "
                                 "and produce context-insensitive profile."));
 
 extern cl::opt<std::string> PerfTraceFilename;
 extern cl::opt<bool> ShowDisassemblyOnly;
while (State.hasNextLBR()) {
     recordBranchCount(Branch, State, Repeat);
   }
   // As samples are aggregated on trie, record them into counter map
   collectSamplesFromFrameTrie(State.getDummyRootPtr());
 
   return true;
 }
 
-std::unique_ptr<PerfReaderBase> PerfReaderBase::create(ProfiledBinary *Binary,
-                                                       StringRef PerfInputFile,
-                                                       bool IsPerfData) {
-  // For perf data input, we need to convert them into perf script first.
-  if (IsPerfData) {
-    std::string ConvertedPerfScript =
-        convertPerfDataToTrace(Binary, PerfInputFile);
-    // Let commoand opt own the string for converted perf trace file name
-    PerfTraceFilename = ConvertedPerfScript;
-    PerfInputFile = PerfTraceFilename;
+std::unique_ptr<PerfReaderBase>
+PerfReaderBase::create(ProfiledBinary *Binary, PerfInputFile &PerfInput) {
+  std::unique_ptr<PerfReaderBase> PerfReader;
+
+  if (PerfInput.Format == PerfFormat::UnsymbolizedProfile) {
+    PerfReader.reset(
+        new UnsymbolizedProfileReader(Binary, PerfInput.InputFile));
+    return PerfReader;
   }
 
-  PerfScriptType PerfType = checkPerfScriptType(PerfInputFile);
-  std::unique_ptr<PerfReaderBase> PerfReader;
-  if (PerfType == PERF_LBR_STACK) {
-    PerfReader.reset(new HybridPerfReader(Binary, PerfInputFile));
-  } else if (PerfType == PERF_LBR) {
-    PerfReader.reset(new LBRPerfReader(Binary, PerfInputFile));
+  // For perf data input, we need to convert them into perf script first.
+  if (PerfInput.Format == PerfFormat::PerfData)
+    PerfInput = PerfScriptReader::convertPerfDataToTrace(Binary, PerfInput);
+
+  assert((PerfInput.Format == PerfFormat::PerfScript) &&
+         "Should be a perfscript!");
+
+  PerfInput.Content =
+      PerfScriptReader::checkPerfScriptType(PerfInput.InputFile);
+  if (PerfInput.Content == PerfContent::LBRStack) {
+    PerfReader.reset(new HybridPerfReader(Binary, PerfInput.InputFile));
+  } else if (PerfInput.Content == PerfContent::LBR) {
+    PerfReader.reset(new LBRPerfReader(Binary, PerfInput.InputFile));
   } else {
     exitWithError("Unsupported perfscript!");
   }
 
   return PerfReader;
 }
 
-std::string PerfReaderBase::convertPerfDataToTrace(ProfiledBinary *Binary,
-                                                   StringRef PerfData) {
+PerfInputFile PerfScriptReader::convertPerfDataToTrace(ProfiledBinary *Binary,
+                                                       PerfInputFile &File) {
+  StringRef PerfData = File.InputFile;
   // Run perf script to retrieve PIDs matching binary we're interested in.
   auto PerfExecutable = sys::Process::FindInEnvPath("PATH", "perf");
   if (!PerfExecutable) {
     exitWithError("Perf not found.");
   }
   std::string PerfPath = *PerfExecutable;
   std::string PerfTraceFile = PerfData.str() + ".script.tmp";
   StringRef ScriptMMapArgs[] = {PerfPath, "script",   "--show-mmap-events",
PerfInputFile PerfScriptReader::convertPerfDataToTrace(ProfiledBinary *Binary,
   }
 
   // Run perf script again to retrieve events for PIDs collected above
   StringRef ScriptSampleArgs[] = {PerfPath, "script",     "--show-mmap-events",
                                   "-F",     "ip,brstack", "--pid",
                                   PIDs,     "-i",         PerfData};
   sys::ExecuteAndWait(PerfPath, ScriptSampleArgs, llvm::None, Redirects);
 
-  return PerfTraceFile;
+  return {PerfTraceFile, PerfFormat::PerfScript, PerfContent::UnknownContent};
 }
 
-void PerfReaderBase::updateBinaryAddress(const MMapEvent &Event) {
+void PerfScriptReader::updateBinaryAddress(const MMapEvent &Event) {
   // Drop the event which doesn't belong to user-provided binary
   StringRef BinaryName = llvm::sys::path::filename(Event.BinaryPath);
   if (Binary->getName() != BinaryName)
     return;
 
   // Drop the event if its image is loaded at the same address
   if (Event.Address == Binary->getBaseAddress()) {
     Binary->setIsLoadedByMMap(true);
void HybridPerfReader::unwindSamples() {
 
   // Warn about untracked frames due to missing probes.
   for (auto Address : AllUntrackedCallsites)
     WithColor::warning() << "Profile context truncated due to missing probe "
                          << "for call instruction at "
                          << format("0x%" PRIx64, Address) << "\n";
 }
 
-bool PerfReaderBase::extractLBRStack(TraceStream &TraceIt,
+bool PerfScriptReader::extractLBRStack(TraceStream &TraceIt,
                                        SmallVectorImpl<LBREntry> &LBRStack) {
   // The raw format of LBR stack is like:
   // 0x4005c8/0x4005dc/P/-/-/0 0x40062f/0x4005b0/P/-/-/0 ...
   //                           ... 0x4005c8/0x4005dc/P/-/-/0
   // It's in FIFO order and seperated by whitespace.
   SmallVector<StringRef, 32> Records;
   TraceIt.getCurrentLine().split(Records, " ", -1, false);
   auto WarnInvalidLBR = [](TraceStream &TraceIt) {
     WithColor::warning() << "Invalid address in LBR record at line "
while (Index < Records.size()) {
     // TODO: filter out buggy duplicate branches on Skylake
 
     LBRStack.emplace_back(LBREntry(Src, Dst, IsArtificial));
   }
   TraceIt.advance();
   return !LBRStack.empty();
 }
 
-bool PerfReaderBase::extractCallstack(TraceStream &TraceIt,
+bool PerfScriptReader::extractCallstack(TraceStream &TraceIt,
                                         SmallVectorImpl<uint64_t> &CallStack) {
   // The raw format of call stack is like:
   //            4005dc      # leaf frame
   //            400634
   //            400684      # root frame
   // It's in bottom-up order with each frame in one line.
 
   // Extract stack frames from sample
   while (!TraceIt.isAtEoF() && !TraceIt.getCurrentLine().startswith(" 0x")) {
bool PerfScriptReader::extractCallstack(TraceStream &TraceIt,
   // out to reduce the number of different calling contexts. One instance
   // of such case - when sample landed in prolog/epilog, somehow stack
   // walking will be broken in an unexpected way that higher frames will be
   // missing.
   return !CallStack.empty() &&
          !Binary->addressInPrologEpilog(CallStack.front());
 }
 
-void PerfReaderBase::warnIfMissingMMap() {
+void PerfScriptReader::warnIfMissingMMap() {
   if (!Binary->getMissingMMapWarned() && !Binary->getIsLoadedByMMap()) {
     WithColor::warning() << "No relevant mmap event is matched for "
                          << Binary->getName()
                          << ", will use preferred address ("
                          << format("0x%" PRIx64,
                                    Binary->getPreferredBaseAddress())
                          << ") as the base loading address!\n";
     // Avoid redundant warning, only warn at the first unmatched sample.
if (extractLBRStack(TraceIt, Sample->LBRStack)) {
       AggregatedSamples[Hashable<PerfSample>(Sample)] += Count;
     }
   } else {
     // LBR sample is encoded in single line after stack sample
     exitWithError("'Hybrid perf sample is corrupted, No LBR sample line");
   }
 }
 
-void PerfReaderBase::writeRawProfile(StringRef Filename) {
+void PerfScriptReader::writeUnsymbolizedProfile(StringRef Filename) {
   std::error_code EC;
   raw_fd_ostream OS(Filename, EC, llvm::sys::fs::OF_TextWithCRLF);
   if (EC)
     exitWithError(EC, Filename);
-  writeRawProfile(OS);
+  writeUnsymbolizedProfile(OS);
 }
 
 // Use ordered map to make the output deterministic
 using OrderedCounterForPrint = std::map<std::string, SampleCounter *>;
 
-void PerfReaderBase::writeRawProfile(raw_fd_ostream &OS) {
-  /*
-     Format:
-     [context string]
-     number of entries in RangeCounter
-     from_1-to_1:count_1
-     from_2-to_2:count_2
-     ......
-     from_n-to_n:count_n
-     number of entries in BranchCounter
-     src_1->dst_1:count_1
-     src_2->dst_2:count_2
-     ......
-     src_n->dst_n:count_n
-  */
-
+void PerfScriptReader::writeUnsymbolizedProfile(raw_fd_ostream &OS) {
   OrderedCounterForPrint OrderedCounters;
   for (auto &CI : SampleCounters) {
     OrderedCounters[getContextKeyStr(CI.first.getPtr(), Binary)] = &CI.second;
   }
 
-  auto SCounterPrinter = [&](RangeSample Counter, StringRef Separator,
+  auto SCounterPrinter = [&](RangeSample &Counter, StringRef Separator,
                              uint32_t Indent) {
     OS.indent(Indent);
     OS << Counter.size() << "\n";
-    for (auto I : Counter) {
+    for (auto &I : Counter) {
       uint64_t Start = UseOffset ? I.first.first
                                  : Binary->offsetToVirtualAddr(I.first.first);
       uint64_t End = UseOffset ? I.first.second
                                : Binary->offsetToVirtualAddr(I.first.second);
       OS.indent(Indent);
       OS << Twine::utohexstr(Start) << Separator << Twine::utohexstr(End) << ":"
          << I.second << "\n";
     }
   };
 
   for (auto &CI : OrderedCounters) {
     uint32_t Indent = 0;
-    if (!CI.first.empty()) {
+    if (ProfileIsCS) {
       // Context string key
       OS << "[" << CI.first << "]\n";
       Indent = 2;
     }
 
     SampleCounter &Counter = *CI.second;
     SCounterPrinter(Counter.RangeCounter, "-", Indent);
     SCounterPrinter(Counter.BranchCounter, "->", Indent);
   }
 }
 
-void LBRPerfReader::computeCounterFromLBR(const PerfSample *Sample,
+// Format of input:
+// number of entries in RangeCounter
+// from_1-to_1:count_1
+// from_2-to_2:count_2
+// ......
+// from_n-to_n:count_n
+// number of entries in BranchCounter
+// src_1->dst_1:count_1
+// src_2->dst_2:count_2
+// ......
+// src_n->dst_n:count_n
+void UnsymbolizedProfileReader::readSampleCounters(TraceStream &TraceIt,
+                                                   SampleCounter &SCounters) {
+  auto exitWithErrorForTraceLine = [](TraceStream &TraceIt) {
+    std::string Msg = TraceIt.isAtEoF()
+                          ? "Invalid raw profile!"
+                          : "Invalid raw profile at line " +
+                                Twine(TraceIt.getLineNumber()).str() + ": " +
+                                TraceIt.getCurrentLine().str();
+    exitWithError(Msg);
+  };
+  auto ReadNumber = [&](uint64_t &Num) {
+    if (TraceIt.isAtEoF())
+      exitWithErrorForTraceLine(TraceIt);
+    if (TraceIt.getCurrentLine().ltrim().getAsInteger(10, Num))
+      exitWithErrorForTraceLine(TraceIt);
+    TraceIt.advance();
+  };
+
+  auto ReadCounter = [&](RangeSample &Counter, StringRef Separator) {
+    uint64_t Num = 0;
+    ReadNumber(Num);
+    while (Num--) {
+      if (TraceIt.isAtEoF())
+        exitWithErrorForTraceLine(TraceIt);
+      StringRef Line = TraceIt.getCurrentLine().ltrim();
+
+      uint64_t Count = 0;
+      auto LineSplit = Line.split(":");
+      if (LineSplit.second.empty() || LineSplit.second.getAsInteger(10, Count))
+        exitWithErrorForTraceLine(TraceIt);
+
+      uint64_t Source = 0;
+      uint64_t Target = 0;
+      auto Range = LineSplit.first.split(Separator);
+      if (Range.second.empty() || Range.first.getAsInteger(16, Source) ||
+          Range.second.getAsInteger(16, Target))
+        exitWithErrorForTraceLine(TraceIt);
+
+      if (!UseOffset) {
+        Source = Binary->virtualAddrToOffset(Source);
+        Target = Binary->virtualAddrToOffset(Target);
+      }
+
+      Counter[{Source, Target}] += Count;
+      TraceIt.advance();
+    }
+  };
+
+  ReadCounter(SCounters.RangeCounter, "-");
+  ReadCounter(SCounters.BranchCounter, "->");
+}
+
+void UnsymbolizedProfileReader::readUnsymbolizedProfile(StringRef FileName) {
+  TraceStream TraceIt(FileName);
+  while (!TraceIt.isAtEoF()) {
+    std::shared_ptr<StringBasedCtxKey> Key =
+        std::make_shared<StringBasedCtxKey>();
+    StringRef Line = TraceIt.getCurrentLine();
+    // Read context stack for CS profile.
+    if (Line.startswith("[")) {
+      ProfileIsCS = true;
+      auto I = ContextStrSet.insert(Line.str());
+      SampleContext::createCtxVectorFromStr(*I.first, Key->Context);
+      TraceIt.advance();
+    }
+    Key->genHashCode();
+    auto Ret =
+        SampleCounters.emplace(Hashable<ContextKey>(Key), SampleCounter());
+    readSampleCounters(TraceIt, Ret.first->second);
+  }
+}
+
+void UnsymbolizedProfileReader::parsePerfTraces() {
+  readUnsymbolizedProfile(PerfTraceFile);
+}
+
+void PerfScriptReader::computeCounterFromLBR(const PerfSample *Sample,
                                              uint64_t Repeat) {
   SampleCounter &Counter = SampleCounters.begin()->second;
   uint64_t EndOffeset = 0;
   for (const LBREntry &LBR : Sample->LBRStack) {
     uint64_t SourceOffset = Binary->virtualAddrToOffset(LBR.Source);
     uint64_t TargetOffset = Binary->virtualAddrToOffset(LBR.Target);
 
     if (!LBR.IsArtificial) {
       Counter.recordBranchCount(SourceOffset, TargetOffset, Repeat);
void LBRPerfReader::parseSample(TraceStream &TraceIt, uint64_t Count) {
   // Parsing LBR stack and populate into PerfSample.LBRStack
   if (extractLBRStack(TraceIt, Sample->LBRStack)) {
     warnIfMissingMMap();
     // Record LBR only samples by aggregation
     AggregatedSamples[Hashable<PerfSample>(Sample)] += Count;
   }
 }
 
-void LBRPerfReader::generateRawProfile() {
+void PerfScriptReader::generateUnsymbolizedProfile() {
   // There is no context for LBR only sample, so initialize one entry with
   // fake "empty" context key.
   assert(SampleCounters.empty() &&
          "Sample counter map should be empty before raw profile generation");
   std::shared_ptr<StringBasedCtxKey> Key =
       std::make_shared<StringBasedCtxKey>();
   Key->genHashCode();
   SampleCounters.emplace(Hashable<ContextKey>(Key), SampleCounter());
   for (const auto &Item : AggregatedSamples) {
     const PerfSample *Sample = Item.first.getPtr();
     computeCounterFromLBR(Sample, Item.second);
   }
 }
 
-uint64_t PerfReaderBase::parseAggregatedCount(TraceStream &TraceIt) {
+uint64_t PerfScriptReader::parseAggregatedCount(TraceStream &TraceIt) {
   // The aggregated count is optional, so do not skip the line and return 1 if
   // it's unmatched
   uint64_t Count = 1;
   if (!TraceIt.getCurrentLine().getAsInteger(10, Count))
     TraceIt.advance();
   return Count;
 }
 
-void PerfReaderBase::parseSample(TraceStream &TraceIt) {
+void PerfScriptReader::parseSample(TraceStream &TraceIt) {
   uint64_t Count = parseAggregatedCount(TraceIt);
   assert(Count >= 1 && "Aggregated count should be >= 1!");
   parseSample(TraceIt, Count);
 }
 
-bool PerfReaderBase::extractMMap2EventForBinary(ProfiledBinary *Binary,
+bool PerfScriptReader::extractMMap2EventForBinary(ProfiledBinary *Binary,
                                                   StringRef Line,
                                                   MMapEvent &MMap) {
   // Parse a line like:
   //  PERF_RECORD_MMAP2 2113428/2113428: [0x7fd4efb57000(0x204000) @ 0
   //  08:04 19532229 3585508847]: r-xp /usr/lib64/libdl-2.17.so
   constexpr static const char *const Pattern =
       "PERF_RECORD_MMAP2 ([0-9]+)/[0-9]+: "
       "\\[(0x[a-f0-9]+)\\((0x[a-f0-9]+)\\) @ "
       "(0x[a-f0-9]+|0) .*\\]: [-a-z]+ (.*)";
   // Field 0 - whole line
if (ShowMmapEvents) {
     outs() << "Mmap: Binary " << MMap.BinaryPath << " loaded at "
            << format("0x%" PRIx64 ":", MMap.Address) << " \n";
   }
 
   StringRef BinaryName = llvm::sys::path::filename(MMap.BinaryPath);
   return Binary->getName() == BinaryName;
 }
 
-void PerfReaderBase::parseMMap2Event(TraceStream &TraceIt) {
+void PerfScriptReader::parseMMap2Event(TraceStream &TraceIt) {
   MMapEvent MMap;
   if (extractMMap2EventForBinary(Binary, TraceIt.getCurrentLine(), MMap))
     updateBinaryAddress(MMap);
   TraceIt.advance();
 }
 
-void PerfReaderBase::parseEventOrSample(TraceStream &TraceIt) {
+void PerfScriptReader::parseEventOrSample(TraceStream &TraceIt) {
   if (isMMap2Event(TraceIt.getCurrentLine()))
     parseMMap2Event(TraceIt);
   else
     parseSample(TraceIt);
 }
 
-void PerfReaderBase::parseAndAggregateTrace() {
+void PerfScriptReader::parseAndAggregateTrace() {
   // Trace line iterator
   TraceStream TraceIt(PerfTraceFile);
   while (!TraceIt.isAtEoF())
     parseEventOrSample(TraceIt);
 }
 
 // A LBR sample is like:
 // 40062f 0x5c6313f/0x5c63170/P/-/-/0  0x5c630e7/0x5c63130/P/-/-/0 ...
 // A heuristic for fast detection by checking whether a
 // leading "  0x" and the '/' exist.
-bool PerfReaderBase::isLBRSample(StringRef Line) {
+bool PerfScriptReader::isLBRSample(StringRef Line) {
   // Skip the leading instruction pointer
   SmallVector<StringRef, 32> Records;
   Line.trim().split(Records, " ", 2, false);
   if (Records.size() < 2)
     return false;
   if (Records[1].startswith("0x") && Records[1].contains('/'))
     return true;
   return false;
 }
 
-bool PerfReaderBase::isMMap2Event(StringRef Line) {
+bool PerfScriptReader::isMMap2Event(StringRef Line) {
   // Short cut to avoid string find is possible.
   if (Line.empty() || Line.size() < 50)
     return false;
 
   if (std::isdigit(Line[0]))
     return false;
 
   // PERF_RECORD_MMAP2 does not appear at the beginning of the line
   // for ` perf script  --show-mmap-events  -i ...`
   return Line.contains("PERF_RECORD_MMAP2");
 }
 
 // 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
-PerfScriptType PerfReaderBase::checkPerfScriptType(StringRef FileName) {
+PerfContent PerfScriptReader::checkPerfScriptType(StringRef FileName) {
   TraceStream TraceIt(FileName);
   uint64_t FrameAddr = 0;
   while (!TraceIt.isAtEoF()) {
     // Skip the aggregated count
     if (!TraceIt.getCurrentLine().getAsInteger(10, FrameAddr))
       TraceIt.advance();
 
     // Detect sample with call stack
     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;
+          return PerfContent::LBRStack;
         else
-          return PERF_LBR;
+          return PerfContent::LBR;
       }
       TraceIt.advance();
     }
   }
 
   exitWithError("Invalid perf script input!");
-  return PERF_INVALID;
+  return PerfContent::UnknownContent;
 }
 
-void HybridPerfReader::generateRawProfile() {
+void HybridPerfReader::generateUnsymbolizedProfile() {
   ProfileIsCS = !IgnoreStackSamples;
   if (ProfileIsCS)
     unwindSamples();
   else
-    LBRPerfReader::generateRawProfile();
+    PerfScriptReader::generateUnsymbolizedProfile();
 }
 
-void PerfReaderBase::warnTruncatedStack() {
+void PerfScriptReader::warnTruncatedStack() {
   for (auto Address : InvalidReturnAddresses) {
     WithColor::warning()
         << "Truncated stack sample due to invalid return address at "
         << format("0x%" PRIx64, Address)
         << ", likely caused by frame pointer omission\n";
   }
 }
 
-void PerfReaderBase::parsePerfTraces() {
+void PerfScriptReader::parsePerfTraces() {
   // Parse perf traces and do aggregation.
   parseAndAggregateTrace();
 
   // Generate unsymbolized profile.
   warnTruncatedStack();
-  generateRawProfile();
+  generateUnsymbolizedProfile();
 
   if (SkipSymbolization)
-    writeRawProfile(OutputFilename);
+    writeUnsymbolizedProfile(OutputFilename);
 }
 
 } // end namespace sampleprof
 } // end namespace llvm

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

 #include "ProfiledBinary.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/TargetSelect.h"
 
 static cl::OptionCategory ProfGenCategory("ProfGen Options");
 
-cl::opt<std::string> PerfTraceFilename(
+static cl::opt<std::string> PerfScriptFilename(
     "perfscript", cl::value_desc("perfscript"), cl::ZeroOrMore,
     llvm::cl::MiscFlags::CommaSeparated,
     cl::desc("Path of perf-script trace created by Linux perf tool with "
              "`script` command(the raw perf.data should be profiled with -b)"),
     cl::cat(ProfGenCategory));
+static cl::alias PSA("ps", cl::desc("Alias for --perfscript"),
+                     cl::aliasopt(PerfScriptFilename));
 
 static cl::opt<std::string> PerfDataFilename(
     "perfdata", cl::value_desc("perfdata"), cl::ZeroOrMore,
     llvm::cl::MiscFlags::CommaSeparated,
     cl::desc("Path of raw perf data created by Linux perf tool (it should be "
              "profiled with -b)"),
     cl::cat(ProfGenCategory));
+static cl::alias PDA("pd", cl::desc("Alias for --perfdata"),
+                     cl::aliasopt(PerfDataFilename));
+
+static cl::opt<std::string> UnsymbolizedProfFilename(
+    "unsymbolized-profile", cl::value_desc("unsymbolized profile"),
+    cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated,
+    cl::desc("Path of the unsymbolized profile created by "
+             "`llvm-profgen` with `--skip-symbolization`"),
+    cl::cat(ProfGenCategory));
+static cl::alias UPA("up", cl::desc("Alias for --unsymbolized-profile"),
+                     cl::aliasopt(UnsymbolizedProfFilename));
 
 static cl::opt<std::string> BinaryPath(
     "binary", cl::value_desc("binary"), cl::Required,
     cl::desc("Path of profiled binary, only one binary is supported."),
     cl::cat(ProfGenCategory));
 
 extern cl::opt<bool> ShowDisassemblyOnly;
 extern cl::opt<bool> ShowSourceLocations;
 extern cl::opt<bool> SkipSymbolization;
 
 using namespace llvm;
 using namespace sampleprof;
 
 // Validate the command line input.
 static void validateCommandLine() {
+  // Allow the missing perfscript if we only use to show binary disassembly.
+  if (!ShowDisassemblyOnly) {
     // Validate input profile is provided only once
-  if (PerfDataFilename.getNumOccurrences() &&
-      PerfTraceFilename.getNumOccurrences()) {
-    std::string Msg = "`-perfdata` and `-perfscript` cannot be used together.";
-    exitWithError(Msg);
-  }
-
-  // Validate input profile is provided
-  if (!PerfDataFilename.getNumOccurrences() &&
-      !PerfTraceFilename.getNumOccurrences()) {
+    uint16_t HasPerfData = PerfDataFilename.getNumOccurrences();
+    uint16_t HasPerfScript = PerfScriptFilename.getNumOccurrences();
+    uint16_t HasUnsymbolizedProfile =
+        UnsymbolizedProfFilename.getNumOccurrences();
+    uint16_t S = HasPerfData + HasPerfScript + HasUnsymbolizedProfile;
+    if (S != 1) {
       std::string Msg =
-        "Use `-perfdata` or `-perfscript` to provide input perf profile.";
+          S > 1
+              ? "`--perfscript`, `--perfdata` and `--unsymbolized-profile` "
+                "cannot be used together."
+              : "Perf input file is missing, please use one of `--perfscript`, "
+                "`--perfdata` and `--unsymbolized-profile` for the input.";
       exitWithError(Msg);
     }
 
-  // Allow the invalid perfscript if we only use to show binary disassembly.
-  if (!ShowDisassemblyOnly) {
-    if (PerfTraceFilename.getNumOccurrences() &&
-        !llvm::sys::fs::exists(PerfTraceFilename)) {
-      std::string Msg =
-          "Input perf script(" + PerfTraceFilename + ") doesn't exist.";
+    auto CheckFileExists = [](bool H, StringRef File) {
+      if (H && !llvm::sys::fs::exists(File)) {
+        std::string Msg = "Input perf file(" + File.str() + ") doesn't exist.";
         exitWithError(Msg);
       }
+    };
 
-    if (PerfDataFilename.getNumOccurrences() &&
-        !llvm::sys::fs::exists(PerfDataFilename)) {
-      std::string Msg =
-          "Input perf data(" + PerfDataFilename + ") doesn't exist.";
-      exitWithError(Msg);
-    }
+    CheckFileExists(HasPerfData, PerfDataFilename);
+    CheckFileExists(HasPerfScript, PerfScriptFilename);
+    CheckFileExists(HasUnsymbolizedProfile, UnsymbolizedProfFilename);
   }
 
   if (!llvm::sys::fs::exists(BinaryPath)) {
     std::string Msg = "Input binary(" + BinaryPath + ") doesn't exist.";
     exitWithError(Msg);
   }
 
   if (CSProfileGenerator::MaxCompressionSize < -1) {
     exitWithError("Value of --compress-recursion should >= -1");
   }
   if (ShowSourceLocations && !ShowDisassemblyOnly) {
     exitWithError("--show-source-locations should work together with "
                   "--show-disassembly-only!");
   }
 }
 
+static PerfInputFile getPerfInputFile() {
+  PerfInputFile File;
+  if (PerfDataFilename.getNumOccurrences()) {
+    File.InputFile = PerfDataFilename;
+    File.Format = PerfFormat::PerfData;
+  } else if (PerfScriptFilename.getNumOccurrences()) {
+    File.InputFile = PerfScriptFilename;
+    File.Format = PerfFormat::PerfScript;
+  } else if (UnsymbolizedProfFilename.getNumOccurrences()) {
+    File.InputFile = UnsymbolizedProfFilename;
+    File.Format = PerfFormat::UnsymbolizedProfile;
+  }
+  return File;
+}
+
 int main(int argc, const char *argv[]) {
   InitLLVM X(argc, argv);
 
   // Initialize targets and assembly printers/parsers.
   InitializeAllTargetInfos();
   InitializeAllTargetMCs();
   InitializeAllDisassemblers();
 
   cl::HideUnrelatedOptions({&ProfGenCategory, &getColorCategory()});
   cl::ParseCommandLineOptions(argc, argv, "llvm SPGO profile generator\n");
   validateCommandLine();
 
   // Load symbols and disassemble the code of a given binary.
   std::unique_ptr<ProfiledBinary> Binary =
       std::make_unique<ProfiledBinary>(BinaryPath);
   if (ShowDisassemblyOnly)
     return EXIT_SUCCESS;
 
-  // Parse perf events and samples
-  StringRef PerfInputFile;
-  bool IsPerfData = PerfDataFilename.getNumOccurrences();
-  if (IsPerfData)
-    PerfInputFile = PerfDataFilename;
-  else
-    PerfInputFile = PerfTraceFilename;
+  PerfInputFile PerfFile = getPerfInputFile();
   std::unique_ptr<PerfReaderBase> Reader =
-      PerfReaderBase::create(Binary.get(), PerfInputFile, IsPerfData);
+      PerfReaderBase::create(Binary.get(), PerfFile);
+  // Parse perf events and samples
   Reader->parsePerfTraces();
 
   if (SkipSymbolization)
     return EXIT_SUCCESS;
 
   std::unique_ptr<ProfileGeneratorBase> Generator =
       ProfileGeneratorBase::create(Binary.get(), Reader->getSampleCounters(),
                                    Reader->profileIsCS());
   Generator->generateProfile();
   Generator->write();
 
   return EXIT_SUCCESS;
 }