Mercurial > hg > CbC > CbC_llvm

comparison tools/llvm-exegesis/lib/Target.h @ 148:63bd29f05246

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
merged
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Wed, 14 Aug 2019 19:46:37 +0900
parents c2174574ed3a
children
comparison
equal deleted inserted replaced
146:3fc4d5c3e21e 148:63bd29f05246
1 //===-- Target.h ------------------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file
10 ///
11 /// Classes that handle the creation of target-specific objects. This is
12 /// similar to llvm::Target/TargetRegistry.
13 ///
14 //===----------------------------------------------------------------------===//
15
16 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_TARGET_H
17 #define LLVM_TOOLS_LLVM_EXEGESIS_TARGET_H
18
19 #include "BenchmarkResult.h"
20 #include "BenchmarkRunner.h"
21 #include "LlvmState.h"
22 #include "SnippetGenerator.h"
23 #include "llvm/ADT/Triple.h"
24 #include "llvm/CodeGen/TargetPassConfig.h"
25 #include "llvm/IR/CallingConv.h"
26 #include "llvm/IR/LegacyPassManager.h"
27 #include "llvm/MC/MCInst.h"
28 #include "llvm/MC/MCRegisterInfo.h"
29
30 namespace llvm {
31 namespace exegesis {
32
33 struct PfmCountersInfo {
34 // An optional name of a performance counter that can be used to measure
35 // cycles.
36 const char *CycleCounter;
37
38 // An optional name of a performance counter that can be used to measure
39 // uops.
40 const char *UopsCounter;
41
42 // An IssueCounter specifies how to measure uops issued to specific proc
43 // resources.
44 struct IssueCounter {
45 const char *Counter;
46 // The name of the ProcResource that this counter measures.
47 const char *ProcResName;
48 };
49 // An optional list of IssueCounters.
50 const IssueCounter *IssueCounters;
51 unsigned NumIssueCounters;
52
53 static const PfmCountersInfo Default;
54 };
55
56 struct CpuAndPfmCounters {
57 const char *CpuName;
58 const PfmCountersInfo *PCI;
59 bool operator<(llvm::StringRef S) const {
60 return llvm::StringRef(CpuName) < S;
61 }
62 };
63
64 class ExegesisTarget {
65 public:
66 explicit ExegesisTarget(llvm::ArrayRef<CpuAndPfmCounters> CpuPfmCounters)
67 : CpuPfmCounters(CpuPfmCounters) {}
68
69 // Targets can use this to add target-specific passes in assembleToStream();
70 virtual void addTargetSpecificPasses(llvm::PassManagerBase &PM) const {}
71
72 // Generates code to move a constant into a the given register.
73 // Precondition: Value must fit into Reg.
74 virtual std::vector<llvm::MCInst>
75 setRegTo(const llvm::MCSubtargetInfo &STI, unsigned Reg,
76 const llvm::APInt &Value) const = 0;
77
78 // Returns the register pointing to scratch memory, or 0 if this target
79 // does not support memory operands. The benchmark function uses the
80 // default calling convention.
81 virtual unsigned getScratchMemoryRegister(const llvm::Triple &) const {
82 return 0;
83 }
84
85 // Fills memory operands with references to the address at [Reg] + Offset.
86 virtual void fillMemoryOperands(InstructionTemplate &IT, unsigned Reg,
87 unsigned Offset) const {
88
89 llvm_unreachable(
90 "fillMemoryOperands() requires getScratchMemoryRegister() > 0");
91 }
92
93 // Returns a list of unavailable registers.
94 // Targets can use this to prevent some registers to be automatically selected
95 // for use in snippets.
96 virtual ArrayRef<unsigned> getUnavailableRegisters() const { return {}; }
97
98 // Returns the maximum number of bytes a load/store instruction can access at
99 // once. This is typically the size of the largest register available on the
100 // processor. Note that this only used as a hint to generate independant
101 // load/stores to/from memory, so the exact returned value does not really
102 // matter as long as it's large enough.
103 virtual unsigned getMaxMemoryAccessSize() const { return 0; }
104
105 // Assigns a random operand of the right type to variable Var.
106 // The default implementation only handles generic operand types.
107 // The target is responsible for handling any operand
108 // starting from OPERAND_FIRST_TARGET.
109 virtual void randomizeMCOperand(const Instruction &Instr, const Variable &Var,
110 llvm::MCOperand &AssignedValue,
111 const llvm::BitVector &ForbiddenRegs) const;
112
113 // Creates a snippet generator for the given mode.
114 std::unique_ptr<SnippetGenerator>
115 createSnippetGenerator(InstructionBenchmark::ModeE Mode,
116 const LLVMState &State) const;
117 // Creates a benchmark runner for the given mode.
118 std::unique_ptr<BenchmarkRunner>
119 createBenchmarkRunner(InstructionBenchmark::ModeE Mode,
120 const LLVMState &State) const;
121
122 // Returns the ExegesisTarget for the given triple or nullptr if the target
123 // does not exist.
124 static const ExegesisTarget *lookup(llvm::Triple TT);
125 // Returns the default (unspecialized) ExegesisTarget.
126 static const ExegesisTarget &getDefault();
127 // Registers a target. Not thread safe.
128 static void registerTarget(ExegesisTarget *T);
129
130 virtual ~ExegesisTarget();
131
132 // Returns the Pfm counters for the given CPU (or the default if no pfm
133 // counters are defined for this CPU).
134 const PfmCountersInfo &getPfmCounters(llvm::StringRef CpuName) const;
135
136 private:
137 virtual bool matchesArch(llvm::Triple::ArchType Arch) const = 0;
138
139 // Targets can implement their own snippet generators/benchmarks runners by
140 // implementing these.
141 std::unique_ptr<SnippetGenerator> virtual createLatencySnippetGenerator(
142 const LLVMState &State) const;
143 std::unique_ptr<SnippetGenerator> virtual createUopsSnippetGenerator(
144 const LLVMState &State) const;
145 std::unique_ptr<BenchmarkRunner> virtual createLatencyBenchmarkRunner(
146 const LLVMState &State, InstructionBenchmark::ModeE Mode) const;
147 std::unique_ptr<BenchmarkRunner> virtual createUopsBenchmarkRunner(
148 const LLVMState &State) const;
149
150 const ExegesisTarget *Next = nullptr;
151 const llvm::ArrayRef<CpuAndPfmCounters> CpuPfmCounters;
152 };
153
154 } // namespace exegesis
155 } // namespace llvm
156
157 #endif // LLVM_TOOLS_LLVM_EXEGESIS_TARGET_H