[llvm-objdump] Dump the contents of llvm stats

llvm/test/Transforms/SampleProfile/pseudo-probe-profile-mismatch.ll

 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%S/Inputs/pseudo-probe-profile-mismatch.prof -report-profile-staleness -persist-profile-staleness -S 2>%t -o %t.ll
 ; RUN: FileCheck %s --input-file %t
 ; RUN: FileCheck %s --input-file %t.ll -check-prefix=CHECK-MD
 ; RUN: llc < %t.ll -filetype=obj -o %t.obj
-; RUN: llvm-objdump --section-headers %t.obj | FileCheck %s --check-prefix=CHECK-OBJ
+; RUN: llvm-objdump --llvm-stats %t.obj | FileCheck %s --check-prefix=CHECK-OBJ
 
 ; CHECK: (1/3) of functions' profile are invalid and (10/50) of samples are discarded due to function hash mismatch.
 ; CHECK: (2/3) of callsites' profile are invalid and (20/30) of samples are discarded due to callsite location mismatch.
 
 ; CHECK-MD: ![[#]] = !{!"NumMismatchedFuncHash", i64 1, !"TotalProfiledFunc", i64 3, !"MismatchedFuncHashSamples", i64 10, !"TotalFuncHashSamples", i64 50, !"MismatchedCallsiteSamples", i64 20, !"TotalCallsiteSamples", i64 30}
 
 ; CHECK-OBJ: .llvm_stats
 

llvm/tools/llvm-objdump/ObjdumpOpts.td

 def : Separate<["--"], "triple">,
   Alias<triple_EQ>;
 
 def unwind_info : Flag<["--"], "unwind-info">,
   HelpText<"Display unwind information">;
 def : Flag<["-"], "u">, Alias<unwind_info>,
   HelpText<"Alias for --unwind-info">;
 
+def llvm_stats : Flag<["--"], "llvm-stats">,
+  HelpText<"Display the content of .llvm_stats section">;
+
 def wide : Flag<["--"], "wide">,
   HelpText<"Ignored for compatibility with GNU objdump">;
 def : Flag<["-"], "w">, Alias<wide>;
 
 defm prefix : Eq<"prefix", "Add prefix to absolute paths">,
               MetaVarName<"prefix">;
 defm prefix_strip
     : Eq<"prefix-strip", "Strip out initial directories from absolute "

llvm/tools/llvm-objdump/llvm-objdump.h

 extern bool Relocations;
 extern bool SectionHeaders;
 extern bool SectionContents;
 extern bool ShowRawInsn;
 extern bool SymbolDescription;
 extern bool SymbolTable;
 extern std::string TripleName;
 extern bool UnwindInfo;
+extern bool LLVMStats;
 
 extern StringSet<> FoundSectionSet;
 
 typedef std::function<bool(llvm::object::SectionRef const &)> FilterPredicate;
 
 /// A filtered iterator for SectionRefs that skips sections based on some given
 /// predicate.
 class SectionFilterIterator {

llvm/tools/llvm-objdump/llvm-objdump.cpp

 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/OffloadBinary.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
+#include "llvm/Support/Base64.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/GraphWriter.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/LEB128.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cctype>

 static uint64_t StopAddress = UINT64_MAX;
 static bool HasStopAddressFlag;
 
 bool objdump::SymbolTable;
 static bool SymbolizeOperands;
 static bool DynamicSymbolTable;
 std::string objdump::TripleName;
 bool objdump::UnwindInfo;
+bool objdump::LLVMStats;
 static bool Wide;
 std::string objdump::Prefix;
 uint32_t objdump::PrefixStrip;
 
 DebugVarsFormat objdump::DbgVariables = DVDisabled;
 
 int objdump::DbgIndent = 52;
 
else if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(O))
     printMachOUnwindInfo(MachO);
   else
     // TODO: Extract DWARF dump tool to objdump.
     WithColor::error(errs(), ToolName)
         << "This operation is only currently supported "
            "for COFF and MachO object files.\n";
 }
 
+static void printLLVMStats(const ObjectFile *O) {
+  Optional<SectionRef> LLVMStatsSec;
+
+  for (const SectionRef &Section : O->sections()) {
+    Expected<StringRef> SecNameOrErr = Section.getName();
+    if (!SecNameOrErr) {
+      consumeError(SecNameOrErr.takeError());
+      continue;
+    }
+    if (*SecNameOrErr == ".llvm_stats")
+      LLVMStatsSec = Section;
+  }
+
+  outs() << "\nLLVM STATISTICS:\n";
+
+  if (!LLVMStatsSec) {
+    reportWarning("no .llvm_stats section in the object file",
+                  O->getFileName());
+    return;
+  }
+
+  StringRef Contents =
+      unwrapOrError(LLVMStatsSec->getContents(), O->getFileName());
+
+  uint32_t KeyPadding = 40;
+  outs() << left_justify("KEY", KeyPadding) << " VALUE\n";
+
+  const uint8_t *Data = reinterpret_cast<const uint8_t *>(Contents.data());
+  const uint8_t *End = Data + Contents.size();
+
+  auto ReadString = [&]() {
+    unsigned NumBytesRead = 0;
+    uint64_t Size = decodeULEB128(Data, &NumBytesRead);
+    if ((Data + NumBytesRead > End) || (Data + NumBytesRead + Size > End)) {
+      reportError(O->getFileName(), "Error when decoding .llvm_stats section");
+    }
+    Data += NumBytesRead;
+    StringRef Str(reinterpret_cast<const char *>(Data), Size);
+    Data += Size;
+    return Str;
+  };
+
+  while (Data < End) {
+    StringRef Key = ReadString();
+    StringRef ValInput = ReadString();
+
+    std::vector<char> ValOutput;
+    if (auto Err = decodeBase64(ValInput, ValOutput))
+      reportError(std::move(Err), O->getFileName());
+    std::string Value(ValOutput.begin(), ValOutput.end());
+
+    outs() << left_justify(Key, KeyPadding) << " " << Value << "\n";
+  }
+}
+
 /// Dump the raw contents of the __clangast section so the output can be piped
 /// into llvm-bcanalyzer.
 static void printRawClangAST(const ObjectFile *Obj) {
   if (outs().is_displayed()) {
     WithColor::error(errs(), ToolName)
         << "The -raw-clang-ast option will dump the raw binary contents of "
            "the clang ast section.\n"
            "Please redirect the output to a file or another program such as "
static void dumpObject(ObjectFile *O, const Archive *A = nullptr,
   if (DynamicRelocations)
     printDynamicRelocations(O);
   if (SectionContents)
     printSectionContents(O);
   if (Disassemble)
     disassembleObject(O, Relocations);
   if (UnwindInfo)
     printUnwindInfo(O);
+  if (LLVMStats)
+    printLLVMStats(O);
 
   // Mach-O specific options:
   if (ExportsTrie)
     printExportsTrie(O);
   if (Rebase)
     printRebaseTable(O);
   if (Bind)
     printBindTable(O);
static void parseObjdumpOptions(const llvm::opt::InputArgList &InputArgs) {
   HasStartAddressFlag = InputArgs.hasArg(OBJDUMP_start_address_EQ);
   parseIntArg(InputArgs, OBJDUMP_stop_address_EQ, StopAddress);
   HasStopAddressFlag = InputArgs.hasArg(OBJDUMP_stop_address_EQ);
   SymbolTable = InputArgs.hasArg(OBJDUMP_syms);
   SymbolizeOperands = InputArgs.hasArg(OBJDUMP_symbolize_operands);
   DynamicSymbolTable = InputArgs.hasArg(OBJDUMP_dynamic_syms);
   TripleName = InputArgs.getLastArgValue(OBJDUMP_triple_EQ).str();
   UnwindInfo = InputArgs.hasArg(OBJDUMP_unwind_info);
+  LLVMStats = InputArgs.hasArg(OBJDUMP_llvm_stats);
   Wide = InputArgs.hasArg(OBJDUMP_wide);
   Prefix = InputArgs.getLastArgValue(OBJDUMP_prefix).str();
   parseIntArg(InputArgs, OBJDUMP_prefix_strip, PrefixStrip);
   if (const opt::Arg *A = InputArgs.getLastArg(OBJDUMP_debug_vars_EQ)) {
     DbgVariables = StringSwitch<DebugVarsFormat>(A->getValue())
                        .Case("ascii", DVASCII)
                        .Case("unicode", DVUnicode)
                        .Default(DVInvalid);
int main(int argc, char **argv) {
 
   if (DisassembleAll || PrintSource || PrintLines ||
       !DisassembleSymbols.empty())
     Disassemble = true;
 
   if (!ArchiveHeaders && !Disassemble && DwarfDumpType == DIDT_Null &&
       !DynamicRelocations && !FileHeaders && !PrivateHeaders && !RawClangAST &&
       !Relocations && !SectionHeaders && !SectionContents && !SymbolTable &&
-      !DynamicSymbolTable && !UnwindInfo && !FaultMapSection && !Offloading &&
+      !DynamicSymbolTable && !UnwindInfo && !LLVMStats && !FaultMapSection &&
+      !Offloading &&
       !(MachOOpt &&
         (Bind || DataInCode || ChainedFixups || DyldInfo || DylibId ||
          DylibsUsed || ExportsTrie || FirstPrivateHeader ||
          FunctionStartsType != FunctionStartsMode::None || IndirectSymbols ||
          InfoPlist || LazyBind || LinkOptHints || ObjcMetaData || Rebase ||
          Rpaths || UniversalHeaders || WeakBind || !FilterSections.empty()))) {
     T->printHelp(ToolName);
     return 2;