LLVM 17.0.0git
LLJIT.h
Go to the documentation of this file.
1//===----- LLJIT.h -- An ORC-based JIT for compiling LLVM IR ----*- 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// An ORC-based JIT for compiling LLVM IR.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_EXECUTIONENGINE_ORC_LLJIT_H
14#define LLVM_EXECUTIONENGINE_ORC_LLJIT_H
15
23#include "llvm/Support/Debug.h"
25
26namespace llvm {
27namespace orc {
28
29class LLJITBuilderState;
30class LLLazyJITBuilderState;
31class ObjectTransformLayer;
32class ExecutorProcessControl;
33
34/// A pre-fabricated ORC JIT stack that can serve as an alternative to MCJIT.
35///
36/// Create instances using LLJITBuilder.
37class LLJIT {
38 template <typename, typename, typename> friend class LLJITBuilderSetters;
39
40 friend void setUpGenericLLVMIRPlatform(LLJIT &J);
41
42public:
43 /// Initializer support for LLJIT.
45 public:
47
48 virtual Error initialize(JITDylib &JD) = 0;
49
50 virtual Error deinitialize(JITDylib &JD) = 0;
51
52 protected:
53 static void setInitTransform(LLJIT &J,
55 };
56
57 /// Destruct this instance. If a multi-threaded instance, waits for all
58 /// compile threads to complete.
59 virtual ~LLJIT();
60
61 /// Returns the ExecutionSession for this instance.
63
64 /// Returns a reference to the triple for this instance.
65 const Triple &getTargetTriple() const { return TT; }
66
67 /// Returns a reference to the DataLayout for this instance.
68 const DataLayout &getDataLayout() const { return DL; }
69
70 /// Returns a reference to the JITDylib representing the JIT'd main program.
72
73 /// Returns the JITDylib with the given name, or nullptr if no JITDylib with
74 /// that name exists.
76 return ES->getJITDylibByName(Name);
77 }
78
79 /// Create a new JITDylib with the given name and return a reference to it.
80 ///
81 /// JITDylib names must be unique. If the given name is derived from user
82 /// input or elsewhere in the environment then the client should check
83 /// (e.g. by calling getJITDylibByName) that the given name is not already in
84 /// use.
86 return ES->createJITDylib(std::move(Name));
87 }
88
89 /// Adds an IR module with the given ResourceTracker.
91
92 /// Adds an IR module to the given JITDylib.
94
95 /// Adds an IR module to the Main JITDylib.
97 return addIRModule(*Main, std::move(TSM));
98 }
99
100 /// Adds an object file to the given JITDylib.
101 Error addObjectFile(ResourceTrackerSP RT, std::unique_ptr<MemoryBuffer> Obj);
102
103 /// Adds an object file to the given JITDylib.
104 Error addObjectFile(JITDylib &JD, std::unique_ptr<MemoryBuffer> Obj);
105
106 /// Adds an object file to the given JITDylib.
107 Error addObjectFile(std::unique_ptr<MemoryBuffer> Obj) {
108 return addObjectFile(*Main, std::move(Obj));
109 }
110
111 /// Look up a symbol in JITDylib JD by the symbol's linker-mangled name (to
112 /// look up symbols based on their IR name use the lookup function instead).
115
116 /// Look up a symbol in JITDylib JD by the symbol's linker-mangled name (to
117 /// look up symbols based on their IR name use the lookup function instead).
119 StringRef Name) {
120 return lookupLinkerMangled(JD, ES->intern(Name));
121 }
122
123 /// Look up a symbol in the main JITDylib by the symbol's linker-mangled name
124 /// (to look up symbols based on their IR name use the lookup function
125 /// instead).
127 return lookupLinkerMangled(*Main, Name);
128 }
129
130 /// Look up a symbol in JITDylib JD based on its IR symbol name.
132 return lookupLinkerMangled(JD, mangle(UnmangledName));
133 }
134
135 /// Look up a symbol in the main JITDylib based on its IR symbol name.
137 return lookup(*Main, UnmangledName);
138 }
139
140 /// Set the PlatformSupport instance.
141 void setPlatformSupport(std::unique_ptr<PlatformSupport> PS) {
142 this->PS = std::move(PS);
143 }
144
145 /// Get the PlatformSupport instance.
147
148 /// Run the initializers for the given JITDylib.
150 DEBUG_WITH_TYPE("orc", {
151 dbgs() << "LLJIT running initializers for JITDylib \"" << JD.getName()
152 << "\"\n";
153 });
154 assert(PS && "PlatformSupport must be set to run initializers.");
155 return PS->initialize(JD);
156 }
157
158 /// Run the deinitializers for the given JITDylib.
160 DEBUG_WITH_TYPE("orc", {
161 dbgs() << "LLJIT running deinitializers for JITDylib \"" << JD.getName()
162 << "\"\n";
163 });
164 assert(PS && "PlatformSupport must be set to run initializers.");
165 return PS->deinitialize(JD);
166 }
167
168 /// Returns a reference to the ObjLinkingLayer
170
171 /// Returns a reference to the object transform layer.
173
174 /// Returns a reference to the IR transform layer.
176
177 /// Returns a reference to the IR compile layer.
179
180 /// Returns a linker-mangled version of UnmangledName.
181 std::string mangle(StringRef UnmangledName) const;
182
183 /// Returns an interned, linker-mangled version of UnmangledName.
185 return ES->intern(mangle(UnmangledName));
186 }
187
188protected:
191
194
195 /// Create an LLJIT instance with a single compile thread.
196 LLJIT(LLJITBuilderState &S, Error &Err);
197
199
201
202 std::unique_ptr<ExecutionSession> ES;
203 std::unique_ptr<PlatformSupport> PS;
204
205 JITDylib *Main = nullptr;
206
209 std::unique_ptr<ThreadPool> CompileThreads;
210
211 std::unique_ptr<ObjectLayer> ObjLinkingLayer;
212 std::unique_ptr<ObjectTransformLayer> ObjTransformLayer;
213 std::unique_ptr<IRCompileLayer> CompileLayer;
214 std::unique_ptr<IRTransformLayer> TransformLayer;
215 std::unique_ptr<IRTransformLayer> InitHelperTransformLayer;
216};
217
218/// An extended version of LLJIT that supports lazy function-at-a-time
219/// compilation of LLVM IR.
220class LLLazyJIT : public LLJIT {
221 template <typename, typename, typename> friend class LLJITBuilderSetters;
222
223public:
224
225 /// Sets the partition function.
226 void
228 CODLayer->setPartitionFunction(std::move(Partition));
229 }
230
231 /// Returns a reference to the on-demand layer.
233
234 /// Add a module to be lazily compiled to JITDylib JD.
236
237 /// Add a module to be lazily compiled to the main JITDylib.
239 return addLazyIRModule(*Main, std::move(M));
240 }
241
242private:
243
244 // Create a single-threaded LLLazyJIT instance.
246
247 std::unique_ptr<LazyCallThroughManager> LCTMgr;
248 std::unique_ptr<CompileOnDemandLayer> CODLayer;
249};
250
252public:
254 std::function<Expected<std::unique_ptr<ObjectLayer>>(ExecutionSession &,
255 const Triple &)>;
256
258 std::function<Expected<std::unique_ptr<IRCompileLayer::IRCompiler>>(
260
261 using PlatformSetupFunction = std::function<Error(LLJIT &J)>;
262
263 std::unique_ptr<ExecutorProcessControl> EPC;
264 std::unique_ptr<ExecutionSession> ES;
265 std::optional<JITTargetMachineBuilder> JTMB;
266 std::optional<DataLayout> DL;
270 unsigned NumCompileThreads = 0;
271
272 /// Called prior to JIT class construcion to fix up defaults.
274};
275
276template <typename JITType, typename SetterImpl, typename State>
278public:
279 /// Set a ExecutorProcessControl for this instance.
280 /// This should not be called if ExecutionSession has already been set.
281 SetterImpl &
282 setExecutorProcessControl(std::unique_ptr<ExecutorProcessControl> EPC) {
283 assert(
284 !impl().ES &&
285 "setExecutorProcessControl should not be called if an ExecutionSession "
286 "has already been set");
287 impl().EPC = std::move(EPC);
288 return impl();
289 }
290
291 /// Set an ExecutionSession for this instance.
292 SetterImpl &setExecutionSession(std::unique_ptr<ExecutionSession> ES) {
293 impl().ES = std::move(ES);
294 return impl();
295 }
296
297 /// Set the JITTargetMachineBuilder for this instance.
298 ///
299 /// If this method is not called, JITTargetMachineBuilder::detectHost will be
300 /// used to construct a default target machine builder for the host platform.
302 impl().JTMB = std::move(JTMB);
303 return impl();
304 }
305
306 /// Return a reference to the JITTargetMachineBuilder.
307 ///
308 std::optional<JITTargetMachineBuilder> &getJITTargetMachineBuilder() {
309 return impl().JTMB;
310 }
311
312 /// Set a DataLayout for this instance. If no data layout is specified then
313 /// the target's default data layout will be used.
314 SetterImpl &setDataLayout(std::optional<DataLayout> DL) {
315 impl().DL = std::move(DL);
316 return impl();
317 }
318
319 /// Set an ObjectLinkingLayer creation function.
320 ///
321 /// If this method is not called, a default creation function will be used
322 /// that will construct an RTDyldObjectLinkingLayer.
324 LLJITBuilderState::ObjectLinkingLayerCreator CreateObjectLinkingLayer) {
325 impl().CreateObjectLinkingLayer = std::move(CreateObjectLinkingLayer);
326 return impl();
327 }
328
329 /// Set a CompileFunctionCreator.
330 ///
331 /// If this method is not called, a default creation function wil be used
332 /// that will construct a basic IR compile function that is compatible with
333 /// the selected number of threads (SimpleCompiler for '0' compile threads,
334 /// ConcurrentIRCompiler otherwise).
336 LLJITBuilderState::CompileFunctionCreator CreateCompileFunction) {
337 impl().CreateCompileFunction = std::move(CreateCompileFunction);
338 return impl();
339 }
340
341 /// Set up an PlatformSetupFunction.
342 ///
343 /// If this method is not called then setUpGenericLLVMIRPlatform
344 /// will be used to configure the JIT's platform support.
345 SetterImpl &
347 impl().SetUpPlatform = std::move(SetUpPlatform);
348 return impl();
349 }
350
351 /// Set the number of compile threads to use.
352 ///
353 /// If set to zero, compilation will be performed on the execution thread when
354 /// JITing in-process. If set to any other number N, a thread pool of N
355 /// threads will be created for compilation.
356 ///
357 /// If this method is not called, behavior will be as if it were called with
358 /// a zero argument.
359 SetterImpl &setNumCompileThreads(unsigned NumCompileThreads) {
360 impl().NumCompileThreads = NumCompileThreads;
361 return impl();
362 }
363
364 /// Set an ExecutorProcessControl object.
365 ///
366 /// If the platform uses ObjectLinkingLayer by default and no
367 /// ObjectLinkingLayerCreator has been set then the ExecutorProcessControl
368 /// object will be used to supply the memory manager for the
369 /// ObjectLinkingLayer.
371 impl().EPC = &EPC;
372 return impl();
373 }
374
375 /// Create an instance of the JIT.
377 if (auto Err = impl().prepareForConstruction())
378 return std::move(Err);
379
380 Error Err = Error::success();
381 std::unique_ptr<JITType> J(new JITType(impl(), Err));
382 if (Err)
383 return std::move(Err);
384 return std::move(J);
385 }
386
387protected:
388 SetterImpl &impl() { return static_cast<SetterImpl &>(*this); }
389};
390
391/// Constructs LLJIT instances.
393 : public LLJITBuilderState,
394 public LLJITBuilderSetters<LLJIT, LLJITBuilder, LLJITBuilderState> {};
395
397 friend class LLLazyJIT;
398
399public:
401 std::function<std::unique_ptr<IndirectStubsManager>()>;
402
405 std::unique_ptr<LazyCallThroughManager> LCTMgr;
407
409};
410
411template <typename JITType, typename SetterImpl, typename State>
413 : public LLJITBuilderSetters<JITType, SetterImpl, State> {
414public:
415 /// Set the address in the target address to call if a lazy compile fails.
416 ///
417 /// If this method is not called then the value will default to 0.
419 this->impl().LazyCompileFailureAddr = Addr;
420 return this->impl();
421 }
422
423 /// Set the lazy-callthrough manager.
424 ///
425 /// If this method is not called then a default, in-process lazy callthrough
426 /// manager for the host platform will be used.
427 SetterImpl &
428 setLazyCallthroughManager(std::unique_ptr<LazyCallThroughManager> LCTMgr) {
429 this->impl().LCTMgr = std::move(LCTMgr);
430 return this->impl();
431 }
432
433 /// Set the IndirectStubsManager builder function.
434 ///
435 /// If this method is not called then a default, in-process
436 /// IndirectStubsManager builder for the host platform will be used.
439 this->impl().ISMBuilder = std::move(ISMBuilder);
440 return this->impl();
441 }
442};
443
444/// Constructs LLLazyJIT instances.
446 : public LLLazyJITBuilderState,
447 public LLLazyJITBuilderSetters<LLLazyJIT, LLLazyJITBuilder,
448 LLLazyJITBuilderState> {};
449
450/// Configure the LLJIT instance to use orc runtime support.
452
453/// Configure the LLJIT instance to scrape modules for llvm.global_ctors and
454/// llvm.global_dtors variables and (if present) build initialization and
455/// deinitialization functions. Platform specific initialization configurations
456/// should be preferred where available.
458
459/// Configure the LLJIT instance to disable platform support explicitly. This is
460/// useful in two cases: for platforms that don't have such requirements and for
461/// platforms, that we have no explicit support yet and that don't work well
462/// with the generic IR platform.
464
465} // End namespace orc
466} // End namespace llvm
467
468#endif // LLVM_EXECUTIONENGINE_ORC_LLJIT_H
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
#define DEBUG_WITH_TYPE(TYPE, X)
DEBUG_WITH_TYPE macro - This macro should be used by passes to emit debug information.
Definition: Debug.h:64
uint64_t Addr
std::string Name
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
static ErrorSuccess success()
Create a success value.
Definition: Error.h:330
Tagged union holding either a T or a Error.
Definition: Error.h:470
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
std::function< std::optional< GlobalValueSet >(GlobalValueSet Requested)> PartitionFunction
Partitioning function.
An ExecutionSession represents a running JIT program.
Definition: Core.h:1373
Represents an address in the executor process.
ExecutorProcessControl supports interaction with a JIT target process.
A layer that applies a transform to emitted modules.
Represents a JIT'd dynamic library.
Definition: Core.h:962
A utility class for building TargetMachines for JITs.
SetterImpl & setExecutorProcessControl(ExecutorProcessControl &EPC)
Set an ExecutorProcessControl object.
Definition: LLJIT.h:370
std::optional< JITTargetMachineBuilder > & getJITTargetMachineBuilder()
Return a reference to the JITTargetMachineBuilder.
Definition: LLJIT.h:308
SetterImpl & setCompileFunctionCreator(LLJITBuilderState::CompileFunctionCreator CreateCompileFunction)
Set a CompileFunctionCreator.
Definition: LLJIT.h:335
SetterImpl & setNumCompileThreads(unsigned NumCompileThreads)
Set the number of compile threads to use.
Definition: LLJIT.h:359
SetterImpl & setDataLayout(std::optional< DataLayout > DL)
Set a DataLayout for this instance.
Definition: LLJIT.h:314
SetterImpl & setJITTargetMachineBuilder(JITTargetMachineBuilder JTMB)
Set the JITTargetMachineBuilder for this instance.
Definition: LLJIT.h:301
SetterImpl & setExecutorProcessControl(std::unique_ptr< ExecutorProcessControl > EPC)
Set a ExecutorProcessControl for this instance.
Definition: LLJIT.h:282
SetterImpl & setObjectLinkingLayerCreator(LLJITBuilderState::ObjectLinkingLayerCreator CreateObjectLinkingLayer)
Set an ObjectLinkingLayer creation function.
Definition: LLJIT.h:323
SetterImpl & setPlatformSetUp(LLJITBuilderState::PlatformSetupFunction SetUpPlatform)
Set up an PlatformSetupFunction.
Definition: LLJIT.h:346
Expected< std::unique_ptr< JITType > > create()
Create an instance of the JIT.
Definition: LLJIT.h:376
SetterImpl & setExecutionSession(std::unique_ptr< ExecutionSession > ES)
Set an ExecutionSession for this instance.
Definition: LLJIT.h:292
Error prepareForConstruction()
Called prior to JIT class construcion to fix up defaults.
Definition: LLJIT.cpp:659
ObjectLinkingLayerCreator CreateObjectLinkingLayer
Definition: LLJIT.h:267
std::function< Expected< std::unique_ptr< IRCompileLayer::IRCompiler > >(JITTargetMachineBuilder JTMB)> CompileFunctionCreator
Definition: LLJIT.h:259
std::function< Error(LLJIT &J)> PlatformSetupFunction
Definition: LLJIT.h:261
std::unique_ptr< ExecutionSession > ES
Definition: LLJIT.h:264
std::function< Expected< std::unique_ptr< ObjectLayer > >(ExecutionSession &, const Triple &)> ObjectLinkingLayerCreator
Definition: LLJIT.h:255
CompileFunctionCreator CreateCompileFunction
Definition: LLJIT.h:268
std::unique_ptr< ExecutorProcessControl > EPC
Definition: LLJIT.h:263
std::optional< DataLayout > DL
Definition: LLJIT.h:266
std::optional< JITTargetMachineBuilder > JTMB
Definition: LLJIT.h:265
PlatformSetupFunction SetUpPlatform
Definition: LLJIT.h:269
Constructs LLJIT instances.
Definition: LLJIT.h:394
Initializer support for LLJIT.
Definition: LLJIT.h:44
virtual Error deinitialize(JITDylib &JD)=0
virtual Error initialize(JITDylib &JD)=0
static void setInitTransform(LLJIT &J, IRTransformLayer::TransformFunction T)
Definition: LLJIT.cpp:652
A pre-fabricated ORC JIT stack that can serve as an alternative to MCJIT.
Definition: LLJIT.h:37
static Expected< std::unique_ptr< ObjectLayer > > createObjectLinkingLayer(LLJITBuilderState &S, ExecutionSession &ES)
Definition: LLJIT.cpp:797
void setPlatformSupport(std::unique_ptr< PlatformSupport > PS)
Set the PlatformSupport instance.
Definition: LLJIT.h:141
std::unique_ptr< ExecutionSession > ES
Definition: LLJIT.h:202
Error addObjectFile(ResourceTrackerSP RT, std::unique_ptr< MemoryBuffer > Obj)
Adds an object file to the given JITDylib.
Definition: LLJIT.cpp:775
Expected< JITDylib & > createJITDylib(std::string Name)
Create a new JITDylib with the given name and return a reference to it.
Definition: LLJIT.h:85
JITDylib & getMainJITDylib()
Returns a reference to the JITDylib representing the JIT'd main program.
Definition: LLJIT.h:71
const DataLayout & getDataLayout() const
Returns a reference to the DataLayout for this instance.
Definition: LLJIT.h:68
void recordCtorDtors(Module &M)
Error initialize(JITDylib &JD)
Run the initializers for the given JITDylib.
Definition: LLJIT.h:149
Error addIRModule(ThreadSafeModule TSM)
Adds an IR module to the Main JITDylib.
Definition: LLJIT.h:96
ObjectLayer & getObjLinkingLayer()
Returns a reference to the ObjLinkingLayer.
Definition: LLJIT.h:169
Expected< ExecutorAddr > lookupLinkerMangled(JITDylib &JD, StringRef Name)
Look up a symbol in JITDylib JD by the symbol's linker-mangled name (to look up symbols based on thei...
Definition: LLJIT.h:118
IRCompileLayer & getIRCompileLayer()
Returns a reference to the IR compile layer.
Definition: LLJIT.h:178
std::unique_ptr< ObjectTransformLayer > ObjTransformLayer
Definition: LLJIT.h:212
virtual ~LLJIT()
Destruct this instance.
Definition: LLJIT.cpp:754
IRTransformLayer & getIRTransformLayer()
Returns a reference to the IR transform layer.
Definition: LLJIT.h:175
std::string mangle(StringRef UnmangledName) const
Returns a linker-mangled version of UnmangledName.
Definition: LLJIT.cpp:925
JITDylib * Main
Definition: LLJIT.h:205
Expected< ExecutorAddr > lookup(JITDylib &JD, StringRef UnmangledName)
Look up a symbol in JITDylib JD based on its IR symbol name.
Definition: LLJIT.h:131
std::unique_ptr< IRTransformLayer > InitHelperTransformLayer
Definition: LLJIT.h:215
Error deinitialize(JITDylib &JD)
Run the deinitializers for the given JITDylib.
Definition: LLJIT.h:159
std::unique_ptr< IRCompileLayer > CompileLayer
Definition: LLJIT.h:213
Expected< ExecutorAddr > lookup(StringRef UnmangledName)
Look up a symbol in the main JITDylib based on its IR symbol name.
Definition: LLJIT.h:136
const Triple & getTargetTriple() const
Returns a reference to the triple for this instance.
Definition: LLJIT.h:65
Expected< ExecutorAddr > lookupLinkerMangled(JITDylib &JD, SymbolStringPtr Name)
Look up a symbol in JITDylib JD by the symbol's linker-mangled name (to look up symbols based on thei...
Definition: LLJIT.cpp:786
static Expected< std::unique_ptr< IRCompileLayer::IRCompiler > > createCompileFunction(LLJITBuilderState &S, JITTargetMachineBuilder JTMB)
Definition: LLJIT.cpp:826
PlatformSupport * getPlatformSupport()
Get the PlatformSupport instance.
Definition: LLJIT.h:146
ExecutionSession & getExecutionSession()
Returns the ExecutionSession for this instance.
Definition: LLJIT.h:62
std::unique_ptr< IRTransformLayer > TransformLayer
Definition: LLJIT.h:214
SymbolStringPtr mangleAndIntern(StringRef UnmangledName) const
Returns an interned, linker-mangled version of UnmangledName.
Definition: LLJIT.h:184
DataLayout DL
Definition: LLJIT.h:207
Error addObjectFile(std::unique_ptr< MemoryBuffer > Obj)
Adds an object file to the given JITDylib.
Definition: LLJIT.h:107
friend void setUpGenericLLVMIRPlatform(LLJIT &J)
Configure the LLJIT instance to scrape modules for llvm.global_ctors and llvm.global_dtors variables ...
Definition: LLJIT.cpp:955
Error applyDataLayout(Module &M)
Definition: LLJIT.cpp:934
std::unique_ptr< ThreadPool > CompileThreads
Definition: LLJIT.h:209
std::unique_ptr< ObjectLayer > ObjLinkingLayer
Definition: LLJIT.h:211
std::unique_ptr< PlatformSupport > PS
Definition: LLJIT.h:203
JITDylib * getJITDylibByName(StringRef Name)
Returns the JITDylib with the given name, or nullptr if no JITDylib with that name exists.
Definition: LLJIT.h:75
ObjectTransformLayer & getObjTransformLayer()
Returns a reference to the object transform layer.
Definition: LLJIT.h:172
Triple TT
Definition: LLJIT.h:208
Error addIRModule(ResourceTrackerSP RT, ThreadSafeModule TSM)
Adds an IR module with the given ResourceTracker.
Definition: LLJIT.cpp:761
Expected< ExecutorAddr > lookupLinkerMangled(StringRef Name)
Look up a symbol in the main JITDylib by the symbol's linker-mangled name (to look up symbols based o...
Definition: LLJIT.h:126
SetterImpl & setLazyCompileFailureAddr(ExecutorAddr Addr)
Set the address in the target address to call if a lazy compile fails.
Definition: LLJIT.h:418
SetterImpl & setLazyCallthroughManager(std::unique_ptr< LazyCallThroughManager > LCTMgr)
Set the lazy-callthrough manager.
Definition: LLJIT.h:428
SetterImpl & setIndirectStubsManagerBuilder(LLLazyJITBuilderState::IndirectStubsManagerBuilderFunction ISMBuilder)
Set the IndirectStubsManager builder function.
Definition: LLJIT.h:437
ExecutorAddr LazyCompileFailureAddr
Definition: LLJIT.h:404
std::unique_ptr< LazyCallThroughManager > LCTMgr
Definition: LLJIT.h:405
std::function< std::unique_ptr< IndirectStubsManager >()> IndirectStubsManagerBuilderFunction
Definition: LLJIT.h:401
IndirectStubsManagerBuilderFunction ISMBuilder
Definition: LLJIT.h:406
Constructs LLLazyJIT instances.
Definition: LLJIT.h:448
An extended version of LLJIT that supports lazy function-at-a-time compilation of LLVM IR.
Definition: LLJIT.h:220
void setPartitionFunction(CompileOnDemandLayer::PartitionFunction Partition)
Sets the partition function.
Definition: LLJIT.h:227
Error addLazyIRModule(ThreadSafeModule M)
Add a module to be lazily compiled to the main JITDylib.
Definition: LLJIT.h:238
CompileOnDemandLayer & getCompileOnDemandLayer()
Returns a reference to the on-demand layer.
Definition: LLJIT.h:232
Error addLazyIRModule(JITDylib &JD, ThreadSafeModule M)
Add a module to be lazily compiled to JITDylib JD.
Definition: LLJIT.cpp:975
Interface for Layers that accept object files.
Definition: Layer.h:133
Pointer to a pooled string representing a symbol name.
An LLVM Module together with a shared ThreadSafeContext.
Error setUpOrcPlatform(LLJIT &J)
Configure the LLJIT instance to use orc runtime support.
Definition: LLJIT.cpp:948
void setUpGenericLLVMIRPlatform(LLJIT &J)
Configure the LLJIT instance to scrape modules for llvm.global_ctors and llvm.global_dtors variables ...
Definition: LLJIT.cpp:955
Error setUpInactivePlatform(LLJIT &J)
Configure the LLJIT instance to disable platform support explicitly.
Definition: LLJIT.cpp:961
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163