|
83
|
1 //===-- IndirectionUtils.h - Utilities for adding indirections --*- 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 //
|
|
|
10 // Contains utilities for adding indirections and breaking up modules.
|
|
|
11 //
|
|
|
12 //===----------------------------------------------------------------------===//
|
|
|
13
|
|
|
14 #ifndef LLVM_EXECUTIONENGINE_ORC_INDIRECTIONUTILS_H
|
|
|
15 #define LLVM_EXECUTIONENGINE_ORC_INDIRECTIONUTILS_H
|
|
|
16
|
|
|
17 #include "JITSymbol.h"
|
|
|
18 #include "llvm/ADT/DenseSet.h"
|
|
|
19 #include "llvm/IR/IRBuilder.h"
|
|
|
20 #include "llvm/IR/Mangler.h"
|
|
|
21 #include "llvm/IR/Module.h"
|
|
|
22 #include <sstream>
|
|
|
23
|
|
|
24 namespace llvm {
|
|
|
25
|
|
|
26 /// @brief Base class for JITLayer independent aspects of
|
|
|
27 /// JITCompileCallbackManager.
|
|
|
28 template <typename TargetT>
|
|
|
29 class JITCompileCallbackManagerBase {
|
|
|
30 public:
|
|
|
31
|
|
|
32 /// @brief Construct a JITCompileCallbackManagerBase.
|
|
|
33 /// @param ErrorHandlerAddress The address of an error handler in the target
|
|
|
34 /// process to be used if a compile callback fails.
|
|
|
35 /// @param NumTrampolinesPerBlock Number of trampolines to emit if there is no
|
|
|
36 /// available trampoline when getCompileCallback is
|
|
|
37 /// called.
|
|
|
38 JITCompileCallbackManagerBase(TargetAddress ErrorHandlerAddress,
|
|
|
39 unsigned NumTrampolinesPerBlock)
|
|
|
40 : ErrorHandlerAddress(ErrorHandlerAddress),
|
|
|
41 NumTrampolinesPerBlock(NumTrampolinesPerBlock) {}
|
|
|
42
|
|
|
43 /// @brief Execute the callback for the given trampoline id. Called by the JIT
|
|
|
44 /// to compile functions on demand.
|
|
|
45 TargetAddress executeCompileCallback(TargetAddress TrampolineID) {
|
|
|
46 typename TrampolineMapT::iterator I = ActiveTrampolines.find(TrampolineID);
|
|
|
47 // FIXME: Also raise an error in the Orc error-handler when we finally have
|
|
|
48 // one.
|
|
|
49 if (I == ActiveTrampolines.end())
|
|
|
50 return ErrorHandlerAddress;
|
|
|
51
|
|
|
52 // Found a callback handler. Yank this trampoline out of the active list and
|
|
|
53 // put it back in the available trampolines list, then try to run the
|
|
|
54 // handler's compile and update actions.
|
|
|
55 // Moving the trampoline ID back to the available list first means there's at
|
|
|
56 // least one available trampoline if the compile action triggers a request for
|
|
|
57 // a new one.
|
|
|
58 AvailableTrampolines.push_back(I->first);
|
|
|
59 auto CallbackHandler = std::move(I->second);
|
|
|
60 ActiveTrampolines.erase(I);
|
|
|
61
|
|
|
62 if (auto Addr = CallbackHandler.Compile()) {
|
|
|
63 CallbackHandler.Update(Addr);
|
|
|
64 return Addr;
|
|
|
65 }
|
|
|
66 return ErrorHandlerAddress;
|
|
|
67 }
|
|
|
68
|
|
|
69 protected:
|
|
|
70
|
|
|
71 typedef std::function<TargetAddress()> CompileFtorT;
|
|
|
72 typedef std::function<void(TargetAddress)> UpdateFtorT;
|
|
|
73
|
|
|
74 struct CallbackHandler {
|
|
|
75 CompileFtorT Compile;
|
|
|
76 UpdateFtorT Update;
|
|
|
77 };
|
|
|
78
|
|
|
79 TargetAddress ErrorHandlerAddress;
|
|
|
80 unsigned NumTrampolinesPerBlock;
|
|
|
81
|
|
|
82 typedef std::map<TargetAddress, CallbackHandler> TrampolineMapT;
|
|
|
83 TrampolineMapT ActiveTrampolines;
|
|
|
84 std::vector<TargetAddress> AvailableTrampolines;
|
|
|
85 };
|
|
|
86
|
|
|
87 /// @brief Manage compile callbacks.
|
|
|
88 template <typename JITLayerT, typename TargetT>
|
|
|
89 class JITCompileCallbackManager :
|
|
|
90 public JITCompileCallbackManagerBase<TargetT> {
|
|
|
91 public:
|
|
|
92
|
|
|
93 typedef typename JITCompileCallbackManagerBase<TargetT>::CompileFtorT
|
|
|
94 CompileFtorT;
|
|
|
95 typedef typename JITCompileCallbackManagerBase<TargetT>::UpdateFtorT
|
|
|
96 UpdateFtorT;
|
|
|
97
|
|
|
98 /// @brief Construct a JITCompileCallbackManager.
|
|
|
99 /// @param JIT JIT layer to emit callback trampolines, etc. into.
|
|
|
100 /// @param Context LLVMContext to use for trampoline & resolve block modules.
|
|
|
101 /// @param ErrorHandlerAddress The address of an error handler in the target
|
|
|
102 /// process to be used if a compile callback fails.
|
|
|
103 /// @param NumTrampolinesPerBlock Number of trampolines to allocate whenever
|
|
|
104 /// there is no existing callback trampoline.
|
|
|
105 /// (Trampolines are allocated in blocks for
|
|
|
106 /// efficiency.)
|
|
|
107 JITCompileCallbackManager(JITLayerT &JIT, LLVMContext &Context,
|
|
|
108 TargetAddress ErrorHandlerAddress,
|
|
|
109 unsigned NumTrampolinesPerBlock)
|
|
|
110 : JITCompileCallbackManagerBase<TargetT>(ErrorHandlerAddress,
|
|
|
111 NumTrampolinesPerBlock),
|
|
|
112 JIT(JIT) {
|
|
|
113 emitResolverBlock(Context);
|
|
|
114 }
|
|
|
115
|
|
|
116 /// @brief Handle to a newly created compile callback. Can be used to get an
|
|
|
117 /// IR constant representing the address of the trampoline, and to set
|
|
|
118 /// the compile and update actions for the callback.
|
|
|
119 class CompileCallbackInfo {
|
|
|
120 public:
|
|
|
121 CompileCallbackInfo(Constant *Addr, CompileFtorT &Compile,
|
|
|
122 UpdateFtorT &Update)
|
|
|
123 : Addr(Addr), Compile(Compile), Update(Update) {}
|
|
|
124
|
|
|
125 Constant* getAddress() const { return Addr; }
|
|
|
126 void setCompileAction(CompileFtorT Compile) {
|
|
|
127 this->Compile = std::move(Compile);
|
|
|
128 }
|
|
|
129 void setUpdateAction(UpdateFtorT Update) {
|
|
|
130 this->Update = std::move(Update);
|
|
|
131 }
|
|
|
132 private:
|
|
|
133 Constant *Addr;
|
|
|
134 CompileFtorT &Compile;
|
|
|
135 UpdateFtorT &Update;
|
|
|
136 };
|
|
|
137
|
|
|
138 /// @brief Get/create a compile callback with the given signature.
|
|
|
139 CompileCallbackInfo getCompileCallback(FunctionType &FT) {
|
|
|
140 TargetAddress TrampolineAddr = getAvailableTrampolineAddr(FT.getContext());
|
|
|
141 auto &CallbackHandler =
|
|
|
142 this->ActiveTrampolines[TrampolineAddr + TargetT::CallSize];
|
|
|
143 Constant *AddrIntVal =
|
|
|
144 ConstantInt::get(Type::getInt64Ty(FT.getContext()), TrampolineAddr);
|
|
|
145 Constant *AddrPtrVal =
|
|
|
146 ConstantExpr::getCast(Instruction::IntToPtr, AddrIntVal,
|
|
|
147 PointerType::get(&FT, 0));
|
|
|
148
|
|
|
149 return CompileCallbackInfo(AddrPtrVal, CallbackHandler.Compile,
|
|
|
150 CallbackHandler.Update);
|
|
|
151 }
|
|
|
152
|
|
|
153 /// @brief Get a functor for updating the value of a named function pointer.
|
|
|
154 UpdateFtorT getLocalFPUpdater(typename JITLayerT::ModuleSetHandleT H,
|
|
|
155 std::string Name) {
|
|
|
156 // FIXME: Move-capture Name once we can use C++14.
|
|
|
157 return [=](TargetAddress Addr) {
|
|
|
158 auto FPSym = JIT.findSymbolIn(H, Name, true);
|
|
|
159 assert(FPSym && "Cannot find function pointer to update.");
|
|
|
160 void *FPAddr = reinterpret_cast<void*>(
|
|
|
161 static_cast<uintptr_t>(FPSym.getAddress()));
|
|
|
162 memcpy(FPAddr, &Addr, sizeof(uintptr_t));
|
|
|
163 };
|
|
|
164 }
|
|
|
165
|
|
|
166 private:
|
|
|
167
|
|
|
168 std::vector<std::unique_ptr<Module>>
|
|
|
169 SingletonSet(std::unique_ptr<Module> M) {
|
|
|
170 std::vector<std::unique_ptr<Module>> Ms;
|
|
|
171 Ms.push_back(std::move(M));
|
|
|
172 return Ms;
|
|
|
173 }
|
|
|
174
|
|
|
175 void emitResolverBlock(LLVMContext &Context) {
|
|
|
176 std::unique_ptr<Module> M(new Module("resolver_block_module",
|
|
|
177 Context));
|
|
|
178 TargetT::insertResolverBlock(*M, *this);
|
|
|
179 auto H = JIT.addModuleSet(SingletonSet(std::move(M)), nullptr);
|
|
|
180 JIT.emitAndFinalize(H);
|
|
|
181 auto ResolverBlockSymbol =
|
|
|
182 JIT.findSymbolIn(H, TargetT::ResolverBlockName, false);
|
|
|
183 assert(ResolverBlockSymbol && "Failed to insert resolver block");
|
|
|
184 ResolverBlockAddr = ResolverBlockSymbol.getAddress();
|
|
|
185 }
|
|
|
186
|
|
|
187 TargetAddress getAvailableTrampolineAddr(LLVMContext &Context) {
|
|
|
188 if (this->AvailableTrampolines.empty())
|
|
|
189 grow(Context);
|
|
|
190 assert(!this->AvailableTrampolines.empty() &&
|
|
|
191 "Failed to grow available trampolines.");
|
|
|
192 TargetAddress TrampolineAddr = this->AvailableTrampolines.back();
|
|
|
193 this->AvailableTrampolines.pop_back();
|
|
|
194 return TrampolineAddr;
|
|
|
195 }
|
|
|
196
|
|
|
197 void grow(LLVMContext &Context) {
|
|
|
198 assert(this->AvailableTrampolines.empty() && "Growing prematurely?");
|
|
|
199 std::unique_ptr<Module> M(new Module("trampoline_block", Context));
|
|
|
200 auto GetLabelName =
|
|
|
201 TargetT::insertCompileCallbackTrampolines(*M, ResolverBlockAddr,
|
|
|
202 this->NumTrampolinesPerBlock,
|
|
|
203 this->ActiveTrampolines.size());
|
|
|
204 auto H = JIT.addModuleSet(SingletonSet(std::move(M)), nullptr);
|
|
|
205 JIT.emitAndFinalize(H);
|
|
|
206 for (unsigned I = 0; I < this->NumTrampolinesPerBlock; ++I) {
|
|
|
207 std::string Name = GetLabelName(I);
|
|
|
208 auto TrampolineSymbol = JIT.findSymbolIn(H, Name, false);
|
|
|
209 assert(TrampolineSymbol && "Failed to emit trampoline.");
|
|
|
210 this->AvailableTrampolines.push_back(TrampolineSymbol.getAddress());
|
|
|
211 }
|
|
|
212 }
|
|
|
213
|
|
|
214 JITLayerT &JIT;
|
|
|
215 TargetAddress ResolverBlockAddr;
|
|
|
216 };
|
|
|
217
|
|
|
218 GlobalVariable* createImplPointer(Function &F, const Twine &Name,
|
|
|
219 Constant *Initializer);
|
|
|
220
|
|
|
221 void makeStub(Function &F, GlobalVariable &ImplPointer);
|
|
|
222
|
|
|
223 typedef std::map<Module*, DenseSet<const GlobalValue*>> ModulePartitionMap;
|
|
|
224
|
|
|
225 void partition(Module &M, const ModulePartitionMap &PMap);
|
|
|
226
|
|
|
227 /// @brief Struct for trivial "complete" partitioning of a module.
|
|
|
228 class FullyPartitionedModule {
|
|
|
229 public:
|
|
|
230 std::unique_ptr<Module> GlobalVars;
|
|
|
231 std::unique_ptr<Module> Commons;
|
|
|
232 std::vector<std::unique_ptr<Module>> Functions;
|
|
|
233
|
|
|
234 FullyPartitionedModule() = default;
|
|
|
235 FullyPartitionedModule(FullyPartitionedModule &&S)
|
|
|
236 : GlobalVars(std::move(S.GlobalVars)), Commons(std::move(S.Commons)),
|
|
|
237 Functions(std::move(S.Functions)) {}
|
|
|
238 };
|
|
|
239
|
|
|
240 FullyPartitionedModule fullyPartition(Module &M);
|
|
|
241
|
|
|
242 }
|
|
|
243
|
|
|
244 #endif // LLVM_EXECUTIONENGINE_ORC_INDIRECTIONUTILS_H
|
