1//===- JITTargetMachineBuilder.h - Build TargetMachines for JIT -*- 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// A utitily for building TargetMachines for JITs.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_EXECUTIONENGINE_ORC_JITTARGETMACHINEBUILDER_H
14#define LLVM_EXECUTIONENGINE_ORC_JITTARGETMACHINEBUILDER_H
15
16#include "llvm/ADT/Optional.h"
17#include "llvm/ADT/Triple.h"
18#include "llvm/MC/SubtargetFeature.h"
19#include "llvm/Support/CodeGen.h"
20#include "llvm/Support/Error.h"
21#include "llvm/Target/TargetMachine.h"
22#include "llvm/Target/TargetOptions.h"
23#include <memory>
24#include <string>
25#include <vector>
26
27namespace llvm {
28
29class raw_ostream;
30
31namespace orc {
32
33/// A utility class for building TargetMachines for JITs.
34class JITTargetMachineBuilder {
35#ifndef NDEBUG
36 friend class JITTargetMachineBuilderPrinter;
37#endif
38public:
39 /// Create a JITTargetMachineBuilder based on the given triple.
40 ///
41 /// Note: TargetOptions is default-constructed, then EmulatedTLS and
42 /// ExplicitEmulatedTLS are set to true. If EmulatedTLS is not
43 /// required, these values should be reset before calling
44 /// createTargetMachine.
45 JITTargetMachineBuilder(Triple TT);
46
47 /// Create a JITTargetMachineBuilder for the host system.
48 ///
49 /// Note: TargetOptions is default-constructed, then EmulatedTLS and
50 /// ExplicitEmulatedTLS are set to true. If EmulatedTLS is not
51 /// required, these values should be reset before calling
52 /// createTargetMachine.
53 static Expected<JITTargetMachineBuilder> detectHost();
54
55 /// Create a TargetMachine.
56 ///
57 /// This operation will fail if the requested target is not registered,
58 /// in which case see llvm/Support/TargetSelect.h. To JIT IR the Target and
59 /// the target's AsmPrinter must both be registered. To JIT assembly
60 /// (including inline and module level assembly) the target's AsmParser must
61 /// also be registered.
62 Expected<std::unique_ptr<TargetMachine>> createTargetMachine();
63
64 /// Get the default DataLayout for the target.
65 ///
66 /// Note: This is reasonably expensive, as it creates a temporary
67 /// TargetMachine instance under the hood. It is only suitable for use during
68 /// JIT setup.
69 Expected<DataLayout> getDefaultDataLayoutForTarget() {
70 auto TM = createTargetMachine();
71 if (!TM)
72 return TM.takeError();
73 return (*TM)->createDataLayout();
74 }
75
76 /// Set the CPU string.
77 JITTargetMachineBuilder &setCPU(std::string CPU) {
78 this->CPU = std::move(CPU);
79 return *this;
80 }
81
82 /// Returns the CPU string.
83 const std::string &getCPU() const { return CPU; }
84
85 /// Set the relocation model.
86 JITTargetMachineBuilder &setRelocationModel(Optional<Reloc::Model> RM) {
87 this->RM = std::move(RM);
88 return *this;
89 }
90
91 /// Get the relocation model.
92 const Optional<Reloc::Model> &getRelocationModel() const { return RM; }
93
94 /// Set the code model.
95 JITTargetMachineBuilder &setCodeModel(Optional<CodeModel::Model> CM) {
96 this->CM = std::move(CM);
97 return *this;
98 }
99
100 /// Get the code model.
101 const Optional<CodeModel::Model> &getCodeModel() const { return CM; }
102
103 /// Set the LLVM CodeGen optimization level.
104 JITTargetMachineBuilder &setCodeGenOptLevel(CodeGenOpt::Level OptLevel) {
105 this->OptLevel = OptLevel;
106 return *this;
107 }
108
109 /// Set subtarget features.
110 JITTargetMachineBuilder &setFeatures(StringRef FeatureString) {
111 Features = SubtargetFeatures(FeatureString);
112 return *this;
113 }
114
115 /// Add subtarget features.
116 JITTargetMachineBuilder &
117 addFeatures(const std::vector<std::string> &FeatureVec);
118
119 /// Access subtarget features.
120 SubtargetFeatures &getFeatures() { return Features; }
121
122 /// Access subtarget features.
123 const SubtargetFeatures &getFeatures() const { return Features; }
124
125 /// Set TargetOptions.
126 ///
127 /// Note: This operation will overwrite any previously configured options,
128 /// including EmulatedTLS, ExplicitEmulatedTLS, and UseInitArray which
129 /// the JITTargetMachineBuilder sets by default. Clients are responsible
130 /// for re-enabling these overwritten options.
131 JITTargetMachineBuilder &setOptions(TargetOptions Options) {
132 this->Options = std::move(Options);
133 return *this;
134 }
135
136 /// Access TargetOptions.
137 TargetOptions &getOptions() { return Options; }
138
139 /// Access TargetOptions.
140 const TargetOptions &getOptions() const { return Options; }
141
142 /// Access Triple.
143 Triple &getTargetTriple() { return TT; }
144
145 /// Access Triple.
146 const Triple &getTargetTriple() const { return TT; }
147
148private:
149 Triple TT;
150 std::string CPU;
151 SubtargetFeatures Features;
152 TargetOptions Options;
153 Optional<Reloc::Model> RM;
154 Optional<CodeModel::Model> CM;
155 CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
156};
157
158#ifndef NDEBUG
159class JITTargetMachineBuilderPrinter {
160public:
161 JITTargetMachineBuilderPrinter(JITTargetMachineBuilder &JTMB,
162 StringRef Indent)
163 : JTMB(JTMB), Indent(Indent) {}
164 void print(raw_ostream &OS) const;
165
166 friend raw_ostream &operator<<(raw_ostream &OS,
167 const JITTargetMachineBuilderPrinter &JTMBP) {
168 JTMBP.print(OS);
169 return OS;
170 }
171
172private:
173 JITTargetMachineBuilder &JTMB;
174 StringRef Indent;
175};
176#endif // NDEBUG
177
178} // end namespace orc
179} // end namespace llvm
180
181#endif // LLVM_EXECUTIONENGINE_ORC_JITTARGETMACHINEBUILDER_H
182

source code of llvm/include/llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h