Dump Accumulator

[kazu]

Summary

This patch adds a utility called DumpAccumulator.

DumpAccumulator allows you to dump arbitrary text messages into a special
section called .llvm_dump. The linker then concatenates these messages into
the identically named section in the final executable.

This utility makes it easy to collect information from optimization
passes of interest in a build environment that caches compilation.

See llvm/include/llvm/Analysis/DumpAccumulator.h for usage.

The original implementation is from Mircea Trofin, and I generalized it.

[mtrofin]

llvm/include/llvm/Analysis/DumpAccumulator.h

43

I'd clarify that transferring the data from pre-link thinlto to post-link isn't supported, but one could use this in post-link, correct?

[kazu]

llvm/include/llvm/Analysis/DumpAccumulator.h

43

We don't add DumpAccumulator to the post-link ThinLTO pipeline yet.

Note that we add DumpAccumulator in buildPerModuleDefaultPipeline, but post-link ThinLTO doesn't call the function.

[mtrofin]

llvm/include/llvm/Analysis/DumpAccumulator.h

43

Yes - my point is that one could enable it in post-link and 'it'd just work'; the thing that doesn't work is making pre-link data jump over to post-link, which would require more plumbing.

[mtrofin]

lgtm

[jhenderson]

Could the llvm-readobj bit be spun off into a separate review, please. As things stand it doesn't have any of its own testing, which should be added at the same time as adding support in the tool itself. The new option is also lacking any documentation in the llvm-readobj and llvm-readelf docs.

[kazu]

In D84473#2178167, @jhenderson wrote:

Could the llvm-readobj bit be spun off into a separate review, please. As things stand it doesn't have any of its own testing, which should be added at the same time as adding support in the tool itself. The new option is also lacking any documentation in the llvm-readobj and llvm-readelf docs.

Sure. I'll split the compiler and llvm-readobj bits and check in the former first. I'll come up with documentation for the llvm-readobj bit. Thanks!

[kazu]

Spun off the llvm-readobj bit.

[jhenderson]

I'm assuming you need llvm-readobj to test your changes? In which case, the llvm-readobj change needs to come first, and then you can write tests using it to test this change (at the moment, the testing for this seems insufficient to me). Do you have a patch yet for the llvm-readobj side?

Could you add some documentation somewhere, either in code comments or somewhere else, explaining the output format you actually want this to be? From my casual reading (I'm not the most knowledgeable of people in this area), it looks like you're creating an ELF SHT_NOTE section, but don't use the SHT_NOTE ELF format (see https://www.sco.com/developers/gabi/latest/ch5.pheader.html#note_section for details). I would actually expect this to emit a section with a new section type, so that the consumer (llvm-readobj) can more easily identify it. Alternatively, it could just be a basic SHT_NOTE section, with a specific note type. Under no circumstances should consumers need to check the section header name to identify the section (string comparisons are expensive, and should be avoided where possible - the general intent for ELF is for different kinds of sections to be distinguished by their types and flags).

llvm/include/llvm/Analysis/DumpAccumulator.h

57

Spurious include?

[jhenderson]

By the way, has the design of this been discussed on llvm-dev? It seems like something should have an RFC if it hasn't already.

clang/lib/CodeGen/BackendUtil.cpp

 #include "clang/Basic/TargetOptions.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/Analysis/DumpAccumulator.h"
 #include "llvm/Analysis/StackSafetyAnalysis.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/CodeGen/RegAllocRegistry.h"
 #include "llvm/CodeGen/SchedulerRegistry.h"

 #include <memory>
 using namespace clang;
 using namespace llvm;
 
 #define HANDLE_EXTENSION(Ext)                                                  \
   llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
 #include "llvm/Support/Extension.def"
 
+extern cl::opt<bool> EnableDumpAccumulator;
+
 namespace {
 
 // Default filename used for profile generation.
 static constexpr StringLiteral DefaultProfileGenName = "default_%m.profraw";
 
 class EmitAssemblyHelper {
   DiagnosticsEngine &Diags;
   const HeaderSearchOptions &HSOpts;
case Backend_EmitLL:
     break;
 
   case Backend_EmitAssembly:
   case Backend_EmitMCNull:
   case Backend_EmitObj:
     NeedCodeGen = true;
     CodeGenPasses.add(
         createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
+    if (EnableDumpAccumulator)
+      CodeGenPasses.add(new DumpAccumulatorWrapper([&MAM](Module &M) {
+        return MAM.getCachedResult<DumpAccumulator>(M);
+      }));
     if (!CodeGenOpts.SplitDwarfOutput.empty()) {
       DwoOS = openOutputFile(CodeGenOpts.SplitDwarfOutput);
       if (!DwoOS)
         return;
     }
     if (!AddEmitPasses(CodeGenPasses, Action, *OS,
                        DwoOS ? &DwoOS->os() : nullptr))
       // FIXME: Should we handle this error differently?

llvm/include/llvm/Analysis/DumpAccumulator.h

+//===- llvm/Analysis/DumpAccumulator.h - Dump Accumulator -------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the declarations for the dump accumulator.
+//
+// DumpAccumulator allows you to dump arbitrary text messages into a special
+// section called .llvm_dump.  The linker then concatenates these messages into
+// the identically named section in the final executable.
+//
+// This utility makes it easy to collect information from optimization passes of
+// interest in a build environment that caches compilation.
+//
+// Suppose you wish to dump all occurrences of inlining.  Then:
+//
+// Step 1: Build your compiler with the following modifications.
+//
+// Add:
+//
+//   #include "llvm/Analysis/DumpAccumulator.h"
+//
+// Declare in the inlining pass:
+//
+//   DumpAccumulator::Result *DAR = MAMProxy.getCachedResult<DumpAccumulator>(M);
+//
+// Add code like so that a message is accumulated every time inlining happens:
+//
+//   if (DAR) {
+//     DAR->Message += F.getName();
+//     DAR->Message += ",";
+//     DAR->Message += Callee.getName();
+//     DAR->Message += "\n";
+//   }
+//
+// Step 2: Build your testcase with:
+//
+//   -mllvm -enable-dump-accumulator
+//
+// Note that ThinLTO is not supported yet.
+//
+// Step 3: Dump the messages like so:
+//
+//   $ llvm-readobj --llvm-dump a.out
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_DUMPACCUMULATOR_H
+#define LLVM_ANALYSIS_DUMPACCUMULATOR_H
+
+#include "llvm/IR/PassManager.h"
+
+#include <string>
+
+namespace llvm {
+class DumpAccumulator : public AnalysisInfoMixin<DumpAccumulator> {
+public:
+  struct Result {
+    bool invalidate(Module &, const PreservedAnalyses &,
+                    llvm::ModuleAnalysisManager::Invalidator &) {
+      return false;
+    }
+
+    Result() = default;
+    Result(const Result &) = delete;
+    Result(Result &&Other) = default;
+    ~Result() = default;
+
+    std::string Message;
+  };
+
+  DumpAccumulator() = default;
+
+  Result run(Module &M, ModuleAnalysisManager &MAM) { return {}; }
+
+private:
+  static AnalysisKey Key;
+  friend AnalysisInfoMixin<DumpAccumulator>;
+};
+
+class DumpAccumulatorWrapper : public ImmutablePass {
+  std::function<DumpAccumulator::Result *(Module &M)> GetFFA;
+
+public:
+  static char ID;
+  explicit DumpAccumulatorWrapper(
+      std::function<DumpAccumulator::Result *(Module &M)> GetFFA);
+  DumpAccumulatorWrapper() : ImmutablePass(ID){};
+  DumpAccumulator::Result *GetResult(Module &M) { return GetFFA(M); }
+};
+
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_DUMPACCUMULATOR_H

llvm/include/llvm/InitializePasses.h

 void initializeDetectDeadLanesPass(PassRegistry&);
 void initializeDivRemPairsLegacyPassPass(PassRegistry&);
 void initializeDomOnlyPrinterPass(PassRegistry&);
 void initializeDomOnlyViewerPass(PassRegistry&);
 void initializeDomPrinterPass(PassRegistry&);
 void initializeDomViewerPass(PassRegistry&);
 void initializeDominanceFrontierWrapperPassPass(PassRegistry&);
 void initializeDominatorTreeWrapperPassPass(PassRegistry&);
+void initializeDumpAccumulatorWrapperPass(PassRegistry &);
 void initializeDwarfEHPreparePass(PassRegistry&);
 void initializeEarlyCSELegacyPassPass(PassRegistry&);
 void initializeEarlyCSEMemSSALegacyPassPass(PassRegistry&);
 void initializeEarlyIfConverterPass(PassRegistry&);
 void initializeEarlyIfPredicatorPass(PassRegistry &);
 void initializeEarlyMachineLICMPass(PassRegistry&);
 void initializeEarlyTailDuplicatePass(PassRegistry&);
 void initializeEdgeBundlesPass(PassRegistry&);

llvm/lib/Analysis/CMakeLists.txt

add_llvm_component_library(LLVMAnalysis
   DemandedBits.cpp
   DependenceAnalysis.cpp
   DependenceGraphBuilder.cpp
   DevelopmentModeInlineAdvisor.cpp
   DivergenceAnalysis.cpp
   DomPrinter.cpp
   DomTreeUpdater.cpp
   DominanceFrontier.cpp
+  DumpAccumulator.cpp
   EHPersonalities.cpp
   FunctionPropertiesAnalysis.cpp
   GlobalsModRef.cpp
   GuardUtils.cpp
   HeatUtils.cpp
   IVDescriptors.cpp
   IVUsers.cpp
   IndirectCallPromotionAnalysis.cpp

llvm/lib/Analysis/DumpAccumulator.cpp

+//===- DumpAccumulator.cpp - Dumping infrastructure -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This implements feature and label extraction for offline supervised learning
+// of a IR to native size model.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Analysis/DumpAccumulator.h"
+#include "llvm/InitializePasses.h"
+
+using namespace llvm;
+
+AnalysisKey DumpAccumulator::Key;
+
+char DumpAccumulatorWrapper::ID = 0;
+INITIALIZE_PASS(DumpAccumulatorWrapper, "dumpaccumulator", "Dump Accumulator",
+                false, true)
+
+DumpAccumulatorWrapper::DumpAccumulatorWrapper(
+    std::function<DumpAccumulator::Result *(Module &M)> GetFFA)
+    : ImmutablePass(ID), GetFFA(GetFFA) {
+  initializeDumpAccumulatorWrapperPass(*PassRegistry::getPassRegistry());
+}

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Analysis/ConstantFolding.h"
+#include "llvm/Analysis/DumpAccumulator.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/CodeGen/GCMetadata.h"
 #include "llvm/CodeGen/GCMetadataPrinter.h"
 #include "llvm/CodeGen/GCStrategy.h"

 #include "llvm/Pass.h"
 #include "llvm/Remarks/Remark.h"
 #include "llvm/Remarks/RemarkFormat.h"
 #include "llvm/Remarks/RemarkStreamer.h"
 #include "llvm/Remarks/RemarkStringTable.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/Compression.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
const MCSection *AsmPrinter::getCurrentSection() const {
   return OutStreamer->getCurrentSectionOnly();
 }
 
 void AsmPrinter::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   MachineFunctionPass::getAnalysisUsage(AU);
   AU.addRequired<MachineOptimizationRemarkEmitterPass>();
   AU.addRequired<GCModuleInfo>();
+  AU.addUsedIfAvailable<DumpAccumulatorWrapper>();
 }
 
 bool AsmPrinter::doInitialization(Module &M) {
   auto *MMIWP = getAnalysisIfAvailable<MachineModuleInfoWrapperPass>();
   MMI = MMIWP ? &MMIWP->getMMI() : nullptr;
 
   // Initialize TargetLoweringObjectFile.
   const_cast<TargetLoweringObjectFile&>(getObjFileLowering())
for (const GlobalValue &GV : M.global_values()) {
       OutStreamer->emitBytes(GV.getPartition());
       OutStreamer->emitZeros(1);
       OutStreamer->emitValue(
           MCSymbolRefExpr::create(getSymbol(&GV), OutContext),
           MAI->getCodePointerSize());
     }
   }
 
+  if (auto *DumpAccumulatorAnalysis =
+          getAnalysisIfAvailable<DumpAccumulatorWrapper>()) {
+    auto *DS = OutStreamer->getContext().getELFSection(
+        ".llvm_dump", ELF::SHT_NOTE, ELF::SHF_STRINGS);
+    OutStreamer->SwitchSection(DS);
+    std::string &Out = DumpAccumulatorAnalysis->GetResult(M)->Message;
+    SmallVector<char, 128> Compressed;
+    Error E = zlib::compress(Out.c_str(), Compressed);
+    assert(!E);
+    OutStreamer->emitULEB128IntValue(Out.size());
+    OutStreamer->emitULEB128IntValue(Compressed.size());
+    OutStreamer->emitBytes({Compressed.data(), Compressed.size()});
+  }
+
   // Allow the target to emit any magic that it wants at the end of the file,
   // after everything else has gone out.
   emitEndOfAsmFile(M);
 
   MMI = nullptr;
 
   OutStreamer->Finish();
   OutStreamer->reset();

llvm/lib/Passes/PassBuilder.cpp

 #include "llvm/Analysis/CFLAndersAliasAnalysis.h"
 #include "llvm/Analysis/CFLSteensAliasAnalysis.h"
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/DDG.h"
 #include "llvm/Analysis/DemandedBits.h"
 #include "llvm/Analysis/DependenceAnalysis.h"
 #include "llvm/Analysis/DominanceFrontier.h"
+#include "llvm/Analysis/DumpAccumulator.h"
 #include "llvm/Analysis/FunctionPropertiesAnalysis.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/IVUsers.h"
 #include "llvm/Analysis/InlineAdvisor.h"
 #include "llvm/Analysis/InlineSizeEstimatorAnalysis.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/Analysis/LazyValueInfo.h"
 #include "llvm/Analysis/LoopAccessAnalysis.h"
EnableCHR("enable-chr-npm", cl::init(true), cl::Hidden,
               cl::desc("Enable control height reduction optimization (CHR)"));
 
 /// Flag to enable inline deferral during PGO.
 static cl::opt<bool>
     EnablePGOInlineDeferral("enable-npm-pgo-inline-deferral", cl::init(true),
                             cl::Hidden,
                             cl::desc("Enable inline deferral during PGO"));
 
+cl::opt<bool> EnableDumpAccumulator("enable-dump-accumulator", cl::init(true),
+                                    cl::Hidden,
+                                    cl::desc("Enable the dump accumulator."));
+
 PipelineTuningOptions::PipelineTuningOptions() {
   LoopInterleaving = true;
   LoopVectorization = true;
   SLPVectorization = false;
   LoopUnrolling = true;
   ForgetAllSCEVInLoopUnroll = ForgetSCEVInLoopUnroll;
   Coroutines = false;
   LicmMssaOptCap = SetLicmMssaOptCap;

 ModulePassManager
 PassBuilder::buildPerModuleDefaultPipeline(OptimizationLevel Level,
                                            bool DebugLogging, bool LTOPreLink) {
   assert(Level != OptimizationLevel::O0 &&
          "Must request optimizations for the default pipeline!");
 
   ModulePassManager MPM(DebugLogging);
 
+  MPM.addPass(RequireAnalysisPass<DumpAccumulator, Module>());
+
   // Force any function attributes we want the rest of the pipeline to observe.
   MPM.addPass(ForceFunctionAttrsPass());
 
   // Apply module pipeline start EP callback.
   for (auto &C : PipelineStartEPCallbacks)
     C(MPM);
 
   if (PGOOpt && PGOOpt->SamplePGOSupport)

llvm/lib/Passes/PassRegistry.def

 MODULE_ANALYSIS("module-summary", ModuleSummaryIndexAnalysis())
 MODULE_ANALYSIS("no-op-module", NoOpModuleAnalysis())
 MODULE_ANALYSIS("profile-summary", ProfileSummaryAnalysis())
 MODULE_ANALYSIS("stack-safety", StackSafetyGlobalAnalysis())
 MODULE_ANALYSIS("verify", VerifierAnalysis())
 MODULE_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC))
 MODULE_ANALYSIS("asan-globals-md", ASanGlobalsMetadataAnalysis())
 MODULE_ANALYSIS("inline-advisor", InlineAdvisorAnalysis())
+MODULE_ANALYSIS("dump-accumulator", DumpAccumulator())
 
 #ifndef MODULE_ALIAS_ANALYSIS
 #define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)                               \
   MODULE_ANALYSIS(NAME, CREATE_PASS)
 #endif
 MODULE_ALIAS_ANALYSIS("globals-aa", GlobalsAA())
 #undef MODULE_ALIAS_ANALYSIS
 #undef MODULE_ANALYSIS

llvm/test/Other/new-pm-defaults.ll

 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \
 ; RUN:     --check-prefix=%llvmcheckext \
 ; RUN:     --check-prefix=CHECK-EP-OPTIMIZER-LAST --check-prefix=CHECK-O23SZ
 
 ; CHECK-O: Running analysis: PassInstrumentationAnalysis
 ; CHECK-O-NEXT: Starting llvm::Module pass manager run.
 ; CHECK-O-NEXT: Running pass: PassManager<{{.*}}Module{{.*}}>
 ; CHECK-O-NEXT: Starting llvm::Module pass manager run.
+; CHECK-O-NEXT: RequireAnalysisPass<llvm::DumpAccumulator, llvm::Module>
+; CHECK-O-NEXT: Running analysis: DumpAccumulator
 ; CHECK-O-NEXT: Running pass: ForceFunctionAttrsPass
 ; CHECK-EP-PIPELINE-START-NEXT: Running pass: NoOpModulePass
 ; CHECK-O-NEXT: Running pass: PassManager<{{.*}}Module{{.*}}>
 ; CHECK-O-NEXT: Starting llvm::Module pass manager run.
 ; CHECK-O-NEXT: Running pass: InferFunctionAttrsPass
 ; CHECK-O-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running analysis: PassInstrumentationAnalysis

llvm/tools/llvm-readobj/ObjDumper.h

public:
   virtual void printMachOSegment() { }
   virtual void printMachOIndirectSymbols() { }
   virtual void printMachOLinkerOptions() { }
 
   virtual void printStackMap() const = 0;
 
   void printSectionsAsString(const object::ObjectFile *Obj,
                              ArrayRef<std::string> Sections);
+  void printLLVMDumpSection(const object::ObjectFile *Obj);
   void printSectionsAsHex(const object::ObjectFile *Obj,
                           ArrayRef<std::string> Sections);
 
 protected:
   ScopedPrinter &W;
 
 private:
   virtual void printSymbols() {}

llvm/tools/llvm-readobj/ObjDumper.cpp

 /// This file implements ObjDumper.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ObjDumper.h"
 #include "Error.h"
 #include "llvm-readobj.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/Compression.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/LEB128.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <map>
 
 namespace llvm {
 
 static inline Error createError(const Twine &Msg) {
   return createStringError(object::object_error::parse_failed, Msg);
for (std::pair<unsigned, bool> S : SecIndices)
     if (!S.second)
       reportWarning(
           createError(formatv("could not find section {0}", S.first).str()),
           Obj->getFileName());
 
   return Ret;
 }
 
+void ObjDumper::printLLVMDumpSection(const object::ObjectFile *Obj) {
+  auto Sections = getSectionRefsByNameOrIndex(Obj, {".llvm_dump"});
+  if (Sections.size() != 1) {
+    reportWarning(createError(".llvm_dump section not found"),
+                  Obj->getFileName());
+    return;
+  }
+  auto Section = Sections[0];
+  StringRef SectionContent =
+      unwrapOrError(Obj->getFileName(), Section.getContents());
+
+  StringRef Current = SectionContent;
+  unsigned Read = 0;
+  auto ReadNumber = [&]() {
+    uint64_t V =
+        decodeULEB128(reinterpret_cast<const uint8_t *>(Current.data()), &Read);
+    Current = Current.substr(Read);
+    return V;
+  };
+  while (Current.size() > 0) {
+    uint64_t UncompressedSize = ReadNumber();
+    std::unique_ptr<char[]> Uncompressed(new char[UncompressedSize]);
+    uint64_t CompressedSize = ReadNumber();
+    if (CompressedSize > Current.size()) {
+      reportWarning(
+          createError(
+              "Expecting a larger compressed buffer than available data"),
+          Obj->getFileName());
+    }
+    if (auto E =
+            zlib::uncompress(Current, Uncompressed.get(), UncompressedSize)) {
+      reportWarning(createError("Error decompressing"), Obj->getFileName());
+    }
+    Current = Current.substr(CompressedSize);
+    StringRef Message(Uncompressed.get(), UncompressedSize);
+    W.startLine() << Message << "\n";
+  }
+}
+
 void ObjDumper::printSectionsAsString(const object::ObjectFile *Obj,
                                       ArrayRef<std::string> Sections) {
   bool First = true;
   for (object::SectionRef Section :
        getSectionRefsByNameOrIndex(Obj, Sections)) {
     StringRef SectionName =
         unwrapOrError(Obj->getFileName(), Section.getName());
 

llvm/tools/llvm-readobj/llvm-readobj.cpp

namespace opts {
 
   // -elf-output-style
   cl::opt<OutputStyleTy>
       Output("elf-output-style", cl::desc("Specify ELF dump style"),
              cl::values(clEnumVal(LLVM, "LLVM default style"),
                         clEnumVal(GNU, "GNU readelf style")),
              cl::init(LLVM));
 
+  // --llvm-dump
+  cl::opt<bool> LLVMDumpSection("llvm-dump", cl::desc("Print .llvm-dump"),
+                                cl::init(false));
+
   cl::extrahelp
       HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
 } // namespace opts
 
 static StringRef ToolName;
 
 namespace llvm {
 
static void dumpObject(const ObjectFile *Obj, ScopedPrinter &Writer,
   if (opts::DynRelocs)
     Dumper->printDynamicRelocations();
   if (opts::UnwindInfo)
     Dumper->printUnwindInfo();
   if (opts::Symbols || opts::DynamicSymbols)
     Dumper->printSymbols(opts::Symbols, opts::DynamicSymbols);
   if (!opts::StringDump.empty())
     Dumper->printSectionsAsString(Obj, opts::StringDump);
+  if (opts::LLVMDumpSection)
+    Dumper->printLLVMDumpSection(Obj);
   if (!opts::HexDump.empty())
     Dumper->printSectionsAsHex(Obj, opts::HexDump);
   if (opts::HashTable)
     Dumper->printHashTable();
   if (opts::GnuHashTable)
     Dumper->printGnuHashTable(Obj);
   if (opts::VersionInfo)
     Dumper->printVersionInfo();