[llvm-exegesis][NFC] Rewrite of the YAML serialization.

[gchatelet]

Summary

This is a NFC in preparation of exporting the initial registers as part of the YAML dump

[gchatelet]

• Add missing Yin.setCurrentDocument()

[gchatelet]

• Add missing Yin.setCurrentDocument()
• Fix typo.

[courbet]

tools/llvm-exegesis/lib/BenchmarkResult.cpp

239

Let's add a second if (Context.error())

[gchatelet]

• Make YamlContext return an Error.

tools/llvm-exegesis/lib/BenchmarkResult.h

 /// Defines classes to represent measurements and serialize/deserialize them to
 //  Yaml.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H
 
+#include "LlvmState.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <limits>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 namespace exegesis {
 
-struct BenchmarkResultContext; // Forward declaration.
-
 struct InstructionBenchmarkKey {
   // The LLVM opcode name.
   std::vector<llvm::MCInst> Instructions;
   // An opaque configuration, that can be used to separate several benchmarks of
   // the same instruction under different configurations.
   std::string Config;
 };
 
struct InstructionBenchmark {
   // Note that measurements are per instruction.
   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);
+  readYaml(const LLVMState &State, llvm::StringRef Filename);
 
   static llvm::Expected<std::vector<InstructionBenchmark>>
-  readYamls(const BenchmarkResultContext &Context, llvm::StringRef Filename);
+  readYamls(const LLVMState &State, llvm::StringRef Filename);
 
-  void readYamlFrom(const BenchmarkResultContext &Context,
-                    llvm::StringRef InputContent);
+  void readYamlFrom(const LLVMState &State, llvm::StringRef InputContent);
 
   // Write functions, non-const because of YAML traits.
-  void writeYamlTo(const BenchmarkResultContext &Context, llvm::raw_ostream &S);
+  void writeYamlTo(const LLVMState &State, llvm::raw_ostream &S);
 
-  llvm::Error writeYaml(const BenchmarkResultContext &Context,
-                        const llvm::StringRef Filename);
+  llvm::Error writeYaml(const LLVMState &State, const llvm::StringRef Filename);
 };
 
 //------------------------------------------------------------------------------
 // Utilities to work with Benchmark measures.
 
 // A class that measures stats over benchmark measures.
 class BenchmarkMeasureStats {
 public:

 private:
   std::string Key;
   double SumValues = 0.0;
   int NumValues = 0;
   double MaxValue = std::numeric_limits<double>::min();
   double MinValue = std::numeric_limits<double>::max();
 };
 
-// This context is used when de/serializing InstructionBenchmark to guarantee
-// that Registers and Instructions are human readable and preserved accross
-// different versions of LLVM.
-struct BenchmarkResultContext {
-  BenchmarkResultContext() = default;
-  BenchmarkResultContext(BenchmarkResultContext &&) = default;
-  BenchmarkResultContext &operator=(BenchmarkResultContext &&) = default;
-  BenchmarkResultContext(const BenchmarkResultContext &) = delete;
-  BenchmarkResultContext &operator=(const BenchmarkResultContext &) = delete;
-
-  // Populate Registers and Instruction mapping.
-  void addRegEntry(unsigned RegNo, llvm::StringRef Name);
-  void addInstrEntry(unsigned Opcode, llvm::StringRef Name);
-
-  // Register accessors.
-  llvm::StringRef getRegName(unsigned RegNo) const;
-  unsigned getRegNo(llvm::StringRef Name) const; // 0 is not found.
-
-  // Instruction accessors.
-  llvm::StringRef getInstrName(unsigned Opcode) const;
-  unsigned getInstrOpcode(llvm::StringRef Name) const; // 0 is not found.
-
-private:
-  // Ideally we would like to use MCRegisterInfo and MCInstrInfo but doing so
-  // would make testing harder, instead we create a mapping that we can easily
-  // populate.
-  std::unordered_map<unsigned, llvm::StringRef> InstrOpcodeToName;
-  std::unordered_map<unsigned, llvm::StringRef> RegNoToName;
-  llvm::StringMap<unsigned> InstrNameToOpcode;
-  llvm::StringMap<unsigned> RegNameToNo;
-};
-
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H

tools/llvm-exegesis/lib/BenchmarkResult.cpp

 #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";
 
-static void serialize(const exegesis::BenchmarkResultContext &Context,
-                      const llvm::MCOperand &MCOperand, llvm::raw_ostream &OS) {
+struct YamlContext {
+  YamlContext(const exegesis::LLVMState &State) : State(&State) {}
+
+  llvm::StringRef getRegName(unsigned RegNo) {
+    return State->getRegInfo().getName(RegNo);
+  }
+
+  llvm::StringRef getInstrName(unsigned InstrNo) {
+    return State->getInstrInfo().getName(InstrNo);
+  }
+
+  unsigned getRegNo(llvm::StringRef RegName) {
+    const llvm::MCRegisterInfo &RegInfo = State->getRegInfo();
+    for (unsigned E = RegInfo.getNumRegs(), I = 0; I < E; ++I)
+      if (RegInfo.getName(I) == RegName)
+        return I;
+    llvm::errs() << "Unknown register " << RegName << "\n";
+    return 0;
+  }
+
+  unsigned getInstrOpcode(llvm::StringRef InstrName) {
+    const llvm::MCInstrInfo &InstrInfo = State->getInstrInfo();
+    for (unsigned E = InstrInfo.getNumOpcodes(), I = 0; I < E; ++I)
+      if (InstrInfo.getName(I) == InstrName)
+        return I;
+    llvm::errs() << "Unknown opcaode " << InstrName << "\n";
+    return 0;
+  }
+
+  const exegesis::LLVMState *State;
+};
+
+static void serialize(YamlContext &Context, const llvm::MCOperand &MCOperand,
+                      llvm::raw_ostream &OS) {
   if (MCOperand.isReg()) {
     OS << Context.getRegName(MCOperand.getReg());
   } else if (MCOperand.isImm()) {
     OS << llvm::format(kIntegerFormat, MCOperand.getImm());
   } else if (MCOperand.isFPImm()) {
     OS << llvm::format(kDoubleFormat, MCOperand.getFPImm());
   } else {
     OS << "INVALID";
   }
 }
 
-static void serialize(const exegesis::BenchmarkResultContext &Context,
-                      const llvm::MCInst &MCInst, llvm::raw_ostream &OS) {
+static void serialize(YamlContext &Context, const llvm::MCInst &MCInst,
+                      llvm::raw_ostream &OS) {
   OS << Context.getInstrName(MCInst.getOpcode());
   for (const auto &Op : MCInst) {
     OS << ' ';
     serialize(Context, Op, OS);
   }
 }
 
-static llvm::MCOperand
-deserialize(const exegesis::BenchmarkResultContext &Context,
+static llvm::MCOperand deserialize(YamlContext &Context,
                                    llvm::StringRef String) {
   assert(!String.empty());
   int64_t IntValue = 0;
   double DoubleValue = 0;
   if (sscanf(String.data(), kIntegerFormat, &IntValue) == 1)
     return llvm::MCOperand::createImm(IntValue);
   if (sscanf(String.data(), kDoubleFormat, &DoubleValue) == 1)
     return llvm::MCOperand::createFPImm(DoubleValue);
   if (unsigned RegNo = Context.getRegNo(String)) // Returns 0 if invalid.
     return llvm::MCOperand::createReg(RegNo);
   return {};
 }
 
-static llvm::StringRef
-deserialize(const exegesis::BenchmarkResultContext &Context,
-            llvm::StringRef String, llvm::MCInst &Value) {
+static llvm::StringRef deserialize(YamlContext &Context, llvm::StringRef String,
+                                   llvm::MCInst &Value) {
   llvm::SmallVector<llvm::StringRef, 8> Pieces;
   String.split(Pieces, " ", /* MaxSplit */ -1, /* KeepEmpty */ false);
   if (Pieces.empty())
     return "Invalid Instruction";
   bool ProcessOpcode = true;
   for (llvm::StringRef Piece : Pieces) {
     if (ProcessOpcode) {
       ProcessOpcode = false;
       Value.setOpcode(Context.getInstrOpcode(Piece));
       if (Value.getOpcode() == 0)
         return "Unknown Opcode Name";
     } else {
       Value.addOperand(deserialize(Context, Piece));
     }
   }
   return {};
 }
 
-// YAML IO requires a mutable pointer to Context but we guarantee to not
-// modify it.
-static void *getUntypedContext(const exegesis::BenchmarkResultContext &Ctx) {
-  return const_cast<exegesis::BenchmarkResultContext *>(&Ctx);
-}
-
-static const exegesis::BenchmarkResultContext &getTypedContext(void *Ctx) {
-  assert(Ctx);
-  return *static_cast<const exegesis::BenchmarkResultContext *>(Ctx);
-}
-
 // Defining YAML traits for IO.
 namespace llvm {
 namespace yaml {
 
 // std::vector<llvm::MCInst> will be rendered as a list.
 template <> struct SequenceElementTraits<llvm::MCInst> {
   static const bool flow = false;
 };
 
 template <> struct ScalarTraits<llvm::MCInst> {
 
   static void output(const llvm::MCInst &Value, void *Ctx,
                      llvm::raw_ostream &Out) {
-    serialize(getTypedContext(Ctx), Value, Out);
+    serialize(*reinterpret_cast<YamlContext *>(Ctx), Value, Out);
   }
 
   static StringRef input(StringRef Scalar, void *Ctx, llvm::MCInst &Value) {
-    return deserialize(getTypedContext(Ctx), Scalar, Value);
+    return deserialize(*reinterpret_cast<YamlContext *>(Ctx), Scalar, Value);
   }
 
   static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
 
   static const bool flow = true;
 };
 
 // std::vector<exegesis::Measure> will be rendered as a list.
struct ScalarEnumerationTraits<exegesis::InstructionBenchmark::ModeE> {
   static void enumeration(IO &Io,
                           exegesis::InstructionBenchmark::ModeE &Value) {
     Io.enumCase(Value, "", exegesis::InstructionBenchmark::Unknown);
     Io.enumCase(Value, "latency", exegesis::InstructionBenchmark::Latency);
     Io.enumCase(Value, "uops", exegesis::InstructionBenchmark::Uops);
   }
 };
 
-template <> struct MappingTraits<exegesis::InstructionBenchmarkKey> {
-  static void mapping(IO &Io, exegesis::InstructionBenchmarkKey &Obj) {
+template <>
+struct MappingContextTraits<exegesis::InstructionBenchmarkKey, YamlContext> {
+  static void mapping(IO &Io, exegesis::InstructionBenchmarkKey &Obj,
+                      YamlContext &Context) {
+    Io.setContext(&Context);
     Io.mapRequired("instructions", Obj.Instructions);
     Io.mapOptional("config", Obj.Config);
   }
 };
 
-template <> struct MappingTraits<exegesis::InstructionBenchmark> {
+template <>
+struct MappingContextTraits<exegesis::InstructionBenchmark, YamlContext> {
   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) {
+  static void mapping(IO &Io, exegesis::InstructionBenchmark &Obj,
+                      YamlContext &Context) {
     Io.mapRequired("mode", Obj.Mode);
-    Io.mapRequired("key", Obj.Key);
+    Io.mapRequired("key", Obj.Key, Context);
     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)
-
 namespace exegesis {
 
-void BenchmarkResultContext::addRegEntry(unsigned RegNo, llvm::StringRef Name) {
-  assert(RegNoToName.find(RegNo) == RegNoToName.end());
-  assert(RegNameToNo.find(Name) == RegNameToNo.end());
-  RegNoToName[RegNo] = Name;
-  RegNameToNo[Name] = RegNo;
-}
-
-llvm::StringRef BenchmarkResultContext::getRegName(unsigned RegNo) const {
-  const auto Itr = RegNoToName.find(RegNo);
-  if (Itr != RegNoToName.end())
-    return Itr->second;
-  return {};
-}
-
-unsigned BenchmarkResultContext::getRegNo(llvm::StringRef Name) const {
-  const auto Itr = RegNameToNo.find(Name);
-  if (Itr != RegNameToNo.end())
-    return Itr->second;
-  return 0;
-}
-
-void BenchmarkResultContext::addInstrEntry(unsigned Opcode,
-                                           llvm::StringRef Name) {
-  assert(InstrOpcodeToName.find(Opcode) == InstrOpcodeToName.end());
-  assert(InstrNameToOpcode.find(Name) == InstrNameToOpcode.end());
-  InstrOpcodeToName[Opcode] = Name;
-  InstrNameToOpcode[Name] = Opcode;
-}
-
-llvm::StringRef BenchmarkResultContext::getInstrName(unsigned Opcode) const {
-  const auto Itr = InstrOpcodeToName.find(Opcode);
-  if (Itr != InstrOpcodeToName.end())
-    return Itr->second;
-  return {};
-}
-
-unsigned BenchmarkResultContext::getInstrOpcode(llvm::StringRef Name) const {
-  const auto Itr = InstrNameToOpcode.find(Name);
-  if (Itr != InstrNameToOpcode.end())
-    return Itr->second;
-  return 0;
-}
-
-template <typename ObjectOrList>
-static llvm::Expected<ObjectOrList>
-readYamlCommon(const BenchmarkResultContext &Context,
+llvm::Expected<InstructionBenchmark>
+InstructionBenchmark::readYaml(const LLVMState &State,
                                llvm::StringRef Filename) {
   if (auto ExpectedMemoryBuffer =
           llvm::errorOrToExpected(llvm::MemoryBuffer::getFile(Filename))) {
-    std::unique_ptr<llvm::MemoryBuffer> MemoryBuffer =
-        std::move(ExpectedMemoryBuffer.get());
-    llvm::yaml::Input Yin(*MemoryBuffer, getUntypedContext(Context));
-    ObjectOrList Benchmark;
-    Yin >> Benchmark;
+    llvm::yaml::Input Yin(*ExpectedMemoryBuffer.get());
+    YamlContext Context(State);
+    InstructionBenchmark Benchmark;
+    if (Yin.setCurrentDocument())
+      llvm::yaml::yamlize(Yin, Benchmark, /*unused*/ true, Context);
     return Benchmark;
   } else {
     return ExpectedMemoryBuffer.takeError();
   }
 }
 
-llvm::Expected<InstructionBenchmark>
-InstructionBenchmark::readYaml(const BenchmarkResultContext &Context,
-                               llvm::StringRef Filename) {
-  return readYamlCommon<InstructionBenchmark>(Context, Filename);
-}
-
 llvm::Expected<std::vector<InstructionBenchmark>>
-InstructionBenchmark::readYamls(const BenchmarkResultContext &Context,
+InstructionBenchmark::readYamls(const LLVMState &State,
                                 llvm::StringRef Filename) {
-  return readYamlCommon<std::vector<InstructionBenchmark>>(Context, Filename);
+  if (auto ExpectedMemoryBuffer =
+          llvm::errorOrToExpected(llvm::MemoryBuffer::getFile(Filename))) {
+    llvm::yaml::Input Yin(*ExpectedMemoryBuffer.get());
+    YamlContext Context(State);
+    std::vector<InstructionBenchmark> Benchmarks;
+    while (Yin.setCurrentDocument()) {
+      Benchmarks.emplace_back();
+      yamlize(Yin, Benchmarks.back(), /*unused*/ true, Context);
+      if (Yin.error())
+        return llvm::errorCodeToError(Yin.error());
+      Yin.nextDocument();
+    }
+    return Benchmarks;
+  } else {
+    return ExpectedMemoryBuffer.takeError();
+  }
 }
 
-void InstructionBenchmark::writeYamlTo(const BenchmarkResultContext &Context,
+void InstructionBenchmark::writeYamlTo(const LLVMState &State,
                                        llvm::raw_ostream &OS) {
-  llvm::yaml::Output Yout(OS, getUntypedContext(Context));
-  Yout << *this;
+  llvm::yaml::Output Yout(OS);
+  YamlContext Context(State);
+  llvm::yaml::yamlize(Yout, *this, /*unused*/ true, Context);
 }
 
-void InstructionBenchmark::readYamlFrom(const BenchmarkResultContext &Context,
+void InstructionBenchmark::readYamlFrom(const LLVMState &State,
                                         llvm::StringRef InputContent) {
-  llvm::yaml::Input Yin(InputContent, getUntypedContext(Context));
-  Yin >> *this;
+  llvm::yaml::Input Yin(InputContent);
+  YamlContext Context(State);
+  llvm::yaml::yamlize(Yin, *this, /*unused*/ true, Context);
 }
 
-llvm::Error
-InstructionBenchmark::writeYaml(const BenchmarkResultContext &Context,
+llvm::Error InstructionBenchmark::writeYaml(const LLVMState &State,
                                             const llvm::StringRef Filename) {
   if (Filename == "-") {
-    writeYamlTo(Context, llvm::outs());
+    writeYamlTo(State, llvm::outs());
   } else {
     int ResultFD = 0;
     if (auto E = llvm::errorCodeToError(
             openFileForWrite(Filename, ResultFD, llvm::sys::fs::CD_CreateAlways,
                              llvm::sys::fs::F_Text))) {
       return E;
     }
     llvm::raw_fd_ostream Ostr(ResultFD, true /*shouldClose*/);
-    writeYamlTo(Context, Ostr);
+    writeYamlTo(State, Ostr);
   }
   return llvm::Error::success();
 }
 
 void BenchmarkMeasureStats::push(const BenchmarkMeasure &BM) {
   if (Key.empty())
     Key = BM.Key;
   assert(Key == BM.Key);
   ++NumValues;
   SumValues += BM.Value;
   MaxValue = std::max(MaxValue, BM.Value);
   MinValue = std::min(MinValue, BM.Value);
 }
 
 } // namespace exegesis

tools/llvm-exegesis/llvm-exegesis.cpp

if (OpcodeIndex > 0)
     return OpcodeIndex;
   // Resolve opcode name -> opcode.
   for (unsigned I = 0, E = MCInstrInfo.getNumOpcodes(); I < E; ++I)
     if (MCInstrInfo.getName(I) == OpcodeName)
       return I;
   llvm::report_fatal_error(llvm::Twine("unknown opcode ").concat(OpcodeName));
 }
 
-static BenchmarkResultContext
-getBenchmarkResultContext(const LLVMState &State) {
-  BenchmarkResultContext Ctx;
-
-  const llvm::MCInstrInfo &InstrInfo = State.getInstrInfo();
-  for (unsigned E = InstrInfo.getNumOpcodes(), I = 0; I < E; ++I)
-    Ctx.addInstrEntry(I, InstrInfo.getName(I).data());
-
-  const llvm::MCRegisterInfo &RegInfo = State.getRegInfo();
-  for (unsigned E = RegInfo.getNumRegs(), I = 0; I < E; ++I)
-    Ctx.addRegEntry(I, RegInfo.getName(I));
-
-  return Ctx;
-}
-
 // Generates code snippets for opcode `Opcode`.
 llvm::Expected<std::vector<BenchmarkCode>>
 generateSnippets(const LLVMState &State, unsigned Opcode) {
   const std::unique_ptr<SnippetGenerator> Generator =
       State.getExegesisTarget().createSnippetGenerator(BenchmarkMode, State);
   if (!Generator) {
     llvm::report_fatal_error("cannot create snippet generator");
   }
#endif
 
   if (NumRepetitions == 0)
     llvm::report_fatal_error("--num-repetitions must be greater than zero");
 
   // Write to standard output if file is not set.
   if (BenchmarkFile.empty())
     BenchmarkFile = "-";
 
-  const BenchmarkResultContext Context = getBenchmarkResultContext(State);
-
   for (const BenchmarkCode &Conf : Configurations) {
     InstructionBenchmark Result =
         Runner->runConfiguration(Conf, NumRepetitions);
-    ExitOnErr(Result.writeYaml(Context, BenchmarkFile));
+    ExitOnErr(Result.writeYaml(State, BenchmarkFile));
   }
   exegesis::pfm::pfmTerminate();
 }
 
 // Prints the results of running analysis pass `Pass` to file `OutputFilename`
 // if OutputFilename is non-empty.
 template <typename Pass>
 static void maybeRunAnalysis(const Analysis &Analyzer, const std::string &Name,
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));
+      ExitOnErr(InstructionBenchmark::readYamls(State, BenchmarkFile));
   llvm::outs() << "Parsed " << Points.size() << " benchmark points\n";
   if (Points.empty()) {
     llvm::errs() << "no benchmarks to analyze\n";
     return;
   }
   // FIXME: Check that all points have the same triple/cpu.
   // FIXME: Merge points from several runs (latency and uops).
 

unittests/tools/llvm-exegesis/CMakeLists.txt

 include_directories(
   ${LLVM_MAIN_SRC_DIR}/tools/llvm-exegesis/lib
   )
 
 set(LLVM_LINK_COMPONENTS
   MC
   MCParser
   Object
   Support
   Symbolize
   )
 
 add_llvm_unittest(LLVMExegesisTests
-  BenchmarkResultTest.cpp
   BenchmarkRunnerTest.cpp
   ClusteringTest.cpp
   PerfHelperTest.cpp
   RegisterValueTest.cpp
   )
 target_link_libraries(LLVMExegesisTests PRIVATE LLVMExegesis)
 
 if(LLVM_TARGETS_TO_BUILD MATCHES "X86")
   add_subdirectory(X86)
 endif()
 if(LLVM_TARGETS_TO_BUILD MATCHES "ARM")
   add_subdirectory(ARM)
 endif()
 if(LLVM_TARGETS_TO_BUILD MATCHES "AArch64")
   add_subdirectory(AArch64)
 endif()

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

 //===-- BenchmarkResultTest.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 "X86InstrInfo.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using ::testing::AllOf;
 using ::testing::Eq;
 using ::testing::get;
if (Lhs != Rhs) {
     *result_listener << Lhs << " <=> " << Rhs;
     return false;
   }
   return true;
 }
 
 namespace {
 
-static constexpr const unsigned kInstrId = 5;
-static constexpr const char kInstrName[] = "Instruction5";
-static constexpr const unsigned kReg1Id = 1;
-static constexpr const char kReg1Name[] = "Reg1";
-static constexpr const unsigned kReg2Id = 2;
-static constexpr const char kReg2Name[] = "Reg2";
-
 TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
+  LLVMInitializeX86TargetInfo();
+  LLVMInitializeX86Target();
+  LLVMInitializeX86TargetMC();
+
+  // Read benchmarks.
+  const LLVMState State;
+
   llvm::ExitOnError ExitOnErr;
-  BenchmarkResultContext Ctx;
-  Ctx.addInstrEntry(kInstrId, kInstrName);
-  Ctx.addRegEntry(kReg1Id, kReg1Name);
-  Ctx.addRegEntry(kReg2Id, kReg2Name);
 
   InstructionBenchmark ToDisk;
 
-  ToDisk.Key.Instructions.push_back(llvm::MCInstBuilder(kInstrId)
-                                        .addReg(kReg1Id)
-                                        .addReg(kReg2Id)
+  ToDisk.Key.Instructions.push_back(llvm::MCInstBuilder(llvm::X86::XOR32rr)
+                                        .addReg(llvm::X86::AL)
+                                        .addReg(llvm::X86::AH)
                                         .addImm(123)
                                         .addFPImm(0.5));
   ToDisk.Key.Config = "config";
   ToDisk.Mode = InstructionBenchmark::Latency;
   ToDisk.CpuName = "cpu_name";
   ToDisk.LLVMTriple = "llvm_triple";
   ToDisk.NumRepetitions = 1;
   ToDisk.Measurements.push_back(BenchmarkMeasure{"a", 1, "debug a"});
   ToDisk.Measurements.push_back(BenchmarkMeasure{"b", 2, ""});
   ToDisk.Error = "error";
   ToDisk.Info = "info";
 
   llvm::SmallString<64> Filename;
   std::error_code EC;
   EC = llvm::sys::fs::createUniqueDirectory("BenchmarkResultTestDir", Filename);
   ASSERT_FALSE(EC);
   llvm::sys::path::append(Filename, "data.yaml");
-  ExitOnErr(ToDisk.writeYaml(Ctx, Filename));
+  llvm::errs() << Filename << "-------\n";
+  ExitOnErr(ToDisk.writeYaml(State, Filename));
 
   {
     // One-element version.
     const auto FromDisk =
-        ExitOnErr(InstructionBenchmark::readYaml(Ctx, Filename));
+        ExitOnErr(InstructionBenchmark::readYaml(State, Filename));
 
     EXPECT_THAT(FromDisk.Key.Instructions,
                 Pointwise(EqMCInst(), ToDisk.Key.Instructions));
     EXPECT_EQ(FromDisk.Key.Config, ToDisk.Key.Config);
     EXPECT_EQ(FromDisk.Mode, ToDisk.Mode);
     EXPECT_EQ(FromDisk.CpuName, ToDisk.CpuName);
     EXPECT_EQ(FromDisk.LLVMTriple, ToDisk.LLVMTriple);
     EXPECT_EQ(FromDisk.NumRepetitions, ToDisk.NumRepetitions);
     EXPECT_THAT(FromDisk.Measurements, ToDisk.Measurements);
     EXPECT_THAT(FromDisk.Error, ToDisk.Error);
     EXPECT_EQ(FromDisk.Info, ToDisk.Info);
   }
   {
     // Vector version.
     const auto FromDiskVector =
-        ExitOnErr(InstructionBenchmark::readYamls(Ctx, Filename));
+        ExitOnErr(InstructionBenchmark::readYamls(State, Filename));
     ASSERT_EQ(FromDiskVector.size(), size_t{1});
     const auto FromDisk = FromDiskVector[0];
     EXPECT_THAT(FromDisk.Key.Instructions,
                 Pointwise(EqMCInst(), ToDisk.Key.Instructions));
     EXPECT_EQ(FromDisk.Key.Config, ToDisk.Key.Config);
     EXPECT_EQ(FromDisk.Mode, ToDisk.Mode);
     EXPECT_EQ(FromDisk.CpuName, ToDisk.CpuName);
     EXPECT_EQ(FromDisk.LLVMTriple, ToDisk.LLVMTriple);

unittests/tools/llvm-exegesis/X86/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   Support
   Symbolize
   X86
   )
 
 add_llvm_unittest(LLVMExegesisX86Tests
   AssemblerTest.cpp
   AnalysisTest.cpp
+  BenchmarkResultTest.cpp
   SnippetGeneratorTest.cpp
   RegisterAliasingTest.cpp
   TargetTest.cpp
   )
 target_link_libraries(LLVMExegesisX86Tests PRIVATE
   LLVMExegesis
   LLVMExegesisX86)