[llvm-exegesis] Dump generated snippets in assembler form

[kpdev42]

Summary

Make possible to dump the generated snippet in a form suitable for
inspecting, editing and passing as --snippets-file to llvm-exegesis.

~~

Huawei RRI, OS Lab

llvm/docs/CommandGuide/llvm-exegesis.rst

.. option:: --analysis-override-benchmark-triple-and-cpu
   (specified via `-mtriple`/`-mcpu`), you can pass this flag.
 
 .. option:: --dump-object-to-disk=</path/to/file.o>
 
  If set, llvm-exegesis will dump the generated code to file. If multiple files
  are to be written, they will have names /path/to/file-OPCODE-REPETITOR.o with
  `-OPCODE` and `-REPETITOR` parts omitted if always the same.
 
+.. option:: --dump-snippet-file=</path/to/file.s>
+
+ If set, llvm-exegesis will dump the generated snippet (without any repetition
+ and prologue/epilog code) to an assembler file with the appropriate
+ `LLVM-EXEGESIS-LIVEIN` and `LLVM-EXEGESIS-DEFREG` directives. If multiple
+ files are to be written, they will have names /path/to/file-OPCODE.s.
+
 .. option:: --use-dummy-perf-counters
 
  If set, llvm-exegesis will not read any real performance counters and
  return a dummy value instead. This can be used to ensure a snippet doesn't
  crash when hardware performance counters are unavailable and for
  debugging :program:`llvm-exegesis` itself.
 
 EXIT STATUS
 -----------
 
 :program:`llvm-exegesis` returns 0 on success. Otherwise, an error message is
 printed to standard error, and the tool returns a non 0 value.

llvm/test/tools/llvm-exegesis/X86/latency/dump-snippet-file.s

+# This test requires -debug-only=... command line option.
+REQUIRES: asserts
+
+# Check that nothing is dumped if not requested.
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -opcode-name=ADDPSrr -benchmark-phase=assemble-measured-code 2>&1 \
+RUN: | FileCheck %s --check-prefix=CHECK-OFF
+
+# An assembler snippet is dumped at any phase if explicitly requested.
+# In the below examples, both snippets and yaml data are printed to stdout.
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-snippet-file=- -benchmark-phase=prepare-snippet -opcode-name=ADDPSrr 2>&1 \
+RUN: | FileCheck %s --implicit-check-not="Output file name is" --check-prefix=CHECK-STDOUT-ADDPSrr
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-snippet-file=- -benchmark-phase=prepare-and-assemble-snippet -opcode-name=ADDPSrr 2>&1 \
+RUN: | FileCheck %s --implicit-check-not="Output file name is" --check-prefix=CHECK-STDOUT-ADDPSrr
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-snippet-file=- -benchmark-phase=assemble-measured-code -opcode-name=ADDPSrr 2>&1 \
+RUN: | FileCheck %s --implicit-check-not="Output file name is" --check-prefix=CHECK-STDOUT-ADDPSrr
+
+# Output file names should be properly computed: they are affected by using multiple opcodes or
+# multiple configs per opcode but *not* multiple repetitors.
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-snippet-file=%t-snippet.s -benchmark-phase=prepare-snippet \
+RUN:               -opcode-name=ADDPSrr,ADDPDrr -repetition-mode=min 2>&1 \
+RUN: | FileCheck %s --implicit-check-not="Output file name is" --check-prefix=CHECK-FILE-ADDPSrr-ADDPDrr
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-snippet-file=%t-snippet.s -benchmark-phase=prepare-snippet \
+RUN:               -opcode-name=SETCCr -max-configs-per-opcode=3 -repetition-mode=min 2>&1 \
+RUN: | FileCheck %s --implicit-check-not="Output file name is" --check-prefix=CHECK-FILE-MANY-CONFIGS
+
+# "-" is a special case if writing multiple snippets.
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-snippet-file=- -benchmark-phase=prepare-snippet \
+RUN:               -opcode-name=ADDPSrr,ADDPDrr -repetition-mode=min 2>&1 \
+RUN: | FileCheck %s --implicit-check-not="Output file name is" --check-prefix=CHECK-STDOUT-ADDPSrr-ADDPDrr
+
+# Test that the dumped snippet can be loaded back by llvm-exegesis
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency \
+RUN:               -dump-snippet-file=%t-snippet.s -benchmark-phase=prepare-snippet \
+RUN:               -opcode-name=ADDPSrr
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency \
+RUN:               -snippets-file=%t-snippet.s -benchmark-phase=assemble-measured-code \
+RUN: | FileCheck %s --check-prefix=CHECK-RELOAD
+
+
+CHECK-OFF-NOT: Output file name is
+
+# Note: testing for *at least* one DEFREG XMM[0-9]+
+
+CHECK-STDOUT-ADDPSrr: Output file name is -
+CHECK-STDOUT-ADDPSrr: # LLVM-EXEGESIS-DEFREG XMM{{[0-9]+}} 0
+CHECK-STDOUT-ADDPSrr: # LLVM-EXEGESIS-DEFREG MXCSR 0
+CHECK-STDOUT-ADDPSrr: addps   %xmm{{[0-9]+}}, %xmm{{[0-9]+}}
+
+CHECK-FILE-ADDPSrr-ADDPDrr: Output file name is {{.*}}-snippet-ADDPSrr.s
+CHECK-FILE-ADDPSrr-ADDPDrr: Output file name is {{.*}}-snippet-ADDPDrr.s
+
+CHECK-FILE-MANY-CONFIGS: Output file name is {{.*}}-snippet-SETCCr.s
+CHECK-FILE-MANY-CONFIGS: Output file name is {{.*}}-snippet-SETCCr-1.s
+CHECK-FILE-MANY-CONFIGS: Output file name is {{.*}}-snippet-SETCCr-2.s
+
+CHECK-STDOUT-ADDPSrr-ADDPDrr: Output file name is -
+CHECK-STDOUT-ADDPSrr-ADDPDrr: # LLVM-EXEGESIS-DEFREG XMM{{[0-9]+}} 0
+CHECK-STDOUT-ADDPSrr-ADDPDrr: # LLVM-EXEGESIS-DEFREG MXCSR 0
+CHECK-STDOUT-ADDPSrr-ADDPDrr: addps   %xmm{{[0-9]+}}, %xmm{{[0-9]+}}
+CHECK-STDOUT-ADDPSrr-ADDPDrr: Output file name is -
+CHECK-STDOUT-ADDPSrr-ADDPDrr: # LLVM-EXEGESIS-DEFREG XMM{{[0-9]+}} 0
+CHECK-STDOUT-ADDPSrr-ADDPDrr: # LLVM-EXEGESIS-DEFREG MXCSR 0
+CHECK-STDOUT-ADDPSrr-ADDPDrr: addpd   %xmm{{[0-9]+}}, %xmm{{[0-9]+}}
+
+CHECK-RELOAD:      mode: latency
+CHECK-RELOAD-NEXT: key:
+CHECK-RELOAD-NEXT:   instructions:
+CHECK-RELOAD-NEXT:     - 'ADDPSrr {{.*}}'
+CHECK-RELOAD-NEXT:   config:          ''
+CHECK-RELOAD-NEXT:   register_initial_values:
+CHECK-RELOAD-NEXT:     - 'XMM{{[0-9]+}}=0x0'
+CHECK-RELOAD:          - 'MXCSR=0x0'
+CHECK-RELOAD:      assembled_snippet: {{[0-9A-F]+}}

llvm/tools/llvm-exegesis/lib/Analysis.h

private:
   std::vector<ResolvedSchedClassAndPoints> makePointsPerSchedClass() const;
 
   template <typename EscapeTag, EscapeTag Tag>
   void writeSnippet(raw_ostream &OS, ArrayRef<uint8_t> Bytes,
                     const char *Separator) const;
 
   const BenchmarkClustering &Clustering_;
   const LLVMState &State_;
-  std::unique_ptr<DisassemblerHelper> DisasmHelper_;
+  const DisassemblerHelper &DisasmHelper_;
   const double AnalysisInconsistencyEpsilonSquared_;
   const bool AnalysisDisplayUnstableOpcodes_;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_CLUSTERING_H

llvm/tools/llvm-exegesis/lib/Analysis.cpp

 template <typename EscapeTag, EscapeTag Tag>
 void Analysis::writeSnippet(raw_ostream &OS, ArrayRef<uint8_t> Bytes,
                             const char *Separator) const {
   SmallVector<std::string, 3> Lines;
   // Parse the asm snippet and print it.
   while (!Bytes.empty()) {
     MCInst MI;
     uint64_t MISize = 0;
-    if (!DisasmHelper_->decodeInst(MI, MISize, Bytes)) {
+    if (!DisasmHelper_.decodeInst(MI, MISize, Bytes)) {
       writeEscaped<Tag>(OS, join(Lines, Separator));
       writeEscaped<Tag>(OS, Separator);
       writeEscaped<Tag>(OS, "[error decoding asm snippet]");
       return;
     }
     SmallString<128> InstPrinterStr; // FIXME: magic number.
     raw_svector_ostream OSS(InstPrinterStr);
-    DisasmHelper_->printInst(&MI, OSS);
+    DisasmHelper_.printInst(&MI, OSS);
     Bytes = Bytes.drop_front(MISize);
     Lines.emplace_back(InstPrinterStr.str().trim());
   }
   writeEscaped<Tag>(OS, join(Lines, Separator));
 }
 
 // Prints a row representing an instruction, along with scheduling info and
 // point coordinates (measurements).
#endif
   OS << "\n";
 }
 
 Analysis::Analysis(const LLVMState &State,
                    const BenchmarkClustering &Clustering,
                    double AnalysisInconsistencyEpsilon,
                    bool AnalysisDisplayUnstableOpcodes)
     : Clustering_(Clustering), State_(State),
+      DisasmHelper_(State.getDisassemblerHelper()),
       AnalysisInconsistencyEpsilonSquared_(AnalysisInconsistencyEpsilon *
                                            AnalysisInconsistencyEpsilon),
-      AnalysisDisplayUnstableOpcodes_(AnalysisDisplayUnstableOpcodes) {
-  if (Clustering.getPoints().empty())
-    return;
-
-  DisasmHelper_ = std::make_unique<DisassemblerHelper>(State);
-}
+      AnalysisDisplayUnstableOpcodes_(AnalysisDisplayUnstableOpcodes) {}
 
 template <>
 Error Analysis::run<Analysis::PrintClusters>(raw_ostream &OS) const {
   if (Clustering_.getPoints().empty())
     return Error::success();
 
   // Write the header.
   OS << "cluster_id" << kCsvSep << "opcode_name" << kCsvSep << "config"

llvm/tools/llvm-exegesis/lib/DisassemblerHelper.h

 /// Helper class for decoding machine instructions and printing them in an
 /// assembler form.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_DISASSEMBLER_HELPER_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_DISASSEMBLER_HELPER_H
 
-#include "LlvmState.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCInstPrinter.h"
 
 #include <memory>
 
 namespace llvm {
+class TargetMachine;
+} // namespace llvm
+
+namespace llvm {
 namespace exegesis {
 
 // A helper class for decoding and printing machine instructions.
 class DisassemblerHelper {
 public:
-  DisassemblerHelper(const LLVMState &State);
+  DisassemblerHelper(const TargetMachine &TM);
 
   void printInst(const MCInst *MI, raw_ostream &OS) const {
-    const auto &STI = State_.getSubtargetInfo();
-    InstPrinter_->printInst(MI, 0, "", STI, OS);
+    InstPrinter_->printInst(MI, 0, "", STI_, OS);
   }
 
   bool decodeInst(MCInst &MI, uint64_t &MISize, ArrayRef<uint8_t> Bytes) const {
     return Disasm_->getInstruction(MI, MISize, Bytes, 0, nulls());
   }
 
 private:
-  const LLVMState &State_;
+  const MCSubtargetInfo &STI_;
   std::unique_ptr<MCContext> Context_;
   std::unique_ptr<MCAsmInfo> AsmInfo_;
   std::unique_ptr<MCInstPrinter> InstPrinter_;
   std::unique_ptr<MCDisassembler> Disasm_;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_DISASSEMBLER_HELPER_H

llvm/tools/llvm-exegesis/lib/DisassemblerHelper.cpp

 //===-- DisassemblerHelper.cpp ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DisassemblerHelper.h"
 
 #include "llvm/MC/TargetRegistry.h"
+#include "llvm/Target/TargetMachine.h"
 
 namespace llvm {
 namespace exegesis {
 
-DisassemblerHelper::DisassemblerHelper(const LLVMState &State) : State_(State) {
+DisassemblerHelper::DisassemblerHelper(const TargetMachine &TM)
+    : STI_(*TM.getMCSubtargetInfo()) {
   MCTargetOptions MCOptions;
-  const auto &TM = State.getTargetMachine();
+  const auto &RegInfo = *TM.getMCRegisterInfo();
+  const auto &InstrInfo = *TM.getMCInstrInfo();
   const auto &Triple = TM.getTargetTriple();
-  AsmInfo_.reset(TM.getTarget().createMCAsmInfo(State_.getRegInfo(),
-                                                Triple.str(), MCOptions));
+  AsmInfo_.reset(
+      TM.getTarget().createMCAsmInfo(RegInfo, Triple.str(), MCOptions));
   InstPrinter_.reset(TM.getTarget().createMCInstPrinter(
-      Triple, 0 /*default variant*/, *AsmInfo_, State_.getInstrInfo(),
-      State_.getRegInfo()));
+      Triple, 0 /*default variant*/, *AsmInfo_, InstrInfo, RegInfo));
 
-  Context_ = std::make_unique<MCContext>(
-      Triple, AsmInfo_.get(), &State_.getRegInfo(), &State_.getSubtargetInfo());
-  Disasm_.reset(TM.getTarget().createMCDisassembler(State_.getSubtargetInfo(),
-                                                    *Context_));
+  Context_ =
+      std::make_unique<MCContext>(Triple, AsmInfo_.get(), &RegInfo, &STI_);
+  Disasm_.reset(TM.getTarget().createMCDisassembler(STI_, *Context_));
   assert(Disasm_ && "cannot create MCDisassembler. missing call to "
                     "InitializeXXXTargetDisassembler ?");
 }
 
 } // namespace exegesis
 } // namespace llvm

llvm/tools/llvm-exegesis/lib/FileNameGenerator.h

public:
   bool isEnabled() const { return IsEnabled; }
 
 private:
   FileNameGenerator(StringRef FileName, ArrayRef<bool> IsVariableInfix);
 
   std::string getFileName(ArrayRef<StringRef> Infixes) const;
 
   bool IsEnabled;
+  bool IsSingleDash;
   std::string FileNamePrefix;
   std::string FileNameSuffix;
   SmallVector<bool, 2> IsVariableInfix;
 
 #ifndef NDEBUG
   // Infixes passed to the first getFileName() call.
   mutable SmallVector<std::string, 2> FirstInfixes;
 #endif
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_FILE_NAME_GENERATOR_H

llvm/tools/llvm-exegesis/lib/FileNameGenerator.cpp

 
 namespace llvm {
 namespace exegesis {
 
 FileNameGenerator::FileNameGenerator(StringRef FileName,
                                      ArrayRef<bool> IsVariableInfix)
     : IsVariableInfix(IsVariableInfix) {
   IsEnabled = !FileName.empty();
-  if (!IsEnabled)
+  IsSingleDash = FileName == "-";
+  if (!IsEnabled || IsSingleDash)
     return;
 
   size_t DotPosition = FileName.rfind('.');
   size_t SlashPosition = FileName.find_last_of("/\\");
 
   if (DotPosition == StringRef::npos ||
       (SlashPosition != StringRef::npos && DotPosition < SlashPosition)) {
     // Two corner cases:
     // 1) "/path/to/file" - no dots at all
     // 2) "/dir/another_dir.ext/file" - the rightmost dot is in directory name
     FileNamePrefix = FileName;
     FileNameSuffix = "";
   } else {
     // "/path/to/file.ext" -> "/path/to/file", ".ext"
     FileNamePrefix = FileName.take_front(DotPosition);
     FileNameSuffix = FileName.drop_front(DotPosition);
   }
 }
 
 std::string FileNameGenerator::getFileName(ArrayRef<StringRef> Infixes) const {
   SmallVector<StringRef, 3> Parts;
 
+  if (IsSingleDash) {
+    LLVM_DEBUG(errs() << "Output file name is -\n");
+    return "-";
+  }
+
   Parts.push_back(FileNamePrefix);
   for (unsigned I = 0, N = IsVariableInfix.size(); I < N; ++I)
     if (IsVariableInfix[I])
       Parts.push_back(Infixes[I]);
 
 #ifndef NDEBUG
   if (FirstInfixes.empty())
     FirstInfixes.assign(Infixes.begin(), Infixes.end());

llvm/tools/llvm-exegesis/lib/LlvmState.h

 //===-- LlvmState.h ---------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// A class to set up and access common LLVM objects.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_LLVMSTATE_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_LLVMSTATE_H
 
+#include "DisassemblerHelper.h"
 #include "MCInstrDescView.h"
 #include "RegisterAliasing.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
const DenseMap<StringRef, unsigned> &getOpcodeNameToOpcodeIdxMapping() const {
     return *OpcodeNameToOpcodeIdxMapping;
   };
 
   const DenseMap<StringRef, unsigned> &getRegNameToRegNoMapping() const {
     assert(RegNameToRegNoMapping);
     return *RegNameToRegNoMapping;
   }
 
+  const DisassemblerHelper &getDisassemblerHelper() const {
+    return *DisasmHelper;
+  }
+
 private:
   std::unique_ptr<const DenseMap<StringRef, unsigned>>
   createOpcodeNameToOpcodeIdxMapping() const;
 
   std::unique_ptr<const DenseMap<StringRef, unsigned>>
   createRegNameToRegNoMapping() const;
 
   LLVMState(std::unique_ptr<const TargetMachine> TM, const ExegesisTarget *ET,
             const PfmCountersInfo *PCI);
 
   const ExegesisTarget *TheExegesisTarget;
   std::unique_ptr<const TargetMachine> TheTargetMachine;
   std::unique_ptr<const RegisterAliasingTrackerCache> RATC;
   std::unique_ptr<const InstructionsCache> IC;
   const PfmCountersInfo *PfmCounters;
   std::unique_ptr<const DenseMap<StringRef, unsigned>>
       OpcodeNameToOpcodeIdxMapping;
   std::unique_ptr<const DenseMap<StringRef, unsigned>> RegNameToRegNoMapping;
+  std::unique_ptr<const DisassemblerHelper> DisasmHelper;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_LLVMSTATE_H

llvm/tools/llvm-exegesis/lib/LlvmState.cpp

: TheExegesisTarget(ET), TheTargetMachine(std::move(TM)), PfmCounters(PCI),
       OpcodeNameToOpcodeIdxMapping(createOpcodeNameToOpcodeIdxMapping()),
       RegNameToRegNoMapping(createRegNameToRegNoMapping()) {
   BitVector ReservedRegs = getFunctionReservedRegs(getTargetMachine());
   for (const unsigned Reg : TheExegesisTarget->getUnavailableRegisters())
     ReservedRegs.set(Reg);
   RATC.reset(
       new RegisterAliasingTrackerCache(getRegInfo(), std::move(ReservedRegs)));
   IC.reset(new InstructionsCache(getInstrInfo(), getRATC()));
+
+  DisasmHelper.reset(new DisassemblerHelper(*TheTargetMachine));
 }
 
 std::unique_ptr<LLVMTargetMachine> LLVMState::createTargetMachine() const {
   return std::unique_ptr<LLVMTargetMachine>(static_cast<LLVMTargetMachine *>(
       TheTargetMachine->getTarget().createTargetMachine(
           TheTargetMachine->getTargetTriple().normalize(),
           TheTargetMachine->getTargetCPU(),
           TheTargetMachine->getTargetFeatureString(), TheTargetMachine->Options,

llvm/tools/llvm-exegesis/llvm-exegesis.cpp

TripleName("mtriple",
                cl::desc("Target triple. See -version for available targets"),
                cl::cat(Options));
 
 static cl::opt<std::string>
     MCPU("mcpu",
          cl::desc("Target a specific cpu type (-mcpu=help for details)"),
          cl::value_desc("cpu-name"), cl::cat(Options), cl::init("native"));
 
+static cl::opt<std::string> DumpSnippetFile(
+    "dump-snippet-file",
+    cl::desc("Dump generated snippet to assembler file (opcode name is "
+             "inserted if writing multiple files). \"-\" uses stdout."),
+    cl::cat(BenchmarkOptions), cl::init(""));
+
 static cl::opt<std::string> DumpObjectToDisk(
     "dump-object-to-disk",
     cl::desc("Dump generated benchmark object to file (opcode and repetitor "
              "names are inserted if writing mupliple files)"),
     cl::cat(BenchmarkOptions), cl::init(""));
 
 static ExitOnError ExitOnErr("llvm-exegesis error: ");
 
static SmallString<16> formatOpcodeLabel(const MCInstrInfo &MCII,
   // It is likely to have only a single configuration per opcode, so handle
   // Index == 0 differently and return just "OPC" instead of "OPC-0".
   if (Key.Index == 0)
     return OpcodeName;
 
   return formatv("{0}-{1}", OpcodeName, Key.Index);
 }
 
+static void dumpAsmSnippet(const LLVMState &State, const BenchmarkCode &BC,
+                           const StringRef DumpFileName) {
+  std::error_code EC;
+  raw_fd_ostream OFS(DumpFileName, EC);
+  ExitOnFileError(DumpFileName, errorCodeToError(EC));
+
+  const auto &RegInfo = State.getRegInfo();
+  for (const RegisterValue &RV : BC.Key.RegisterInitialValues) {
+    OFS << "# LLVM-EXEGESIS-DEFREG " << RegInfo.getName(RV.Register) << " "
+        << formatv("{0:X}", RV.Value) << "\n";
+  }
+  for (unsigned LI : BC.LiveIns) {
+    OFS << "# LLVM-EXEGESIS-LIVEIN " << RegInfo.getName(LI) << "\n";
+  }
+
+  const auto &DisasmHelper = State.getDisassemblerHelper();
+  for (auto &MI : BC.Key.Instructions) {
+    DisasmHelper.printInst(&MI, OFS);
+    OFS << "\n";
+  }
+
+  OFS.flush();
+  ExitOnFileError(DumpFileName, errorCodeToError(OFS.error()));
+}
+
 static void dumpObjectFile(const StringRef Buffer,
                            const StringRef DumpFileName) {
   std::error_code EC;
   raw_fd_ostream OFS(DumpFileName, EC);
   ExitOnFileError(DumpFileName, errorCodeToError(EC));
   OFS.write(Buffer.data(), Buffer.size());
   OFS.flush();
   ExitOnFileError(DumpFileName, errorCodeToError(OFS.error()));
ExitOnErr(errorCodeToError(openFileForWrite(BenchmarkFile, ResultFD,
                                                 sys::fs::CD_CreateAlways,
                                                 sys::fs::OF_TextWithCRLF)));
     FileOstr.emplace(ResultFD, true /*shouldClose*/);
   }
   raw_ostream &Ostr = FileOstr ? *FileOstr : outs();
 
   bool ManyConfigurations = Configurations.size() > 1;
   bool ManyRepetitors = Repetitors.size() > 1;
+  FileNameGenerator SnippetFileName(DumpSnippetFile, ManyConfigurations, false);
   FileNameGenerator DumpedObjectName(DumpObjectToDisk, ManyConfigurations,
                                      ManyRepetitors);
 
   std::optional<ProgressMeter<>> Meter;
   if (BenchmarkMeasurementsPrintProgress)
     Meter.emplace(Configurations.size());
   for (const BenchmarkCode &Conf : Configurations) {
     ProgressMeter<>::ProgressMeterStep MeterStep(Meter ? &*Meter : nullptr);
     SmallVector<Benchmark, 2> AllResults;
 
     const auto OpcodeLabel = formatOpcodeLabel(MCII, Conf.Key);
+    if (SnippetFileName.isEnabled())
+      dumpAsmSnippet(State, Conf, SnippetFileName.getFileName(OpcodeLabel, ""));
 
     for (const std::unique_ptr<const SnippetRepetitor> &Repetitor :
          Repetitors) {
       auto RC = ExitOnErr(Runner.getRunnableConfiguration(
           Conf, NumRepetitions, LoopBodySize, *Repetitor));
 
       if (BenchmarkPhaseSelector >=
               BenchmarkPhaseSelectorE::AssembleMeasuredCode &&
ExitWithError(
         "--use-dummy-perf-counters to not query the kernel for real event "
         "counts.");
 #else
     if (exegesis::pfm::pfmInitialize())
       ExitWithError("cannot initialize libpfm");
 #endif
   }
 
-  InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
   InitializeAllExegesisTargets();
 
   const LLVMState State =
       ExitOnErr(LLVMState::Create(TripleName, MCPU, "", UseDummyPerfCounters));
 
   // Preliminary check to ensure features needed for requested
   // benchmark mode are present on target CPU and/or OS.
static void analysisMain() {
 
   if (AnalysisClustersOutputFile.empty() &&
       AnalysisInconsistenciesOutputFile.empty()) {
     ExitWithError(
         "for --mode=analysis: At least one of --analysis-clusters-output-file "
         "and --analysis-inconsistencies-output-file must be specified");
   }
 
-  InitializeAllAsmPrinters();
-  InitializeAllDisassemblers();
   InitializeAllExegesisTargets();
 
   auto MemoryBuffer = ExitOnFileError(
       BenchmarkFile,
       errorOrToExpected(MemoryBuffer::getFile(BenchmarkFile, /*IsText=*/true)));
 
   const auto TriplesAndCpus = ExitOnFileError(
       BenchmarkFile,
int main(int Argc, char **Argv) {
   using namespace llvm;
 
   InitLLVM X(Argc, Argv);
 
   // Initialize targets so we can print them when flag --version is specified.
   InitializeAllTargetInfos();
   InitializeAllTargets();
   InitializeAllTargetMCs();
+  InitializeAllAsmPrinters();
+  InitializeAllDisassemblers();
 
   // Register the Target and CPU printer for --version.
   cl::AddExtraVersionPrinter(sys::printDefaultTargetAndDetectedCPU);
 
   // Enable printing of available targets when flag --version is specified.
   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
 
   cl::HideUnrelatedOptions({&llvm::exegesis::Options,

llvm/unittests/tools/llvm-exegesis/AArch64/TargetTest.cpp

AArch64TargetTest()
     STI_.reset(
         Target_->createMCSubtargetInfo(kTriple, "generic", /*no features*/ ""));
   }
 
   static void SetUpTestCase() {
     LLVMInitializeAArch64TargetInfo();
     LLVMInitializeAArch64Target();
     LLVMInitializeAArch64TargetMC();
+    LLVMInitializeAArch64AsmPrinter();
+    LLVMInitializeAArch64Disassembler();
     InitializeAArch64ExegesisTarget();
   }
 
   std::vector<MCInst> setRegTo(unsigned Reg, const APInt &Value) {
     return ExegesisTarget_->setRegTo(*STI_, Reg, Value);
   }
 
   const Target *Target_;

llvm/unittests/tools/llvm-exegesis/ARM/AssemblerTest.cpp

protected:
   ARMMachineFunctionGeneratorTest()
       : MachineFunctionGeneratorBaseTest("armv7-none-linux-gnueabi", "") {}
 
   static void SetUpTestCase() {
     LLVMInitializeARMTargetInfo();
     LLVMInitializeARMTargetMC();
     LLVMInitializeARMTarget();
     LLVMInitializeARMAsmPrinter();
+    LLVMInitializeARMDisassembler();
   }
 };
 
 TEST_F(ARMMachineFunctionGeneratorTest, DISABLED_JitFunction) {
   Check({}, MCInst(), 0x1e, 0xff, 0x2f, 0xe1);
 }
 
 TEST_F(ARMMachineFunctionGeneratorTest, DISABLED_JitFunctionADDrr) {

llvm/unittests/tools/llvm-exegesis/Mips/TestBase.h

 protected:
   MipsTestBase()
       : State(cantFail(LLVMState::Create("mips-unknown-linux", "mips32"))) {}
 
   static void SetUpTestCase() {
     LLVMInitializeMipsTargetInfo();
     LLVMInitializeMipsTargetMC();
     LLVMInitializeMipsTarget();
+    LLVMInitializeMipsAsmPrinter();
+    LLVMInitializeMipsDisassembler();
     InitializeMipsExegesisTarget();
   }
 
   const LLVMState State;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif

llvm/unittests/tools/llvm-exegesis/PowerPC/TestBase.h

protected:
   PPCTestBase()
       : State(cantFail(
             LLVMState::Create("powerpc64le-unknown-linux", "ppc64le"))) {}
 
   static void SetUpTestCase() {
     LLVMInitializePowerPCTargetInfo();
     LLVMInitializePowerPCTargetMC();
     LLVMInitializePowerPCTarget();
+    LLVMInitializePowerPCAsmPrinter();
+    LLVMInitializePowerPCDisassembler();
     InitializePowerPCExegesisTarget();
   }
 
   const LLVMState State;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif

llvm/unittests/tools/llvm-exegesis/X86/BenchmarkResultTest.cpp

 }
 
 namespace {
 
 TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
   LLVMInitializeX86TargetInfo();
   LLVMInitializeX86Target();
   LLVMInitializeX86TargetMC();
+  LLVMInitializeX86AsmPrinter();
+  LLVMInitializeX86Disassembler();
   InitializeX86ExegesisTarget();
 
   // Read benchmarks.
   const LLVMState State =
       cantFail(LLVMState::Create("x86_64-unknown-linux", "haswell"));
 
   ExitOnError ExitOnErr;
 

llvm/unittests/tools/llvm-exegesis/X86/TestBase.h

X86TestBase()
       : State(cantFail(LLVMState::Create("x86_64-unknown-linux", "haswell"))) {}
 
   static void SetUpTestCase() {
     LLVMInitializeX86TargetInfo();
     LLVMInitializeX86TargetMC();
     LLVMInitializeX86Target();
     LLVMInitializeX86AsmPrinter();
     LLVMInitializeX86AsmParser();
+    LLVMInitializeX86Disassembler();
     InitializeX86ExegesisTarget();
   }
 
   const LLVMState State;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif