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