[llvm-exegesis] Print the whole snippet in analysis.

[courbet]

Summary

On hover, the whole asm snippet is displayed, including operands.

This requires the actual assembly output instead of just the MCInsts:
This is because some pseudo-instructions get lowered to actual target
instructions during codegen (e.g. ABS_Fp32 -> SSE or X87).

[courbet]

clang-format

[gchatelet]

tools/llvm-exegesis/lib/Analysis.cpp

94

Why not a llvm::SmallVector<llvm::SmallString<16>, 3> ?

110

as discussed please use drop_front() which is more self explanatory.

tools/llvm-exegesis/lib/Analysis.h

56

[nit] as discussed you may want to use a pointer here to make it clear that llvm::MCSchedClassDesc is immutable.

tools/llvm-exegesis/lib/BenchmarkResult.cpp

178

You may use the YAML Normalization https://llvm.org/docs/YamlIO.html#normalization

[courbet]

address review comments

[gchatelet]

tools/llvm-exegesis/lib/Analysis.cpp

94

Ping?

[courbet]

tools/llvm-exegesis/lib/Analysis.cpp

94

llvm::join is not nicely compatible with SmallString.

tools/llvm-exegesis/lib/Analysis.h

 /// Analysis output for benchmark results.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_ANALYSIS_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_ANALYSIS_H
 
 #include "Clustering.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCDisassembler/MCDisassembler.h"
+#include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
+#include <memory>
 #include <set>
 #include <string>
 #include <unordered_map>
 
 namespace exegesis {
 
 // A helper class to analyze benchmark results for a target.
 class Analysis {

 private:
   using ClusterId = InstructionBenchmarkClustering::ClusterId;
 
   // An llvm::MCSchedClassDesc augmented with some additional data.
   struct SchedClass {
     SchedClass(const llvm::MCSchedClassDesc &SD,
                const llvm::MCSubtargetInfo &STI);
 
-    const llvm::MCSchedClassDesc &SCDesc;
+    const llvm::MCSchedClassDesc *const SCDesc;
     const llvm::SmallVector<llvm::MCWriteProcResEntry, 8>
         NonRedundantWriteProcRes;
     const std::vector<std::pair<uint16_t, float>> IdealizedProcResPressure;
   };
 
   // Represents the intersection of a sched class and a cluster.
   class SchedClassCluster {
   public:
private:
   void printSchedClassDescHtml(const SchedClass &SC,
                                llvm::raw_ostream &OS) const;
 
   // Builds a map of Sched Class -> indices of points that belong to the sched
   // class.
   std::unordered_map<unsigned, std::vector<size_t>>
   makePointsPerSchedClass() const;
 
+  template <typename EscapeTag, EscapeTag Tag>
+  void writeSnippet(llvm::raw_ostream &OS, llvm::ArrayRef<uint8_t> Bytes,
+                    const char *Separator) const;
+
   const InstructionBenchmarkClustering &Clustering_;
+  llvm::MCObjectFileInfo ObjectFileInfo_;
+  std::unique_ptr<llvm::MCContext> Context_;
   std::unique_ptr<llvm::MCSubtargetInfo> SubtargetInfo_;
   std::unique_ptr<llvm::MCInstrInfo> InstrInfo_;
+  std::unique_ptr<llvm::MCRegisterInfo> RegInfo_;
+  std::unique_ptr<llvm::MCAsmInfo> AsmInfo_;
+  std::unique_ptr<llvm::MCInstPrinter> InstPrinter_;
+  std::unique_ptr<llvm::MCDisassembler> Disasm_;
   std::unordered_map<std::string, unsigned> MnemonicToOpcode_;
 };
 
 // Computes the idealized ProcRes Unit pressure. This is the expected
 // distribution if the CPU scheduler can distribute the load as evenly as
 // possible.
 std::vector<std::pair<uint16_t, float>> computeIdealizedProcResPressure(
     const llvm::MCSchedModel &SM,
     llvm::SmallVector<llvm::MCWriteProcResEntry, 8> WPRS);
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_CLUSTERING_H

tools/llvm-exegesis/lib/Analysis.cpp

 //===-- Analysis.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Analysis.h"
 #include "BenchmarkResult.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/MC/MCAsmInfo.h"
 #include "llvm/Support/FormatVariadic.h"
 #include <unordered_set>
 #include <vector>
 
 namespace exegesis {
 
 static const char kCsvSep = ',';
 
for (const char C : S) {
     else if (C == '&')
       OS << "&amp;";
     else
       OS << C;
   }
 }
 
 template <>
-void writeEscaped<kEscapeHtmlString>(llvm::raw_ostream &OS, const llvm::StringRef S) {
+void writeEscaped<kEscapeHtmlString>(llvm::raw_ostream &OS,
+                                     const llvm::StringRef S) {
   for (const char C : S) {
     if (C == '"')
       OS << "\\\"";
     else
       OS << C;
   }
 }
 
else
     OS << CID.getId();
 }
 
 template <EscapeTag Tag>
 static void writeMeasurementValue(llvm::raw_ostream &OS, const double Value) {
   writeEscaped<Tag>(OS, llvm::formatv("{0:F}", Value).str());
 }
 
-template <EscapeTag Tag>
-static void writeSnippet(llvm::raw_ostream &OS,
-                         const std::vector<llvm::MCInst> &Instructions,
-                         const llvm::MCInstrInfo &InstrInfo,
-                         const char* Separator) {
-  // FIXME: Print operands.
-  llvm::SmallVector<llvm::StringRef, 3> Opcodes;
-  for (const llvm::MCInst &Instr : Instructions) {
-    Opcodes.push_back(InstrInfo.getName(Instr.getOpcode()));
+template <typename EscapeTag, EscapeTag Tag>
+void Analysis::writeSnippet(llvm::raw_ostream &OS,
+                            llvm::ArrayRef<uint8_t> Bytes,
+                            const char *Separator) const {
+  llvm::SmallVector<std::string, 3> Lines;
+  // Parse the asm snippet and print it.
+  while (!Bytes.empty()) {
+    llvm::MCInst MI;
+    uint64_t MISize = 0;
+    if (!Disasm_->getInstruction(MI, MISize, Bytes, 0, llvm::nulls(),
+                                 llvm::nulls())) {
+      writeEscaped<Tag>(OS, llvm::join(Lines, Separator));
+      writeEscaped<Tag>(OS, Separator);
+      writeEscaped<Tag>(OS, "[error decoding asm snippet]");
+      return;
     }
-  writeEscaped<Tag>(OS, llvm::join(Opcodes, Separator));
+    Lines.emplace_back();
+    std::string &Line = Lines.back();
+    llvm::raw_string_ostream OSS(Line);
+    InstPrinter_->printInst(&MI, OSS, "", *SubtargetInfo_);
+    Bytes = Bytes.drop_front(MISize);
+    OSS.flush();
+    Line = llvm::StringRef(Line).trim().str();
+  }
+  writeEscaped<Tag>(OS, llvm::join(Lines, Separator));
 }
 
 // Prints a row representing an instruction, along with scheduling info and
 // point coordinates (measurements).
 void Analysis::printInstructionRowCsv(const size_t PointId,
                                       llvm::raw_ostream &OS) const {
   const InstructionBenchmark &Point = Clustering_.getPoints()[PointId];
   writeClusterId<kEscapeCsv>(OS, Clustering_.getClusterIdForPoint(PointId));
   OS << kCsvSep;
-  writeSnippet<kEscapeCsv>(OS, Point.Key.Instructions, *InstrInfo_, "; ");
+  writeSnippet<EscapeTag, kEscapeCsv>(OS, Point.AssembledSnippet, "; ");
   OS << kCsvSep;
   writeEscaped<kEscapeCsv>(OS, Point.Key.Config);
   OS << kCsvSep;
   assert(!Point.Key.Instructions.empty());
   // FIXME: Resolve variant classes.
   const unsigned SchedClassId =
       InstrInfo_->get(Point.Key.Instructions[0].getOpcode()).getSchedClass();
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

 }
 
 Analysis::Analysis(const llvm::Target &Target,
                    const InstructionBenchmarkClustering &Clustering)
     : Clustering_(Clustering) {
   if (Clustering.getPoints().empty())
     return;
 
-  InstrInfo_.reset(Target.createMCInstrInfo());
   const InstructionBenchmark &FirstPoint = Clustering.getPoints().front();
+  InstrInfo_.reset(Target.createMCInstrInfo());
+  RegInfo_.reset(Target.createMCRegInfo(FirstPoint.LLVMTriple));
+  AsmInfo_.reset(Target.createMCAsmInfo(*RegInfo_, FirstPoint.LLVMTriple));
   SubtargetInfo_.reset(Target.createMCSubtargetInfo(FirstPoint.LLVMTriple,
                                                     FirstPoint.CpuName, ""));
+  InstPrinter_.reset(Target.createMCInstPrinter(
+      llvm::Triple(FirstPoint.LLVMTriple), 0 /*default variant*/, *AsmInfo_,
+      *InstrInfo_, *RegInfo_));
+
+  Context_ = llvm::make_unique<llvm::MCContext>(AsmInfo_.get(), RegInfo_.get(),
+                                                &ObjectFileInfo_);
+  Disasm_.reset(Target.createMCDisassembler(*SubtargetInfo_, *Context_));
+  assert(Disasm_ && "cannot create MCDisassembler. missing call to "
+                    "InitializeXXXTargetDisassembler ?");
 }
 
 template <>
 llvm::Error
 Analysis::run<Analysis::PrintClusters>(llvm::raw_ostream &OS) const {
   if (Clustering_.getPoints().empty())
     return llvm::Error::success();
 
if (Instructions.empty())
     return;
   writeEscaped<kEscapeHtml>(OS, InstrInfo.getName(Instructions[0].getOpcode()));
   if (Instructions.size() > 1)
     OS << " (x" << Instructions.size() << ")";
 }
 
 // Latency tries to find a serial path. Just show the opcode path and show the
 // whole snippet only on hover.
-static void writeLatencySnippetHtml(llvm::raw_ostream &OS,
-                                 const std::vector<llvm::MCInst> &Instructions,
-                                 const llvm::MCInstrInfo &InstrInfo) {
+static void
+writeLatencySnippetHtml(llvm::raw_ostream &OS,
   bool First = true;
   for (const llvm::MCInst &Instr : Instructions) {
     if (First)
       First = false;
     else
       OS << " &rarr; ";
     writeEscaped<kEscapeHtml>(OS, InstrInfo.getName(Instr.getOpcode()));
   }
OS << "<tr class=\""
                ? "good-cluster"
                : "bad-cluster")
        << "\"><td>";
     writeClusterId<kEscapeHtml>(OS, Cluster.id());
     OS << "</td><td><ul>";
     for (const size_t PointId : Cluster.getPointIds()) {
       const auto &Point = Points[PointId];
       OS << "<li><span class=\"mono\" title=\"";
-      writeSnippet<kEscapeHtmlString>(OS, Point.Key.Instructions, *InstrInfo_, "\n");
+      writeSnippet<EscapeTag, kEscapeHtmlString>(OS, Point.AssembledSnippet,
+                                                 "\n");
       OS << "\">";
       switch (Point.Mode) {
-        case InstructionBenchmark::Latency:
-          writeLatencySnippetHtml(OS, Point.Key.Instructions, *InstrInfo_);
-          break;
-        case InstructionBenchmark::Uops:
-          writeUopsSnippetHtml(OS, Point.Key.Instructions, *InstrInfo_);
-          break;
-        default:
-          llvm_unreachable("invalid mode");
       }
       OS << "</span> <span class=\"mono\">";
       writeEscaped<kEscapeHtml>(OS, Point.Key.Config);
       OS << "</span></li>";
     }
     OS << "</ul></td>";
     for (const auto &Stats : Cluster.getRepresentative()) {
       OS << "<td class=\"measurement\">";
if (ProcResDesc->SubUnitsIdxBegin == nullptr) {
       }
     }
   }
   return Result;
 }
 
 Analysis::SchedClass::SchedClass(const llvm::MCSchedClassDesc &SD,
                                  const llvm::MCSubtargetInfo &STI)
-    : SCDesc(SD),
+    : SCDesc(&SD),
       NonRedundantWriteProcRes(getNonRedundantWriteProcRes(SD, STI)),
       IdealizedProcResPressure(computeIdealizedProcResPressure(
           STI.getSchedModel(), NonRedundantWriteProcRes)) {}
 
 void Analysis::SchedClassCluster::addPoint(
     size_t PointId, const InstructionBenchmarkClustering &Clustering) {
   PointIds.push_back(PointId);
   const auto &Point = Clustering.getPoints()[PointId];
if (Mode == InstructionBenchmark::Latency) {
     if (NumMeasurements != 1) {
       llvm::errs()
           << "invalid number of measurements in latency mode: expected 1, got "
           << NumMeasurements << "\n";
       return false;
     }
     // Find the latency.
     SchedClassPoint[0].Value = 0.0;
-    for (unsigned I = 0; I < SC.SCDesc.NumWriteLatencyEntries; ++I) {
+    for (unsigned I = 0; I < SC.SCDesc->NumWriteLatencyEntries; ++I) {
       const llvm::MCWriteLatencyEntry *const WLE =
-          STI.getWriteLatencyEntry(&SC.SCDesc, I);
+          STI.getWriteLatencyEntry(SC.SCDesc, I);
       SchedClassPoint[0].Value =
           std::max<double>(SchedClassPoint[0].Value, WLE->Cycles);
     }
     ClusterCenterPoint[0].Value = Representative[0].avg();
   } else if (Mode == InstructionBenchmark::Uops) {
     for (int I = 0, E = Representative.size(); I < E; ++I) {
       // Find the pressure on ProcResIdx `Key`.
       uint16_t ProcResIdx = 0;

 
 void Analysis::printSchedClassDescHtml(const SchedClass &SC,
                                        llvm::raw_ostream &OS) const {
   OS << "<table class=\"sched-class-desc\">";
   OS << "<tr><th>Valid</th><th>Variant</th><th>uOps</th><th>Latency</"
         "th><th>WriteProcRes</th><th title=\"This is the idealized unit "
         "resource (port) pressure assuming ideal distribution\">Idealized "
         "Resource Pressure</th></tr>";
-  if (SC.SCDesc.isValid()) {
+  if (SC.SCDesc->isValid()) {
     const auto &SM = SubtargetInfo_->getSchedModel();
     OS << "<tr><td>&#10004;</td>";
-    OS << "<td>" << (SC.SCDesc.isVariant() ? "&#10004;" : "&#10005;")
+    OS << "<td>" << (SC.SCDesc->isVariant() ? "&#10004;" : "&#10005;")
        << "</td>";
-    OS << "<td>" << SC.SCDesc.NumMicroOps << "</td>";
+    OS << "<td>" << SC.SCDesc->NumMicroOps << "</td>";
     // Latencies.
     OS << "<td><ul>";
-    for (int I = 0, E = SC.SCDesc.NumWriteLatencyEntries; I < E; ++I) {
+    for (int I = 0, E = SC.SCDesc->NumWriteLatencyEntries; I < E; ++I) {
       const auto *const Entry =
-          SubtargetInfo_->getWriteLatencyEntry(&SC.SCDesc, I);
+          SubtargetInfo_->getWriteLatencyEntry(SC.SCDesc, I);
       OS << "<li>" << Entry->Cycles;
-      if (SC.SCDesc.NumWriteLatencyEntries > 1) {
+      if (SC.SCDesc->NumWriteLatencyEntries > 1) {
         // Dismabiguate if more than 1 latency.
         OS << " (WriteResourceID " << Entry->WriteResourceID << ")";
       }
       OS << "</li>";
     }
     OS << "</ul></td>";
     // WriteProcRes.
     OS << "<td><ul>";

tools/llvm-exegesis/lib/BenchmarkResult.h

struct InstructionBenchmark {
   enum ModeE { Unknown, Latency, Uops };
   ModeE Mode;
   std::string CpuName;
   std::string LLVMTriple;
   int NumRepetitions = 0;
   std::vector<BenchmarkMeasure> Measurements;
   std::string Error;
   std::string Info;
+  std::vector<uint8_t> AssembledSnippet;
 
   // Read functions.
   static llvm::Expected<InstructionBenchmark>
   readYaml(const BenchmarkResultContext &Context, llvm::StringRef Filename);
 
   static llvm::Expected<std::vector<InstructionBenchmark>>
   readYamls(const BenchmarkResultContext &Context, llvm::StringRef Filename);
 

tools/llvm-exegesis/lib/BenchmarkResult.cpp

 //===-- BenchmarkResult.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "BenchmarkResult.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ObjectYAML/YAML.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 static constexpr const char kIntegerFormat[] = "i_0x%" PRId64 "x";
 static constexpr const char kDoubleFormat[] = "f_%la";
 

 template <> struct MappingTraits<exegesis::InstructionBenchmarkKey> {
   static void mapping(IO &Io, exegesis::InstructionBenchmarkKey &Obj) {
     Io.mapRequired("instructions", Obj.Instructions);
     Io.mapOptional("config", Obj.Config);
   }
 };
 
 template <> struct MappingTraits<exegesis::InstructionBenchmark> {
+  class NormalizedBinary {
+  public:
+    NormalizedBinary(IO &io) {}
+    NormalizedBinary(IO &, std::vector<uint8_t> &Data) : Binary(Data) {}
+    std::vector<uint8_t> denormalize(IO &) {
+      std::vector<uint8_t> Data;
+      std::string Str;
+      raw_string_ostream OSS(Str);
+      Binary.writeAsBinary(OSS);
+      OSS.flush();
+      Data.assign(Str.begin(), Str.end());
+      return Data;
+    }
+
+    BinaryRef Binary;
+  };
+
   static void mapping(IO &Io, exegesis::InstructionBenchmark &Obj) {
     Io.mapRequired("mode", Obj.Mode);
     Io.mapRequired("key", Obj.Key);
     Io.mapRequired("cpu_name", Obj.CpuName);
     Io.mapRequired("llvm_triple", Obj.LLVMTriple);
     Io.mapRequired("num_repetitions", Obj.NumRepetitions);
     Io.mapRequired("measurements", Obj.Measurements);
     Io.mapRequired("error", Obj.Error);
     Io.mapOptional("info", Obj.Info);
+    // AssembledSnippet
+    MappingNormalization<NormalizedBinary, std::vector<uint8_t>> BinaryString(
+        Io, Obj.AssembledSnippet);
+    Io.mapOptional("assembled_snippet", BinaryString->Binary);
   }
 };
 
 } // namespace yaml
 } // namespace llvm
 
 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(exegesis::InstructionBenchmark)
 

tools/llvm-exegesis/lib/BenchmarkRunner.h

private:
   createConfigurations(unsigned Opcode) const = 0;
 
   virtual std::vector<BenchmarkMeasure>
   runMeasurements(const ExecutableFunction &EF,
                   const unsigned NumRepetitions) const = 0;
 
   llvm::Expected<std::string>
   writeObjectFile(llvm::ArrayRef<llvm::MCInst> Code) const;
+  llvm::Expected<ExecutableFunction>
+  createExecutableFunction(llvm::ArrayRef<llvm::MCInst> Code) const;
 };
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRUNNER_H

tools/llvm-exegesis/lib/BenchmarkRunner.cpp

BenchmarkRunner::runOne(const BenchmarkConfiguration &Configuration,
   InstrBenchmark.Info = Configuration.Info;
 
   const std::vector<llvm::MCInst> &Snippet = Configuration.Snippet;
   if (Snippet.empty()) {
     InstrBenchmark.Error = "Empty snippet";
     return InstrBenchmark;
   }
 
-  for (const auto &MCInst : Snippet)
-    InstrBenchmark.Key.Instructions.push_back(MCInst);
+  InstrBenchmark.Key.Instructions = Snippet;
 
-  std::vector<llvm::MCInst> Code;
-  for (int I = 0; I < InstrBenchmark.NumRepetitions; ++I)
+  // Repeat the snippet until there are at least NumInstructions in the
+  // resulting code. The snippet is always repeated at least once.
+  const auto GenerateInstructions = [&Snippet](const int MinInstructions) {
+    std::vector<llvm::MCInst> Code = Snippet;
+    for (int I = 0; I < MinInstructions; ++I)
       Code.push_back(Snippet[I % Snippet.size()]);
+    return Code;
+  };
 
-  auto ExpectedObjectPath = writeObjectFile(Code);
-  if (llvm::Error E = ExpectedObjectPath.takeError()) {
+  // Assemble at least kMinInstructionsForSnippet instructions by repeating the
+  // snippet for debug/analysis. This is so that the user clearly understands
+  // that the inside instructions are repeated.
+  constexpr const int kMinInstructionsForSnippet = 16;
+  {
+    auto EF = createExecutableFunction(
+        GenerateInstructions(kMinInstructionsForSnippet));
+    if (llvm::Error E = EF.takeError()) {
       InstrBenchmark.Error = llvm::toString(std::move(E));
       return InstrBenchmark;
     }
+    const auto FnBytes = EF->getFunctionBytes();
+    InstrBenchmark.AssembledSnippet.assign(FnBytes.begin(), FnBytes.end());
+  }
 
-  // FIXME: Check if TargetMachine or ExecutionEngine can be reused instead of
-  // creating one everytime.
-  const ExecutableFunction EF(State.createTargetMachine(),
-                              getObjectFromFile(*ExpectedObjectPath));
-  InstrBenchmark.Measurements = runMeasurements(EF, NumRepetitions);
+  // Assemble NumRepetitions instructions repetitions of the snippet for
+  // measurements.
+  auto EF = createExecutableFunction(
+      GenerateInstructions(InstrBenchmark.NumRepetitions));
+  if (llvm::Error E = EF.takeError()) {
+    InstrBenchmark.Error = llvm::toString(std::move(E));
+    return InstrBenchmark;
+  }
+  InstrBenchmark.Measurements = runMeasurements(*EF, NumRepetitions);
 
   return InstrBenchmark;
 }
 
 llvm::Expected<std::string>
 BenchmarkRunner::writeObjectFile(llvm::ArrayRef<llvm::MCInst> Code) const {
   int ResultFD = 0;
   llvm::SmallString<256> ResultPath;
   if (llvm::Error E = llvm::errorCodeToError(llvm::sys::fs::createTemporaryFile(
           "snippet", "o", ResultFD, ResultPath)))
     return std::move(E);
   llvm::raw_fd_ostream OFS(ResultFD, true /*ShouldClose*/);
   assembleToStream(State.createTargetMachine(), Code, OFS);
   llvm::outs() << "Check generated assembly with: /usr/bin/objdump -d "
                << ResultPath << "\n";
   return ResultPath.str();
 }
 
+llvm::Expected<ExecutableFunction> BenchmarkRunner::createExecutableFunction(
+    llvm::ArrayRef<llvm::MCInst> Code) const {
+  auto ExpectedObjectPath = writeObjectFile(Code);
+  if (llvm::Error E = ExpectedObjectPath.takeError()) {
+    return std::move(E);
+  }
+
+  // FIXME: Check if TargetMachine or ExecutionEngine can be reused instead of
+  // creating one everytime.
+  return ExecutableFunction(State.createTargetMachine(),
+                            getObjectFromFile(*ExpectedObjectPath));
+}
+
 } // namespace exegesis

tools/llvm-exegesis/lib/CMakeLists.txt

 llvm_update_compile_flags(LLVMExegesis)
 llvm_map_components_to_libnames(libs
   Analysis
   CodeGen
   Core
   ExecutionEngine
   GlobalISel
   MC
+  MCDisassembler
   MCJIT
   Object
+  ObjectYAML
   Support
   )
 
 if(LLVM_ENABLE_LIBPFM AND HAVE_LIBPFM)
   list(APPEND libs pfm)
 endif()
 
 target_link_libraries(LLVMExegesis ${libs})
 set_target_properties(LLVMExegesis PROPERTIES FOLDER "Libraries")

tools/llvm-exegesis/lib/LLVMBuild.txt

 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Library
 name = Exegesis
 parent = Libraries
-required_libraries = CodeGen ExecutionEngine MC MCJIT Object Support
+required_libraries = CodeGen ExecutionEngine MC MCDisassembler MCJIT Object ObjectYAML Support

tools/llvm-exegesis/llvm-exegesis.cpp

 }
 
 static void analysisMain() {
   if (BenchmarkFile.empty())
     llvm::report_fatal_error("--benchmarks-file must be set.");
 
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
+  llvm::InitializeNativeTargetDisassembler();
   // Read benchmarks.
   const LLVMState State;
   const std::vector<InstructionBenchmark> Points =
       ExitOnErr(InstructionBenchmark::readYamls(
           getBenchmarkResultContext(State), BenchmarkFile));
   llvm::outs() << "Parsed " << Points.size() << " benchmark points\n";
   if (Points.empty()) {
     llvm::errs() << "no benchmarks to analyze\n";