[InstrProf] Add version into llvm-profdata

[gulfem]

Summary

This patch adds support of printing profile version
into llvm-profdata which was proposed in:
https://discourse.llvm.org/t/llvm-profdata-failure-guarantees-for-code-coverage/64924

[gulfem]

Fixed the test.

[davidxl]

lgtm

compiler-rt/test/profile/Linux/profile-version.c

+// REQUIRES: linux
+// RUN: %clang_profgen -O2 -o %t %s
+// RUN: env LLVM_PROFILE_FILE=%t.profraw %run %t
+// RUN: llvm-profdata show --profile-version %t.profraw > %t.profraw.out
+// RUN: FileCheck %s --check-prefix=RAW-PROF < %t.profraw.out
+
+// RUN: rm -rf %t.profdir
+// RUN: env LLVM_PROFILE_FILE=%t.profdir/default_%m.profraw %run %t
+// RUN: env LLVM_PROFILE_FILE=%t.profdir/default_%m.profraw %run %t
+// RUN: env LLVM_PROFILE_FILE=%t.profdir/default_%m.profraw %run %t
+// RUN: llvm-profdata show --profile-version %t.profdir/default_*.profraw > %t.profraw.out
+// RUN: FileCheck %s --check-prefix=INDEXED-PROF < %t.profraw.out
+
+void foo() {}
+
+void bar() {}
+
+int main() {
+  foo();
+  bar();
+  return 0;
+}
+
+// RAW-PROF: Instrumentation level: Front-end
+// RAW-PROF-NEXT: Total functions: 3
+// RAW-PROF-NEXT: Maximum function count: 1
+// RAW-PROF-NEXT: Maximum internal block count: 0
+// RAW-PROF-NEXT: Profile version: {{[0-9]+}}
+
+// INDEXED-PROF: Instrumentation level: Front-end
+// INDEXED-PROF-NEXT: Total functions: 3
+// INDEXED-PROF-NEXT: Maximum function count: 3
+// INDEXED-PROF-NEXT: Maximum internal block count: 0
+// INDEXED-PROF-NEXT: Profile version: {{[0-9]+}}

llvm/docs/CommandGuide/llvm-profdata.rst

 
 OPTIONS
 ^^^^^^^
 
 .. option:: --all-functions
 
  Print details for every function.
 
+.. option:: --binary-ids
+
+ Print embedded binary ids in a profile.
+
 .. option:: --counts
 
  Print the counter values for the displayed functions.
 
 .. option:: --function=<string>
 
  Print details for a function if the function's name contains the given string.
 

  Show only those functions whose max count values are greater or equal to ``n``.
  By default, the value-cutoff is set to 0.
 
 .. option:: --list-below-cutoff
 
  Only output names of functions whose max count value are below the cutoff
  value.
 
+.. option:: --profile-version
+
+ Print profile version.
+
 .. option:: --showcs
 
  Only show context sensitive profile counts. The default is to filter all
  context sensitive profile counts.
 
 .. option:: --show-prof-sym-list=[true|false]
 
  Show profile symbol list if it exists in the profile. This option is only

llvm/include/llvm/ProfileData/InstrProfReader.h

public:
 
   /// Print binary ids on stream OS.
   virtual Error printBinaryIds(raw_ostream &OS) { return success(); };
 
   /// Iterator over profile data.
   InstrProfIterator<> begin() { return InstrProfIterator<>(this); }
   InstrProfIterator<> end() { return InstrProfIterator<>(); }
 
+  /// Return the profile version.
+  virtual uint64_t getVersion() const = 0;
+
   virtual bool isIRLevelProfile() const = 0;
 
   virtual bool hasCSIRLevelProfile() const = 0;
 
   virtual bool instrEntryBBEnabled() const = 0;
 
   /// Return true if we must provide debug info to create PGO profiles.
   virtual bool useDebugInfoCorrelate() const { return false; }
public:
   TextInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer_)
       : DataBuffer(std::move(DataBuffer_)), Line(*DataBuffer, true, '#') {}
   TextInstrProfReader(const TextInstrProfReader &) = delete;
   TextInstrProfReader &operator=(const TextInstrProfReader &) = delete;
 
   /// Return true if the given buffer is in text instrprof format.
   static bool hasFormat(const MemoryBuffer &Buffer);
 
+  // Text format does not have version, so return 0.
+  uint64_t getVersion() const override { return 0; }
+
   bool isIRLevelProfile() const override {
     return static_cast<bool>(ProfileKind & InstrProfKind::IRInstrumentation);
   }
 
   bool hasCSIRLevelProfile() const override {
     return static_cast<bool>(ProfileKind & InstrProfKind::ContextSensitive);
   }
 
public:
   RawInstrProfReader(const RawInstrProfReader &) = delete;
   RawInstrProfReader &operator=(const RawInstrProfReader &) = delete;
 
   static bool hasFormat(const MemoryBuffer &DataBuffer);
   Error readHeader() override;
   Error readNextRecord(NamedInstrProfRecord &Record) override;
   Error printBinaryIds(raw_ostream &OS) override;
 
+  uint64_t getVersion() const override { return Version; }
+
   bool isIRLevelProfile() const override {
     return (Version & VARIANT_MASK_IR_PROF) != 0;
   }
 
   bool hasCSIRLevelProfile() const override {
     return (Version & VARIANT_MASK_CSIR_PROF) != 0;
   }
 
IndexedInstrProfReader(
       std::unique_ptr<MemoryBuffer> DataBuffer,
       std::unique_ptr<MemoryBuffer> RemappingBuffer = nullptr)
       : DataBuffer(std::move(DataBuffer)),
         RemappingBuffer(std::move(RemappingBuffer)), RecordIndex(0) {}
   IndexedInstrProfReader(const IndexedInstrProfReader &) = delete;
   IndexedInstrProfReader &operator=(const IndexedInstrProfReader &) = delete;
 
   /// Return the profile version.
-  uint64_t getVersion() const { return Index->getVersion(); }
+  uint64_t getVersion() const override { return Index->getVersion(); }
   bool isIRLevelProfile() const override { return Index->isIRLevelProfile(); }
   bool hasCSIRLevelProfile() const override {
     return Index->hasCSIRLevelProfile();
   }
 
   bool instrEntryBBEnabled() const override {
     return Index->instrEntryBBEnabled();
   }

llvm/tools/llvm-profdata/llvm-profdata.cpp

 static int showInstrProfile(const std::string &Filename, bool ShowCounts,
                             uint32_t TopN, bool ShowIndirectCallTargets,
                             bool ShowMemOPSizes, bool ShowDetailedSummary,
                             std::vector<uint32_t> DetailedSummaryCutoffs,
                             bool ShowAllFunctions, bool ShowCS,
                             uint64_t ValueCutoff, bool OnlyListBelow,
                             const std::string &ShowFunction, bool TextFormat,
                             bool ShowBinaryIds, bool ShowCovered,
-                            raw_fd_ostream &OS) {
+                            bool ShowProfileVersion, raw_fd_ostream &OS) {
   auto ReaderOrErr = InstrProfReader::create(Filename);
   std::vector<uint32_t> Cutoffs = std::move(DetailedSummaryCutoffs);
   if (ShowDetailedSummary && Cutoffs.empty()) {
     Cutoffs = ProfileSummaryBuilder::DefaultCutoffs;
   }
   InstrProfSummaryBuilder Builder(std::move(Cutoffs));
   if (Error E = ReaderOrErr.takeError())
     exitWithError(std::move(E), Filename);
if (ShowDetailedSummary) {
     OS << "Total count: " << PS->getTotalCount() << "\n";
     PS->printDetailedSummary(OS);
   }
 
   if (ShowBinaryIds)
     if (Error E = Reader->printBinaryIds(OS))
       exitWithError(std::move(E), Filename);
 
+  if (ShowProfileVersion)
+    OS << "Profile version: " << Reader->getVersion() << "\n";
   return 0;
 }
 
 static void showSectionInfo(sampleprof::SampleProfileReader *Reader,
                             raw_fd_ostream &OS) {
   if (!Reader->dumpSectionInfo(OS)) {
     WithColor::warning() << "-show-sec-info-only is only supported for "
                          << "sample profile in extbinary format and is "
cl::opt<std::string> DebugInfoFilename(
       cl::desc("Read and extract profile metadata from debug info and show "
                "the functions it found."));
   cl::opt<bool> ShowCovered(
       "covered", cl::init(false),
       cl::desc("Show only the functions that have been executed."));
   cl::opt<std::string> ProfiledBinary(
       "profiled-binary", cl::init(""),
       cl::desc("Path to binary from which the profile was collected."));
-
+  cl::opt<bool> ShowProfileVersion("profile-version", cl::init(false),
+                                   cl::desc("Show profile version. "));
   cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n");
 
   if (Filename.empty() && DebugInfoFilename.empty())
     exitWithError(
         "the positional argument '<profdata-file>' is required unless '--" +
         DebugInfoFilename.ArgStr + "' is provided");
 
   if (Filename == OutputFilename) {
if (!DebugInfoFilename.empty())
     return showDebugInfoCorrelation(DebugInfoFilename, ShowDetailedSummary,
                                     ShowProfileSymbolList, OS);
 
   if (ProfileKind == instr)
     return showInstrProfile(
         Filename, ShowCounts, TopNFunctions, ShowIndirectCallTargets,
         ShowMemOPSizes, ShowDetailedSummary, DetailedSummaryCutoffs,
         ShowAllFunctions, ShowCS, ValueCutoff, OnlyListBelow, ShowFunction,
-        TextFormat, ShowBinaryIds, ShowCovered, OS);
+        TextFormat, ShowBinaryIds, ShowCovered, ShowProfileVersion, OS);
   if (ProfileKind == sample)
     return showSampleProfile(
         Filename, ShowCounts, TopNFunctions, ShowAllFunctions,
         ShowDetailedSummary, ShowFunction, ShowProfileSymbolList,
         ShowSectionInfoOnly, ShowHotFuncList, JsonFormat, OS);
   return showMemProfProfile(Filename, ProfiledBinary, OS);
 }