[llvm-exegesis] Get the BenchmarkRunner from the ExegesisTarget.

[courbet]

Summary

This allows targets to override code generation for some instructions.
As an example of override, this also moves ad-hoc instruction filtering
for X86 into the X86 ExegesisTarget.

[gchatelet]

tools/llvm-exegesis/llvm-exegesis.cpp

54 ↗

(On Diff #152849)

Unknown is Analysis?

[courbet]

tools/llvm-exegesis/llvm-exegesis.cpp

54 ↗

(On Diff #152849)

Yes, that allows getting rid of the extra enum and avoid a switch to convert from one enum to the other.

[gchatelet]

tools/llvm-exegesis/llvm-exegesis.cpp

54 ↗

(On Diff #152849)

Ok so please add a comment explaining why Analysis is different from latency/uops.

[courbet]

Thanks.

llvm/trunk/tools/llvm-exegesis/lib/Assembler.h

 // Gather the set of reserved registers (depends on function's calling
 // convention and target machine).
 llvm::BitVector getFunctionReservedRegs(const llvm::TargetMachine &TM);
 
 // Creates a temporary `void foo()` function containing the provided
 // Instructions. Runs a set of llvm Passes to provide correct prologue and
 // epilogue. Once the MachineFunction is ready, it is assembled for TM to
 // AsmStream, the temporary function is eventually discarded.
-void assembleToStream(const ExegesisTarget *ET,
+void assembleToStream(const ExegesisTarget &ET,
                       std::unique_ptr<llvm::LLVMTargetMachine> TM,
                       llvm::ArrayRef<unsigned> RegsToDef,
                       llvm::ArrayRef<llvm::MCInst> Instructions,
                       llvm::raw_pwrite_stream &AsmStream);
 
 // Creates an ObjectFile in the format understood by the host.
 // Note: the resulting object keeps a copy of Buffer so it can be discarded once
 // this function returns.

llvm/trunk/tools/llvm-exegesis/lib/Assembler.cpp

llvm::BitVector getFunctionReservedRegs(const llvm::TargetMachine &TM) {
   std::unique_ptr<llvm::MachineModuleInfo> MMI =
       llvm::make_unique<llvm::MachineModuleInfo>(&TM);
   llvm::MachineFunction &MF =
       createVoidVoidMachineFunction(FunctionID, Module.get(), MMI.get());
   // Saving reserved registers for client.
   return MF.getSubtarget().getRegisterInfo()->getReservedRegs(MF);
 }
 
-void assembleToStream(const ExegesisTarget *ET,
+void assembleToStream(const ExegesisTarget &ET,
                       std::unique_ptr<llvm::LLVMTargetMachine> TM,
                       llvm::ArrayRef<unsigned> RegsToDef,
                       llvm::ArrayRef<llvm::MCInst> Instructions,
                       llvm::raw_pwrite_stream &AsmStream) {
   std::unique_ptr<llvm::LLVMContext> Context =
       llvm::make_unique<llvm::LLVMContext>();
   std::unique_ptr<llvm::Module> Module =
       createModule(Context, TM->createDataLayout());
   std::unique_ptr<llvm::MachineModuleInfo> MMI =
       llvm::make_unique<llvm::MachineModuleInfo>(TM.get());
   llvm::MachineFunction &MF =
       createVoidVoidMachineFunction(FunctionID, Module.get(), MMI.get());
 
   // We need to instruct the passes that we're done with SSA and virtual
   // registers.
   auto &Properties = MF.getProperties();
   Properties.set(llvm::MachineFunctionProperties::Property::NoVRegs);
   Properties.reset(llvm::MachineFunctionProperties::Property::IsSSA);
-  std::vector<llvm::MCInst> SnippetWithSetup;
-  bool IsSnippetSetupComplete = RegsToDef.empty();
-  if (ET) {
-    SnippetWithSetup =
-        generateSnippetSetupCode(RegsToDef, *ET, IsSnippetSetupComplete);
+  bool IsSnippetSetupComplete = false;
+  std::vector<llvm::MCInst> SnippetWithSetup =
+      generateSnippetSetupCode(RegsToDef, ET, IsSnippetSetupComplete);
+  if (!SnippetWithSetup.empty()) {
     SnippetWithSetup.insert(SnippetWithSetup.end(), Instructions.begin(),
                             Instructions.end());
     Instructions = SnippetWithSetup;
   }
   // If the snippet setup is not complete, we disable liveliness tracking. This
   // means that we won't know what values are in the registers.
   if (!IsSnippetSetupComplete)
     Properties.reset(llvm::MachineFunctionProperties::Property::TracksLiveness);
void assembleToStream(const ExegesisTarget &ET,
   llvm::TargetLibraryInfoImpl TLII(llvm::Triple(Module->getTargetTriple()));
   PM.add(new llvm::TargetLibraryInfoWrapperPass(TLII));
 
   llvm::TargetPassConfig *TPC = TM->createPassConfig(PM);
   PM.add(TPC);
   PM.add(MMI.release());
   TPC->printAndVerify("MachineFunctionGenerator::assemble");
   // Add target-specific passes.
-  if (ET) {
-    ET->addTargetSpecificPasses(PM);
-    TPC->printAndVerify("After ExegesisTarget::addTargetSpecificPasses");
-  }
+  ET.addTargetSpecificPasses(PM);
   // Adding the following passes:
   // - machineverifier: checks that the MachineFunction is well formed.
   // - prologepilog: saves and restore callee saved registers.
   for (const char *PassName : {"machineverifier", "prologepilog"})
     if (addPass(PM, PassName, *TPC))
       llvm::report_fatal_error("Unable to add a mandatory pass");
   TPC->setInitialized();
 

llvm/trunk/tools/llvm-exegesis/lib/BenchmarkRunner.h

struct BenchmarkConfiguration {
 
   // Informations about how this configuration was built.
   std::string Info;
 };
 
 // Common code for all benchmark modes.
 class BenchmarkRunner {
 public:
-  explicit BenchmarkRunner(const LLVMState &State);
-
-  // Subtargets can disable running benchmarks for some instructions by
-  // returning an error here.
-  class InstructionFilter {
-  public:
-    virtual ~InstructionFilter();
-
-    virtual llvm::Error shouldRun(const LLVMState &State,
-                                  unsigned Opcode) const {
-      return llvm::ErrorSuccess();
-    }
-  };
+  explicit BenchmarkRunner(const LLVMState &State, InstructionBenchmark::ModeE Mode);
 
   virtual ~BenchmarkRunner();
 
   llvm::Expected<std::vector<InstructionBenchmark>>
-  run(unsigned Opcode, const InstructionFilter &Filter,
-      unsigned NumRepetitions);
+  run(unsigned Opcode, unsigned NumRepetitions);
 
   // Given a snippet, computes which registers the setup code needs to define.
   std::vector<unsigned>
   computeRegsToDef(const std::vector<InstructionInstance> &Snippet) const;
 
 protected:
   const LLVMState &State;
   const RegisterAliasingTrackerCache RATC;
 
 private:
+  // API to be implemented by subclasses.
+  virtual llvm::Expected<SnippetPrototype>
+    generatePrototype(unsigned Opcode) const = 0;
+
+  virtual std::vector<BenchmarkMeasure>
+    runMeasurements(const ExecutableFunction &EF,
+                    const unsigned NumRepetitions) const = 0;
+
+  // Internal helpers.
   InstructionBenchmark runOne(const BenchmarkConfiguration &Configuration,
                               unsigned Opcode, unsigned NumRepetitions) const;
 
   // Calls generatePrototype and expands the SnippetPrototype into one or more
   // BenchmarkConfiguration.
   llvm::Expected<std::vector<BenchmarkConfiguration>>
   generateConfigurations(unsigned Opcode) const;
 
-  virtual InstructionBenchmark::ModeE getMode() const = 0;
-
-  virtual llvm::Expected<SnippetPrototype>
-  generatePrototype(unsigned Opcode) const = 0;
-
-  virtual std::vector<BenchmarkMeasure>
-  runMeasurements(const ExecutableFunction &EF,
-                  const unsigned NumRepetitions) const = 0;
 
   llvm::Expected<std::string>
   writeObjectFile(const BenchmarkConfiguration::Setup &Setup,
                   llvm::ArrayRef<llvm::MCInst> Code) const;
+
+  const InstructionBenchmark::ModeE Mode;
 };
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRUNNER_H

llvm/trunk/tools/llvm-exegesis/lib/BenchmarkRunner.cpp

 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"
 
 namespace exegesis {
 
 BenchmarkFailure::BenchmarkFailure(const llvm::Twine &S)
     : llvm::StringError(S, llvm::inconvertibleErrorCode()) {}
 
-BenchmarkRunner::InstructionFilter::~InstructionFilter() = default;
-
-BenchmarkRunner::BenchmarkRunner(const LLVMState &State)
-    : State(State),
-      RATC(State.getRegInfo(), getFunctionReservedRegs(State.getTargetMachine())) {}
+BenchmarkRunner::BenchmarkRunner(const LLVMState &State,
+                                 InstructionBenchmark::ModeE Mode)
+    : State(State), RATC(State.getRegInfo(),
+                         getFunctionReservedRegs(State.getTargetMachine())),
+      Mode(Mode) {}
 
 BenchmarkRunner::~BenchmarkRunner() = default;
 
 llvm::Expected<std::vector<InstructionBenchmark>>
-BenchmarkRunner::run(unsigned Opcode, const InstructionFilter &Filter,
-                     unsigned NumRepetitions) {
+BenchmarkRunner::run(unsigned Opcode, unsigned NumRepetitions) {
+  const llvm::MCInstrDesc &InstrDesc = State.getInstrInfo().get(Opcode);
   // Ignore instructions that we cannot run.
-  if (State.getInstrInfo().get(Opcode).isPseudo())
+  if (InstrDesc.isPseudo())
     return llvm::make_error<BenchmarkFailure>("Unsupported opcode: isPseudo");
-
-  if (llvm::Error E = Filter.shouldRun(State, Opcode))
-    return std::move(E);
+  if (InstrDesc.isBranch() || InstrDesc.isIndirectBranch())
+    return llvm::make_error<BenchmarkFailure>(
+        "Unsupported opcode: isBranch/isIndirectBranch");
+  if (InstrDesc.isCall() || InstrDesc.isReturn())
+    return llvm::make_error<BenchmarkFailure>(
+        "Unsupported opcode: isCall/isReturn");
 
   llvm::Expected<std::vector<BenchmarkConfiguration>> ConfigurationOrError =
       generateConfigurations(Opcode);
 
   if (llvm::Error E = ConfigurationOrError.takeError())
     return std::move(E);
 
   std::vector<InstructionBenchmark> InstrBenchmarks;
   for (const BenchmarkConfiguration &Conf : ConfigurationOrError.get())
     InstrBenchmarks.push_back(runOne(Conf, Opcode, NumRepetitions));
   return InstrBenchmarks;
 }
 
 InstructionBenchmark
 BenchmarkRunner::runOne(const BenchmarkConfiguration &Configuration,
                         unsigned Opcode, unsigned NumRepetitions) const {
   InstructionBenchmark InstrBenchmark;
-  InstrBenchmark.Mode = getMode();
+  InstrBenchmark.Mode = Mode;
   InstrBenchmark.CpuName = State.getTargetMachine().getTargetCPU();
   InstrBenchmark.LLVMTriple =
       State.getTargetMachine().getTargetTriple().normalize();
   InstrBenchmark.NumRepetitions = NumRepetitions;
   InstrBenchmark.Info = Configuration.Info;
 
   const std::vector<llvm::MCInst> &Snippet = Configuration.Snippet;
   if (Snippet.empty()) {

llvm/trunk/tools/llvm-exegesis/lib/CMakeLists.txt

add_library(LLVMExegesis
   Clustering.cpp
   Latency.cpp
   LlvmState.cpp
   MCInstrDescView.cpp
   PerfHelper.cpp
   RegisterAliasing.cpp
   Target.cpp
   Uops.cpp
-  X86.cpp
   )
 
 llvm_update_compile_flags(LLVMExegesis)
 llvm_map_components_to_libnames(libs
   Analysis
   CodeGen
   Core
   ExecutionEngine

llvm/trunk/tools/llvm-exegesis/lib/Latency.h

 
 #include "BenchmarkRunner.h"
 #include "MCInstrDescView.h"
 
 namespace exegesis {
 
 class LatencyBenchmarkRunner : public BenchmarkRunner {
 public:
-  using BenchmarkRunner::BenchmarkRunner;
+  LatencyBenchmarkRunner(const LLVMState &State)
+      : BenchmarkRunner(State, InstructionBenchmark::Latency) {}
   ~LatencyBenchmarkRunner() override;
 
   llvm::Expected<SnippetPrototype>
   generatePrototype(unsigned Opcode) const override;
 
 private:
   llvm::Error isInfeasible(const llvm::MCInstrDesc &MCInstrDesc) const;
 
   llvm::Expected<SnippetPrototype> generateSelfAliasingPrototype(
       const Instruction &Instr,
       const AliasingConfigurations &SelfAliasing) const;
 
   llvm::Expected<SnippetPrototype> generateTwoInstructionPrototype(
       const Instruction &Instr,
       const AliasingConfigurations &SelfAliasing) const;
 
-  InstructionBenchmark::ModeE getMode() const override;
-
   std::vector<BenchmarkMeasure>
   runMeasurements(const ExecutableFunction &EF,
                   const unsigned NumRepetitions) const override;
 };
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_LATENCY_H

llvm/trunk/tools/llvm-exegesis/lib/Latency.cpp

 
 // FIXME: Handle memory, see PR36905.
 static bool hasMemoryOperand(const llvm::MCOperandInfo &OpInfo) {
   return OpInfo.OperandType == llvm::MCOI::OPERAND_MEMORY;
 }
 
 LatencyBenchmarkRunner::~LatencyBenchmarkRunner() = default;
 
-InstructionBenchmark::ModeE LatencyBenchmarkRunner::getMode() const {
-  return InstructionBenchmark::Latency;
-}
-
 llvm::Error LatencyBenchmarkRunner::isInfeasible(
     const llvm::MCInstrDesc &MCInstrDesc) const {
-  if (MCInstrDesc.isPseudo())
-    return llvm::make_error<BenchmarkFailure>("Infeasible : is pseudo");
   if (llvm::any_of(MCInstrDesc.operands(), hasUnknownOperand))
     return llvm::make_error<BenchmarkFailure>(
         "Infeasible : has unknown operands");
   if (llvm::any_of(MCInstrDesc.operands(), hasMemoryOperand))
     return llvm::make_error<BenchmarkFailure>(
         "Infeasible : has memory operands");
   return llvm::Error::success();
 }

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

 /// \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 "Target.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"
 #include "llvm/Target/TargetMachine.h"
 #include <memory>
 #include <string>
public:
   LLVMState();
 
   LLVMState(const std::string &Triple,
             const std::string &CpuName); // For tests.
 
   const llvm::TargetMachine &getTargetMachine() const { return *TargetMachine; }
   std::unique_ptr<llvm::LLVMTargetMachine> createTargetMachine() const;
 
-  const ExegesisTarget *getExegesisTarget() const { return TheExegesisTarget; }
+  const ExegesisTarget &getExegesisTarget() const { return *TheExegesisTarget; }
 
   bool canAssemble(const llvm::MCInst &mc_inst) const;
 
   // For convenience:
   const llvm::MCInstrInfo &getInstrInfo() const {
     return *TargetMachine->getMCInstrInfo();
   }
   const llvm::MCRegisterInfo &getRegInfo() const {
     return *TargetMachine->getMCRegisterInfo();
   }
   const llvm::MCSubtargetInfo &getSubtargetInfo() const {
     return *TargetMachine->getMCSubtargetInfo();
   }
 
 private:
-  const ExegesisTarget *TheExegesisTarget = nullptr;
+  const ExegesisTarget *TheExegesisTarget;
   std::unique_ptr<const llvm::TargetMachine> TargetMachine;
 };
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_LLVMSTATE_H

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

 //===-- LlvmState.cpp -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LlvmState.h"
+#include "Target.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 
 namespace exegesis {
 
 LLVMState::LLVMState(const std::string &Triple, const std::string &CpuName) {
   std::string Error;
   const llvm::Target *const TheTarget =
       llvm::TargetRegistry::lookupTarget(Triple, Error);
   assert(TheTarget && "unknown target for host");
   const llvm::TargetOptions Options;
   TargetMachine.reset(static_cast<llvm::LLVMTargetMachine *>(
       TheTarget->createTargetMachine(Triple, CpuName, /*Features*/ "", Options,
                                      llvm::Reloc::Model::Static)));
   TheExegesisTarget = ExegesisTarget::lookup(TargetMachine->getTargetTriple());
+  if (!TheExegesisTarget) {
+    llvm::errs() << "no exegesis target for " << Triple << ", using default\n";
+    TheExegesisTarget = &ExegesisTarget::getDefault();
+  }
 }
 
 LLVMState::LLVMState()
     : LLVMState(llvm::sys::getProcessTriple(),
                 llvm::sys::getHostCPUName().str()) {}
 
 std::unique_ptr<llvm::LLVMTargetMachine>
 LLVMState::createTargetMachine() const {

llvm/trunk/tools/llvm-exegesis/lib/Target.h

 /// Classes that handle the creation of target-specific objects. This is
 /// similar to llvm::Target/TargetRegistry.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_TARGET_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_TARGET_H
 
+#include "BenchmarkResult.h"
+#include "BenchmarkRunner.h"
+#include "LlvmState.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCRegisterInfo.h"
 
 namespace exegesis {
 
 class ExegesisTarget {
 public:
   // Targets can use this to add target-specific passes in assembleToStream();
   virtual void addTargetSpecificPasses(llvm::PassManagerBase &PM) const {}
 
   // Generates code to move a constant into a the given register.
   virtual std::vector<llvm::MCInst> setRegToConstant(unsigned Reg) const {
     return {};
   }
 
+  // Creates a benchmark runner for the given mode.
+  std::unique_ptr<BenchmarkRunner>
+  createBenchmarkRunner(InstructionBenchmark::ModeE Mode,
+                        const LLVMState &State) const;
+
   // Returns the ExegesisTarget for the given triple or nullptr if the target
   // does not exist.
   static const ExegesisTarget *lookup(llvm::Triple TT);
+  // Returns the default (unspecialized) ExegesisTarget.
+  static const ExegesisTarget &getDefault();
   // Registers a target. Not thread safe.
   static void registerTarget(ExegesisTarget *T);
 
   virtual ~ExegesisTarget();
 
 private:
   virtual bool matchesArch(llvm::Triple::ArchType Arch) const = 0;
+
+  // Targets can implement their own Latency/Uops benchmarks runners by
+  // implementing these.
+  std::unique_ptr<BenchmarkRunner> virtual createLatencyBenchmarkRunner(
+      const LLVMState &State) const;
+  std::unique_ptr<BenchmarkRunner> virtual createUopsBenchmarkRunner(
+      const LLVMState &State) const;
+
   const ExegesisTarget *Next = nullptr;
 };
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_TARGET_H

llvm/trunk/tools/llvm-exegesis/lib/Target.cpp

 //===-- Target.cpp ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "Target.h"
 
+#include "Latency.h"
+#include "Uops.h"
+
 namespace exegesis {
 
 ExegesisTarget::~ExegesisTarget() {} // anchor.
 
 static ExegesisTarget *FirstTarget = nullptr;
 
 const ExegesisTarget *ExegesisTarget::lookup(llvm::Triple TT) {
   for (const ExegesisTarget *T = FirstTarget; T != nullptr; T = T->Next) {
if (FirstTarget == nullptr) {
     return;
   }
   assert(Target->Next == nullptr && "target has already been registered");
   if (Target->Next != nullptr)
     return;
   Target->Next = FirstTarget;
   FirstTarget = Target;
 }
+
+std::unique_ptr<BenchmarkRunner>
+ExegesisTarget::createBenchmarkRunner(InstructionBenchmark::ModeE Mode,
+                                      const LLVMState &State) const {
+  switch (Mode) {
+  case InstructionBenchmark::Unknown:
+    return nullptr;
+  case InstructionBenchmark::Latency:
+    return createLatencyBenchmarkRunner(State);
+  case InstructionBenchmark::Uops:
+    return createUopsBenchmarkRunner(State);
+  }
+  return nullptr;
+}
+
+std::unique_ptr<BenchmarkRunner>
+ExegesisTarget::createLatencyBenchmarkRunner(const LLVMState &State) const {
+  return llvm::make_unique<LatencyBenchmarkRunner>(State);
+}
+
+std::unique_ptr<BenchmarkRunner>
+ExegesisTarget::createUopsBenchmarkRunner(const LLVMState &State) const {
+  return llvm::make_unique<UopsBenchmarkRunner>(State);
+}
+
+namespace {
+
+// Default implementation.
+class ExegesisDefaultTarget : public ExegesisTarget {
+private:
+  bool matchesArch(llvm::Triple::ArchType Arch) const override {
+    llvm_unreachable("never called");
+    return false;
+  }
+};
+
+} // namespace
+
+const ExegesisTarget &ExegesisTarget::getDefault() {
+  static ExegesisDefaultTarget Target;
+  return Target;
+}
+
 } // namespace exegesis

llvm/trunk/tools/llvm-exegesis/lib/Uops.h

 #define LLVM_TOOLS_LLVM_EXEGESIS_UOPS_H
 
 #include "BenchmarkRunner.h"
 
 namespace exegesis {
 
 class UopsBenchmarkRunner : public BenchmarkRunner {
 public:
-  using BenchmarkRunner::BenchmarkRunner;
+  UopsBenchmarkRunner(const LLVMState &State)
+      : BenchmarkRunner(State, InstructionBenchmark::Uops) {}
   ~UopsBenchmarkRunner() override;
 
   llvm::Expected<SnippetPrototype>
   generatePrototype(unsigned Opcode) const override;
 
 private:
   llvm::Error isInfeasible(const llvm::MCInstrDesc &MCInstrDesc) const;
 
-  InstructionBenchmark::ModeE getMode() const override;
-
   std::vector<BenchmarkMeasure>
   runMeasurements(const ExecutableFunction &EF,
                   const unsigned NumRepetitions) const override;
 };
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_UOPS_H

llvm/trunk/tools/llvm-exegesis/lib/Uops.cpp

 
 // FIXME: Handle memory, see PR36905.
 static bool hasMemoryOperand(const llvm::MCOperandInfo &OpInfo) {
   return OpInfo.OperandType == llvm::MCOI::OPERAND_MEMORY;
 }
 
 llvm::Error
 UopsBenchmarkRunner::isInfeasible(const llvm::MCInstrDesc &MCInstrDesc) const {
-  if (MCInstrDesc.isPseudo())
-    return llvm::make_error<BenchmarkFailure>("Infeasible : is pseudo");
   if (llvm::any_of(MCInstrDesc.operands(), hasUnknownOperand))
     return llvm::make_error<BenchmarkFailure>(
         "Infeasible : has unknown operands");
   if (llvm::any_of(MCInstrDesc.operands(), hasMemoryOperand))
     return llvm::make_error<BenchmarkFailure>(
         "Infeasible : has memory operands");
   return llvm::Error::success();
 }

 static void remove(llvm::BitVector &a, const llvm::BitVector &b) {
   assert(a.size() == b.size());
   for (auto I : b.set_bits())
     a.reset(I);
 }
 
 UopsBenchmarkRunner::~UopsBenchmarkRunner() = default;
 
-InstructionBenchmark::ModeE UopsBenchmarkRunner::getMode() const {
-  return InstructionBenchmark::Uops;
-}
-
 llvm::Expected<SnippetPrototype>
 UopsBenchmarkRunner::generatePrototype(unsigned Opcode) const {
   const auto &InstrDesc = State.getInstrInfo().get(Opcode);
   if (auto E = isInfeasible(InstrDesc))
     return std::move(E);
   const Instruction Instr(InstrDesc, RATC);
   const AliasingConfigurations SelfAliasing(Instr, Instr);
   if (SelfAliasing.empty()) {

llvm/trunk/tools/llvm-exegesis/lib/X86.h

-//===-- X86.h ---------------------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// X86 target-specific setup.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_TOOLS_LLVM_EXEGESIS_X86_H
-#define LLVM_TOOLS_LLVM_EXEGESIS_X86_H
-
-#include "BenchmarkRunner.h"
-#include "LlvmState.h"
-
-namespace exegesis {
-
-class X86Filter : public BenchmarkRunner::InstructionFilter {
-public:
-  ~X86Filter() override;
-
-  llvm::Error shouldRun(const LLVMState &State, unsigned Opcode) const override;
-};
-
-} // namespace exegesis
-
-#endif // LLVM_TOOLS_LLVM_EXEGESIS_X86_H

llvm/trunk/tools/llvm-exegesis/lib/X86.cpp

-//===-- X86.cpp --------------------------------------------------*- C++-*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "X86.h"
-
-namespace exegesis {
-
-static llvm::Error makeError(llvm::Twine Msg) {
-  return llvm::make_error<llvm::StringError>(Msg,
-                                             llvm::inconvertibleErrorCode());
-}
-
-X86Filter::~X86Filter() = default;
-
-// Test whether we can generate a snippet for this instruction.
-llvm::Error X86Filter::shouldRun(const LLVMState &State,
-                                 const unsigned Opcode) const {
-  const auto &InstrInfo = State.getInstrInfo();
-  const llvm::MCInstrDesc &InstrDesc = InstrInfo.get(Opcode);
-  if (InstrDesc.isBranch() || InstrDesc.isIndirectBranch())
-    return makeError("Unsupported opcode: isBranch/isIndirectBranch");
-  if (InstrDesc.isCall() || InstrDesc.isReturn())
-    return makeError("Unsupported opcode: isCall/isReturn");
-  const auto OpcodeName = InstrInfo.getName(Opcode);
-  if (OpcodeName.startswith("POPF") || OpcodeName.startswith("PUSHF") ||
-      OpcodeName.startswith("ADJCALLSTACK")) {
-    return makeError("Unsupported opcode: Push/Pop/AdjCallStack");
-  }
-  return llvm::ErrorSuccess();
-}
-
-} // namespace exegesis

llvm/trunk/tools/llvm-exegesis/lib/X86/Target.cpp

 //===-- Target.cpp ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "../Target.h"
 
+#include "../Latency.h"
+#include "../Uops.h"
 #include "MCTargetDesc/X86MCTargetDesc.h"
 #include "X86.h"
 #include "X86RegisterInfo.h"
 #include "llvm/MC/MCInstBuilder.h"
 
 namespace exegesis {
 
+// Test whether we can generate a snippet for this instruction.
+static llvm::Error shouldRun(const LLVMState &State, const unsigned Opcode) {
+  const auto &InstrInfo = State.getInstrInfo();
+  const auto OpcodeName = InstrInfo.getName(Opcode);
+  if (OpcodeName.startswith("POPF") || OpcodeName.startswith("PUSHF") ||
+      OpcodeName.startswith("ADJCALLSTACK")) {
+    return llvm::make_error<BenchmarkFailure>(
+        "Unsupported opcode: Push/Pop/AdjCallStack");
+  }
+  return llvm::ErrorSuccess();
+}
+
 namespace {
 
+class X86LatencyBenchmarkRunner : public LatencyBenchmarkRunner {
+private:
+  using LatencyBenchmarkRunner::LatencyBenchmarkRunner;
+
+  llvm::Expected<SnippetPrototype>
+  generatePrototype(unsigned Opcode) const override {
+    if (llvm::Error E = shouldRun(State, Opcode)) {
+      return std::move(E);
+    }
+    return LatencyBenchmarkRunner::generatePrototype(Opcode);
+  }
+};
+
+class X86UopsBenchmarkRunner : public UopsBenchmarkRunner {
+private:
+  using UopsBenchmarkRunner::UopsBenchmarkRunner;
+
+  llvm::Expected<SnippetPrototype>
+  generatePrototype(unsigned Opcode) const override {
+    if (llvm::Error E = shouldRun(State, Opcode)) {
+      return std::move(E);
+    }
+    return UopsBenchmarkRunner::generatePrototype(Opcode);
+  }
+};
+
 class ExegesisX86Target : public ExegesisTarget {
   void addTargetSpecificPasses(llvm::PassManagerBase &PM) const override {
     // Lowers FP pseudo-instructions, e.g. ABS_Fp32 -> ABS_F.
     // FIXME: Enable when the exegesis assembler no longer does
     // Properties.reset(TracksLiveness);
     // PM.add(llvm::createX86FloatingPointStackifierPass());
   }
 
if (llvm::X86::VR256XRegClass.contains(Reg)) {
       return setVectorRegToConstant(Reg, 32, llvm::X86::VMOVDQUYrm);
     }
     if (llvm::X86::VR512RegClass.contains(Reg)) {
       return setVectorRegToConstant(Reg, 64, llvm::X86::VMOVDQU64Zrm);
     }
     return {};
   }
 
+  std::unique_ptr<BenchmarkRunner>
+  createLatencyBenchmarkRunner(const LLVMState &State) const override {
+    return llvm::make_unique<X86LatencyBenchmarkRunner>(State);
+  }
+
+  std::unique_ptr<BenchmarkRunner>
+  createUopsBenchmarkRunner(const LLVMState &State) const override {
+    return llvm::make_unique<X86UopsBenchmarkRunner>(State);
+  }
+
   bool matchesArch(llvm::Triple::ArchType Arch) const override {
     return Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::x86;
   }
 
 private:
   // setRegToConstant() specialized for a vector register of size
   // `RegSizeBytes`. `RMOpcode` is the opcode used to do a memory -> vector
   // register load.

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

 /// Measures execution properties (latencies/uops) of an instruction.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "lib/Analysis.h"
 #include "lib/BenchmarkResult.h"
 #include "lib/BenchmarkRunner.h"
 #include "lib/Clustering.h"
-#include "lib/Latency.h"
 #include "lib/LlvmState.h"
 #include "lib/PerfHelper.h"
-#include "lib/Uops.h"
-#include "lib/X86.h"
+#include "lib/Target.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"

 
 static llvm::cl::opt<std::string>
     OpcodeName("opcode-name", llvm::cl::desc("opcode to measure, by name"),
                llvm::cl::init(""));
 
 static llvm::cl::opt<std::string>
     BenchmarkFile("benchmarks-file", llvm::cl::desc(""), llvm::cl::init(""));
 
-enum class BenchmarkModeE { Latency, Uops, Analysis };
-static llvm::cl::opt<BenchmarkModeE> BenchmarkMode(
+static llvm::cl::opt<exegesis::InstructionBenchmark::ModeE> BenchmarkMode(
     "mode", llvm::cl::desc("the mode to run"),
-    llvm::cl::values(
-        clEnumValN(BenchmarkModeE::Latency, "latency", "Instruction Latency"),
-        clEnumValN(BenchmarkModeE::Uops, "uops", "Uop Decomposition"),
-        clEnumValN(BenchmarkModeE::Analysis, "analysis", "Analysis")));
+    llvm::cl::values(clEnumValN(exegesis::InstructionBenchmark::Latency,
+                                "latency", "Instruction Latency"),
+                     clEnumValN(exegesis::InstructionBenchmark::Uops, "uops",
+                                "Uop Decomposition"),
+                     // When not asking for a specific benchmark mode, we'll
+                     // analyse the results.
+                     clEnumValN(exegesis::InstructionBenchmark::Unknown,
+                                "analysis", "Analysis")));
 
 static llvm::cl::opt<unsigned>
     NumRepetitions("num-repetitions",
                    llvm::cl::desc("number of time to repeat the asm snippet"),
                    llvm::cl::init(10000));
 
 static llvm::cl::opt<bool> IgnoreInvalidSchedClass(
     "ignore-invalid-sched-class",
if (exegesis::pfm::pfmInitialize())
     llvm::report_fatal_error("cannot initialize libpfm");
 
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
 #ifdef LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET
   LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET();
 #endif
 
-  // FIXME: Target-specific filter.
-  X86Filter Filter;
-
   const LLVMState State;
   const auto Opcode = GetOpcodeOrDie(State.getInstrInfo());
 
   // Ignore instructions without a sched class if -ignore-invalid-sched-class is
   // passed.
   if (IgnoreInvalidSchedClass &&
       State.getInstrInfo().get(Opcode).getSchedClass() == 0) {
     llvm::errs() << "ignoring instruction without sched class\n";
     return;
   }
 
   // FIXME: Do not require SchedModel for latency.
   if (!State.getSubtargetInfo().getSchedModel().hasExtraProcessorInfo())
     llvm::report_fatal_error("sched model is missing extra processor info!");
 
-  std::unique_ptr<BenchmarkRunner> Runner;
-  switch (BenchmarkMode) {
-  case BenchmarkModeE::Latency:
-    Runner = llvm::make_unique<LatencyBenchmarkRunner>(State);
-    break;
-  case BenchmarkModeE::Uops:
-    Runner = llvm::make_unique<UopsBenchmarkRunner>(State);
-    break;
-  case BenchmarkModeE::Analysis:
-    llvm_unreachable("not a benchmark");
+  const std::unique_ptr<BenchmarkRunner> Runner =
+      State.getExegesisTarget().createBenchmarkRunner(BenchmarkMode, State);
+  if (!Runner) {
+    llvm::report_fatal_error("cannot create benchmark runner");
   }
 
   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);
   std::vector<InstructionBenchmark> Results =
-      ExitOnErr(Runner->run(Opcode, Filter, NumRepetitions));
+      ExitOnErr(Runner->run(Opcode, NumRepetitions));
   for (InstructionBenchmark &Result : Results)
     ExitOnErr(Result.writeYaml(Context, BenchmarkFile));
 
   exegesis::pfm::pfmTerminate();
 }
 
 // Prints the results of running analysis pass `Pass` to file `OutputFilename`
 // if OutputFilename is non-empty.
int main(int Argc, char **Argv) {
   llvm::cl::ParseCommandLineOptions(Argc, Argv, "");
 
   exegesis::ExitOnErr.setExitCodeMapper([](const llvm::Error &Err) {
     if (Err.isA<llvm::StringError>())
       return EXIT_SUCCESS;
     return EXIT_FAILURE;
   });
 
-  if (BenchmarkMode == BenchmarkModeE::Analysis) {
+  if (BenchmarkMode == exegesis::InstructionBenchmark::Unknown) {
     exegesis::analysisMain();
   } else {
     exegesis::benchmarkMain();
   }
   return EXIT_SUCCESS;
 }

llvm/trunk/unittests/tools/llvm-exegesis/Common/AssemblerUtils.h

 //===-- AssemblerUtils.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Assembler.h"
+#include "Target.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
MachineFunctionGeneratorBaseTest(const std::string &TT,
     if (!CanExecute) {
       llvm::outs() << "Skipping execution, host:"
                    << llvm::sys::getProcessTriple() << ", target:" << TT
                    << "\n";
     }
   }
 
   template <class... Bs> inline void Check(llvm::MCInst MCInst, Bs... Bytes) {
-    CheckWithSetup(nullptr, {}, MCInst, Bytes...);
+    CheckWithSetup(ExegesisTarget::getDefault(), {}, MCInst, Bytes...);
   }
 
   template <class... Bs>
-  inline void CheckWithSetup(const ExegesisTarget *ET,
+  inline void CheckWithSetup(const ExegesisTarget &ET,
                              llvm::ArrayRef<unsigned> RegsToDef,
                              llvm::MCInst MCInst, Bs... Bytes) {
     ExecutableFunction Function =
         (MCInst.getOpcode() == 0) ? assembleToFunction(ET, RegsToDef, {})
                                   : assembleToFunction(ET, RegsToDef, {MCInst});
     ASSERT_THAT(Function.getFunctionBytes().str(),
                 testing::ElementsAre(Bytes...));
     if (CanExecute)
std::unique_ptr<llvm::LLVMTargetMachine> createTargetMachine() {
     llvm::TargetMachine *TM = TheTarget->createTargetMachine(
         TT, CpuName, "", Options, llvm::Reloc::Model::Static);
     EXPECT_TRUE(TM) << TT << " " << CpuName;
     return std::unique_ptr<llvm::LLVMTargetMachine>(
         static_cast<llvm::LLVMTargetMachine *>(TM));
   }
 
   ExecutableFunction
-  assembleToFunction(const ExegesisTarget *ET,
+  assembleToFunction(const ExegesisTarget &ET,
                      llvm::ArrayRef<unsigned> RegsToDef,
                      llvm::ArrayRef<llvm::MCInst> Instructions) {
     llvm::SmallString<256> Buffer;
     llvm::raw_svector_ostream AsmStream(Buffer);
     assembleToStream(ET, createTargetMachine(), RegsToDef, Instructions,
                      AsmStream);
     return ExecutableFunction(createTargetMachine(),
                               getObjectFromBuffer(AsmStream.str()));
   }
 
   const std::string TT;
   const std::string CpuName;
   const bool CanExecute;
 };
 
 } // namespace exegesis

llvm/trunk/unittests/tools/llvm-exegesis/X86/SnippetGeneratorTest.cpp

EXPECT_THAT(II.VariableValues[0].getReg(), Not(II.VariableValues[1].getReg()))
       << "Def is different from first Use";
   EXPECT_THAT(II.VariableValues[0].getReg(), Not(II.VariableValues[2].getReg()))
       << "Def is different from second Use";
   EXPECT_THAT(II.VariableValues[3], IsInvalid());
 }
 
 class FakeBenchmarkRunner : public BenchmarkRunner {
 public:
-  using BenchmarkRunner::BenchmarkRunner;
+  FakeBenchmarkRunner(const LLVMState &State)
+      : BenchmarkRunner(State, InstructionBenchmark::Unknown) {}
 
   Instruction createInstruction(unsigned Opcode) {
     return Instruction(State.getInstrInfo().get(Opcode), RATC);
   }
 
 private:
-  InstructionBenchmark::ModeE getMode() const override {
-    return InstructionBenchmark::Unknown;
-  }
-
   llvm::Expected<SnippetPrototype>
   generatePrototype(unsigned Opcode) const override {
     return llvm::make_error<llvm::StringError>("not implemented",
                                                llvm::inconvertibleErrorCode());
   }
 
   std::vector<BenchmarkMeasure>
   runMeasurements(const ExecutableFunction &EF,