tools/llvm-exegesis/lib/Target.cpp

   1 //===-- Target.cpp ----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 #include "Target.h"
  10
  11 #include "Latency.h"
  12 #include "Uops.h"
  13
  14 namespace exegesis {
  15
  16 ExegesisTarget::~ExegesisTarget() {} // anchor.
  17
  18 static ExegesisTarget *FirstTarget = nullptr;
  19
  20 const ExegesisTarget *ExegesisTarget::lookup(llvm::Triple TT) {
  21   for (const ExegesisTarget *T = FirstTarget; T != nullptr; T = T->Next) {
  22     if (T->matchesArch(TT.getArch()))
  23       return T;
  24   }
  25   return nullptr;
  26 }
  27
  28 void ExegesisTarget::registerTarget(ExegesisTarget *Target) {
  29   if (FirstTarget == nullptr) {
  30     FirstTarget = Target;
  31     return;
  32   }
  33   if (Target->Next != nullptr)
  34     return; // Already registered.
  35   Target->Next = FirstTarget;
  36   FirstTarget = Target;
  37 }
  38
  39 std::unique_ptr<SnippetGenerator>
  40 ExegesisTarget::createSnippetGenerator(InstructionBenchmark::ModeE Mode,
  41                                        const LLVMState &State) const {
  42   switch (Mode) {
  43   case InstructionBenchmark::Unknown:
  44     return nullptr;
  45   case InstructionBenchmark::Latency:
  46     return createLatencySnippetGenerator(State);
  47   case InstructionBenchmark::Uops:
  48     return createUopsSnippetGenerator(State);
  49   }
  50   return nullptr;
  51 }
  52
  53 std::unique_ptr<BenchmarkRunner>
  54 ExegesisTarget::createBenchmarkRunner(InstructionBenchmark::ModeE Mode,
  55                                       const LLVMState &State) const {
  56   switch (Mode) {
  57   case InstructionBenchmark::Unknown:
  58     return nullptr;
  59   case InstructionBenchmark::Latency:
  60     return createLatencyBenchmarkRunner(State);
  61   case InstructionBenchmark::Uops:
  62     return createUopsBenchmarkRunner(State);
  63   }
  64   return nullptr;
  65 }
  66
  67 std::unique_ptr<SnippetGenerator>
  68 ExegesisTarget::createLatencySnippetGenerator(const LLVMState &State) const {
  69   return llvm::make_unique<LatencySnippetGenerator>(State);
  70 }
  71
  72 std::unique_ptr<SnippetGenerator>
  73 ExegesisTarget::createUopsSnippetGenerator(const LLVMState &State) const {
  74   return llvm::make_unique<UopsSnippetGenerator>(State);
  75 }
  76
  77 std::unique_ptr<BenchmarkRunner>
  78 ExegesisTarget::createLatencyBenchmarkRunner(const LLVMState &State) const {
  79   return llvm::make_unique<LatencyBenchmarkRunner>(State);
  80 }
  81
  82 std::unique_ptr<BenchmarkRunner>
  83 ExegesisTarget::createUopsBenchmarkRunner(const LLVMState &State) const {
  84   return llvm::make_unique<UopsBenchmarkRunner>(State);
  85 }
  86
  87 namespace {
  88
  89 // Default implementation.
  90 class ExegesisDefaultTarget : public ExegesisTarget {
  91 private:
  92   std::vector<llvm::MCInst> setRegTo(const llvm::MCSubtargetInfo &STI,
  93                                      unsigned Reg,
  94                                      const llvm::APInt &Value) const override {
  95     llvm_unreachable("Not yet implemented");
  96   }
  97
  98   bool matchesArch(llvm::Triple::ArchType Arch) const override {
  99     llvm_unreachable("never called");
 100     return false;
 101   }
 102 };
 103
 104 } // namespace
 105
 106 const ExegesisTarget &ExegesisTarget::getDefault() {
 107   static ExegesisDefaultTarget Target;
 108   return Target;
 109 }
 110
 111 } // namespace exegesis