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
114