Line data Source code
1 : //===- ExecutionEngine.h - Abstract Execution Engine Interface --*- 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 : // This file defines the abstract interface that implements execution support
11 : // for LLVM.
12 : //
13 : //===----------------------------------------------------------------------===//
14 :
15 : #ifndef LLVM_EXECUTIONENGINE_EXECUTIONENGINE_H
16 : #define LLVM_EXECUTIONENGINE_EXECUTIONENGINE_H
17 :
18 : #include "llvm-c/ExecutionEngine.h"
19 : #include "llvm/ADT/ArrayRef.h"
20 : #include "llvm/ADT/Optional.h"
21 : #include "llvm/ADT/SmallVector.h"
22 : #include "llvm/ADT/StringMap.h"
23 : #include "llvm/ADT/StringRef.h"
24 : #include "llvm/ExecutionEngine/JITSymbol.h"
25 : #include "llvm/IR/DataLayout.h"
26 : #include "llvm/IR/Module.h"
27 : #include "llvm/Object/Binary.h"
28 : #include "llvm/Support/CBindingWrapping.h"
29 : #include "llvm/Support/CodeGen.h"
30 : #include "llvm/Support/ErrorHandling.h"
31 : #include "llvm/Support/Mutex.h"
32 : #include "llvm/Target/TargetMachine.h"
33 : #include "llvm/Target/TargetOptions.h"
34 : #include <algorithm>
35 : #include <cstdint>
36 : #include <functional>
37 : #include <map>
38 : #include <memory>
39 : #include <string>
40 : #include <vector>
41 :
42 : namespace llvm {
43 :
44 : class Constant;
45 : class Function;
46 : struct GenericValue;
47 : class GlobalValue;
48 : class GlobalVariable;
49 : class JITEventListener;
50 : class MCJITMemoryManager;
51 : class ObjectCache;
52 : class RTDyldMemoryManager;
53 : class Triple;
54 : class Type;
55 :
56 : namespace object {
57 :
58 : class Archive;
59 : class ObjectFile;
60 :
61 : } // end namespace object
62 :
63 : /// Helper class for helping synchronize access to the global address map
64 : /// table. Access to this class should be serialized under a mutex.
65 65 : class ExecutionEngineState {
66 : public:
67 : using GlobalAddressMapTy = StringMap<uint64_t>;
68 :
69 : private:
70 : /// GlobalAddressMap - A mapping between LLVM global symbol names values and
71 : /// their actualized version...
72 : GlobalAddressMapTy GlobalAddressMap;
73 :
74 : /// GlobalAddressReverseMap - This is the reverse mapping of GlobalAddressMap,
75 : /// used to convert raw addresses into the LLVM global value that is emitted
76 : /// at the address. This map is not computed unless getGlobalValueAtAddress
77 : /// is called at some point.
78 : std::map<uint64_t, std::string> GlobalAddressReverseMap;
79 :
80 : public:
81 : GlobalAddressMapTy &getGlobalAddressMap() {
82 437 : return GlobalAddressMap;
83 : }
84 :
85 : std::map<uint64_t, std::string> &getGlobalAddressReverseMap() {
86 1 : return GlobalAddressReverseMap;
87 : }
88 :
89 : /// Erase an entry from the mapping table.
90 : ///
91 : /// \returns The address that \p ToUnmap was happed to.
92 : uint64_t RemoveMapping(StringRef Name);
93 : };
94 :
95 : using FunctionCreator = std::function<void *(const std::string &)>;
96 :
97 : /// Abstract interface for implementation execution of LLVM modules,
98 : /// designed to support both interpreter and just-in-time (JIT) compiler
99 : /// implementations.
100 : class ExecutionEngine {
101 : /// The state object holding the global address mapping, which must be
102 : /// accessed synchronously.
103 : //
104 : // FIXME: There is no particular need the entire map needs to be
105 : // synchronized. Wouldn't a reader-writer design be better here?
106 : ExecutionEngineState EEState;
107 :
108 : /// The target data for the platform for which execution is being performed.
109 : ///
110 : /// Note: the DataLayout is LLVMContext specific because it has an
111 : /// internal cache based on type pointers. It makes unsafe to reuse the
112 : /// ExecutionEngine across context, we don't enforce this rule but undefined
113 : /// behavior can occurs if the user tries to do it.
114 : const DataLayout DL;
115 :
116 : /// Whether lazy JIT compilation is enabled.
117 : bool CompilingLazily;
118 :
119 : /// Whether JIT compilation of external global variables is allowed.
120 : bool GVCompilationDisabled;
121 :
122 : /// Whether the JIT should perform lookups of external symbols (e.g.,
123 : /// using dlsym).
124 : bool SymbolSearchingDisabled;
125 :
126 : /// Whether the JIT should verify IR modules during compilation.
127 : bool VerifyModules;
128 :
129 : friend class EngineBuilder; // To allow access to JITCtor and InterpCtor.
130 :
131 : protected:
132 : /// The list of Modules that we are JIT'ing from. We use a SmallVector to
133 : /// optimize for the case where there is only one module.
134 : SmallVector<std::unique_ptr<Module>, 1> Modules;
135 :
136 : /// getMemoryforGV - Allocate memory for a global variable.
137 : virtual char *getMemoryForGV(const GlobalVariable *GV);
138 :
139 : static ExecutionEngine *(*MCJITCtor)(
140 : std::unique_ptr<Module> M, std::string *ErrorStr,
141 : std::shared_ptr<MCJITMemoryManager> MM,
142 : std::shared_ptr<LegacyJITSymbolResolver> SR,
143 : std::unique_ptr<TargetMachine> TM);
144 :
145 : static ExecutionEngine *(*OrcMCJITReplacementCtor)(
146 : std::string *ErrorStr, std::shared_ptr<MCJITMemoryManager> MM,
147 : std::shared_ptr<LegacyJITSymbolResolver> SR,
148 : std::unique_ptr<TargetMachine> TM);
149 :
150 : static ExecutionEngine *(*InterpCtor)(std::unique_ptr<Module> M,
151 : std::string *ErrorStr);
152 :
153 : /// LazyFunctionCreator - If an unknown function is needed, this function
154 : /// pointer is invoked to create it. If this returns null, the JIT will
155 : /// abort.
156 : FunctionCreator LazyFunctionCreator;
157 :
158 : /// getMangledName - Get mangled name.
159 : std::string getMangledName(const GlobalValue *GV);
160 :
161 : public:
162 : /// lock - This lock protects the ExecutionEngine and MCJIT classes. It must
163 : /// be held while changing the internal state of any of those classes.
164 : sys::Mutex lock;
165 :
166 : //===--------------------------------------------------------------------===//
167 : // ExecutionEngine Startup
168 : //===--------------------------------------------------------------------===//
169 :
170 : virtual ~ExecutionEngine();
171 :
172 : /// Add a Module to the list of modules that we can JIT from.
173 0 : virtual void addModule(std::unique_ptr<Module> M) {
174 0 : Modules.push_back(std::move(M));
175 0 : }
176 :
177 : /// addObjectFile - Add an ObjectFile to the execution engine.
178 : ///
179 : /// This method is only supported by MCJIT. MCJIT will immediately load the
180 : /// object into memory and adds its symbols to the list used to resolve
181 : /// external symbols while preparing other objects for execution.
182 : ///
183 : /// Objects added using this function will not be made executable until
184 : /// needed by another object.
185 : ///
186 : /// MCJIT will take ownership of the ObjectFile.
187 : virtual void addObjectFile(std::unique_ptr<object::ObjectFile> O);
188 : virtual void addObjectFile(object::OwningBinary<object::ObjectFile> O);
189 :
190 : /// addArchive - Add an Archive to the execution engine.
191 : ///
192 : /// This method is only supported by MCJIT. MCJIT will use the archive to
193 : /// resolve external symbols in objects it is loading. If a symbol is found
194 : /// in the Archive the contained object file will be extracted (in memory)
195 : /// and loaded for possible execution.
196 : virtual void addArchive(object::OwningBinary<object::Archive> A);
197 :
198 : //===--------------------------------------------------------------------===//
199 :
200 810 : const DataLayout &getDataLayout() const { return DL; }
201 :
202 : /// removeModule - Removes a Module from the list of modules, but does not
203 : /// free the module's memory. Returns true if M is found, in which case the
204 : /// caller assumes responsibility for deleting the module.
205 : //
206 : // FIXME: This stealth ownership transfer is horrible. This will probably be
207 : // fixed by deleting ExecutionEngine.
208 : virtual bool removeModule(Module *M);
209 :
210 : /// FindFunctionNamed - Search all of the active modules to find the function that
211 : /// defines FnName. This is very slow operation and shouldn't be used for
212 : /// general code.
213 : virtual Function *FindFunctionNamed(StringRef FnName);
214 :
215 : /// FindGlobalVariableNamed - Search all of the active modules to find the global variable
216 : /// that defines Name. This is very slow operation and shouldn't be used for
217 : /// general code.
218 : virtual GlobalVariable *FindGlobalVariableNamed(StringRef Name, bool AllowInternal = false);
219 :
220 : /// runFunction - Execute the specified function with the specified arguments,
221 : /// and return the result.
222 : ///
223 : /// For MCJIT execution engines, clients are encouraged to use the
224 : /// "GetFunctionAddress" method (rather than runFunction) and cast the
225 : /// returned uint64_t to the desired function pointer type. However, for
226 : /// backwards compatibility MCJIT's implementation can execute 'main-like'
227 : /// function (i.e. those returning void or int, and taking either no
228 : /// arguments or (int, char*[])).
229 : virtual GenericValue runFunction(Function *F,
230 : ArrayRef<GenericValue> ArgValues) = 0;
231 :
232 : /// getPointerToNamedFunction - This method returns the address of the
233 : /// specified function by using the dlsym function call. As such it is only
234 : /// useful for resolving library symbols, not code generated symbols.
235 : ///
236 : /// If AbortOnFailure is false and no function with the given name is
237 : /// found, this function silently returns a null pointer. Otherwise,
238 : /// it prints a message to stderr and aborts.
239 : ///
240 : /// This function is deprecated for the MCJIT execution engine.
241 : virtual void *getPointerToNamedFunction(StringRef Name,
242 : bool AbortOnFailure = true) = 0;
243 :
244 : /// mapSectionAddress - map a section to its target address space value.
245 : /// Map the address of a JIT section as returned from the memory manager
246 : /// to the address in the target process as the running code will see it.
247 : /// This is the address which will be used for relocation resolution.
248 0 : virtual void mapSectionAddress(const void *LocalAddress,
249 : uint64_t TargetAddress) {
250 0 : llvm_unreachable("Re-mapping of section addresses not supported with this "
251 : "EE!");
252 : }
253 :
254 : /// generateCodeForModule - Run code generation for the specified module and
255 : /// load it into memory.
256 : ///
257 : /// When this function has completed, all code and data for the specified
258 : /// module, and any module on which this module depends, will be generated
259 : /// and loaded into memory, but relocations will not yet have been applied
260 : /// and all memory will be readable and writable but not executable.
261 : ///
262 : /// This function is primarily useful when generating code for an external
263 : /// target, allowing the client an opportunity to remap section addresses
264 : /// before relocations are applied. Clients that intend to execute code
265 : /// locally can use the getFunctionAddress call, which will generate code
266 : /// and apply final preparations all in one step.
267 : ///
268 : /// This method has no effect for the interpeter.
269 0 : virtual void generateCodeForModule(Module *M) {}
270 :
271 : /// finalizeObject - ensure the module is fully processed and is usable.
272 : ///
273 : /// It is the user-level function for completing the process of making the
274 : /// object usable for execution. It should be called after sections within an
275 : /// object have been relocated using mapSectionAddress. When this method is
276 : /// called the MCJIT execution engine will reapply relocations for a loaded
277 : /// object. This method has no effect for the interpeter.
278 0 : virtual void finalizeObject() {}
279 :
280 : /// runStaticConstructorsDestructors - This method is used to execute all of
281 : /// the static constructors or destructors for a program.
282 : ///
283 : /// \param isDtors - Run the destructors instead of constructors.
284 : virtual void runStaticConstructorsDestructors(bool isDtors);
285 :
286 : /// This method is used to execute all of the static constructors or
287 : /// destructors for a particular module.
288 : ///
289 : /// \param isDtors - Run the destructors instead of constructors.
290 : void runStaticConstructorsDestructors(Module &module, bool isDtors);
291 :
292 :
293 : /// runFunctionAsMain - This is a helper function which wraps runFunction to
294 : /// handle the common task of starting up main with the specified argc, argv,
295 : /// and envp parameters.
296 : int runFunctionAsMain(Function *Fn, const std::vector<std::string> &argv,
297 : const char * const * envp);
298 :
299 :
300 : /// addGlobalMapping - Tell the execution engine that the specified global is
301 : /// at the specified location. This is used internally as functions are JIT'd
302 : /// and as global variables are laid out in memory. It can and should also be
303 : /// used by clients of the EE that want to have an LLVM global overlay
304 : /// existing data in memory. Values to be mapped should be named, and have
305 : /// external or weak linkage. Mappings are automatically removed when their
306 : /// GlobalValue is destroyed.
307 : void addGlobalMapping(const GlobalValue *GV, void *Addr);
308 : void addGlobalMapping(StringRef Name, uint64_t Addr);
309 :
310 : /// clearAllGlobalMappings - Clear all global mappings and start over again,
311 : /// for use in dynamic compilation scenarios to move globals.
312 : void clearAllGlobalMappings();
313 :
314 : /// clearGlobalMappingsFromModule - Clear all global mappings that came from a
315 : /// particular module, because it has been removed from the JIT.
316 : void clearGlobalMappingsFromModule(Module *M);
317 :
318 : /// updateGlobalMapping - Replace an existing mapping for GV with a new
319 : /// address. This updates both maps as required. If "Addr" is null, the
320 : /// entry for the global is removed from the mappings. This returns the old
321 : /// value of the pointer, or null if it was not in the map.
322 : uint64_t updateGlobalMapping(const GlobalValue *GV, void *Addr);
323 : uint64_t updateGlobalMapping(StringRef Name, uint64_t Addr);
324 :
325 : /// getAddressToGlobalIfAvailable - This returns the address of the specified
326 : /// global symbol.
327 : uint64_t getAddressToGlobalIfAvailable(StringRef S);
328 :
329 : /// getPointerToGlobalIfAvailable - This returns the address of the specified
330 : /// global value if it is has already been codegen'd, otherwise it returns
331 : /// null.
332 : void *getPointerToGlobalIfAvailable(StringRef S);
333 : void *getPointerToGlobalIfAvailable(const GlobalValue *GV);
334 :
335 : /// getPointerToGlobal - This returns the address of the specified global
336 : /// value. This may involve code generation if it's a function.
337 : ///
338 : /// This function is deprecated for the MCJIT execution engine. Use
339 : /// getGlobalValueAddress instead.
340 : void *getPointerToGlobal(const GlobalValue *GV);
341 :
342 : /// getPointerToFunction - The different EE's represent function bodies in
343 : /// different ways. They should each implement this to say what a function
344 : /// pointer should look like. When F is destroyed, the ExecutionEngine will
345 : /// remove its global mapping and free any machine code. Be sure no threads
346 : /// are running inside F when that happens.
347 : ///
348 : /// This function is deprecated for the MCJIT execution engine. Use
349 : /// getFunctionAddress instead.
350 : virtual void *getPointerToFunction(Function *F) = 0;
351 :
352 : /// getPointerToFunctionOrStub - If the specified function has been
353 : /// code-gen'd, return a pointer to the function. If not, compile it, or use
354 : /// a stub to implement lazy compilation if available. See
355 : /// getPointerToFunction for the requirements on destroying F.
356 : ///
357 : /// This function is deprecated for the MCJIT execution engine. Use
358 : /// getFunctionAddress instead.
359 34 : virtual void *getPointerToFunctionOrStub(Function *F) {
360 : // Default implementation, just codegen the function.
361 34 : return getPointerToFunction(F);
362 : }
363 :
364 : /// getGlobalValueAddress - Return the address of the specified global
365 : /// value. This may involve code generation.
366 : ///
367 : /// This function should not be called with the interpreter engine.
368 0 : virtual uint64_t getGlobalValueAddress(const std::string &Name) {
369 : // Default implementation for the interpreter. MCJIT will override this.
370 : // JIT and interpreter clients should use getPointerToGlobal instead.
371 0 : return 0;
372 : }
373 :
374 : /// getFunctionAddress - Return the address of the specified function.
375 : /// This may involve code generation.
376 0 : virtual uint64_t getFunctionAddress(const std::string &Name) {
377 : // Default implementation for the interpreter. MCJIT will override this.
378 : // Interpreter clients should use getPointerToFunction instead.
379 0 : return 0;
380 : }
381 :
382 : /// getGlobalValueAtAddress - Return the LLVM global value object that starts
383 : /// at the specified address.
384 : ///
385 : const GlobalValue *getGlobalValueAtAddress(void *Addr);
386 :
387 : /// StoreValueToMemory - Stores the data in Val of type Ty at address Ptr.
388 : /// Ptr is the address of the memory at which to store Val, cast to
389 : /// GenericValue *. It is not a pointer to a GenericValue containing the
390 : /// address at which to store Val.
391 : void StoreValueToMemory(const GenericValue &Val, GenericValue *Ptr,
392 : Type *Ty);
393 :
394 : void InitializeMemory(const Constant *Init, void *Addr);
395 :
396 : /// getOrEmitGlobalVariable - Return the address of the specified global
397 : /// variable, possibly emitting it to memory if needed. This is used by the
398 : /// Emitter.
399 : ///
400 : /// This function is deprecated for the MCJIT execution engine. Use
401 : /// getGlobalValueAddress instead.
402 16 : virtual void *getOrEmitGlobalVariable(const GlobalVariable *GV) {
403 16 : return getPointerToGlobal((const GlobalValue *)GV);
404 : }
405 :
406 : /// Registers a listener to be called back on various events within
407 : /// the JIT. See JITEventListener.h for more details. Does not
408 : /// take ownership of the argument. The argument may be NULL, in
409 : /// which case these functions do nothing.
410 276 : virtual void RegisterJITEventListener(JITEventListener *) {}
411 0 : virtual void UnregisterJITEventListener(JITEventListener *) {}
412 :
413 : /// Sets the pre-compiled object cache. The ownership of the ObjectCache is
414 : /// not changed. Supported by MCJIT but not the interpreter.
415 0 : virtual void setObjectCache(ObjectCache *) {
416 0 : llvm_unreachable("No support for an object cache");
417 : }
418 :
419 : /// setProcessAllSections (MCJIT Only): By default, only sections that are
420 : /// "required for execution" are passed to the RTDyldMemoryManager, and other
421 : /// sections are discarded. Passing 'true' to this method will cause
422 : /// RuntimeDyld to pass all sections to its RTDyldMemoryManager regardless
423 : /// of whether they are "required to execute" in the usual sense.
424 : ///
425 : /// Rationale: Some MCJIT clients want to be able to inspect metadata
426 : /// sections (e.g. Dwarf, Stack-maps) to enable functionality or analyze
427 : /// performance. Passing these sections to the memory manager allows the
428 : /// client to make policy about the relevant sections, rather than having
429 : /// MCJIT do it.
430 0 : virtual void setProcessAllSections(bool ProcessAllSections) {
431 0 : llvm_unreachable("No support for ProcessAllSections option");
432 : }
433 :
434 : /// Return the target machine (if available).
435 0 : virtual TargetMachine *getTargetMachine() { return nullptr; }
436 :
437 : /// DisableLazyCompilation - When lazy compilation is off (the default), the
438 : /// JIT will eagerly compile every function reachable from the argument to
439 : /// getPointerToFunction. If lazy compilation is turned on, the JIT will only
440 : /// compile the one function and emit stubs to compile the rest when they're
441 : /// first called. If lazy compilation is turned off again while some lazy
442 : /// stubs are still around, and one of those stubs is called, the program will
443 : /// abort.
444 : ///
445 : /// In order to safely compile lazily in a threaded program, the user must
446 : /// ensure that 1) only one thread at a time can call any particular lazy
447 : /// stub, and 2) any thread modifying LLVM IR must hold the JIT's lock
448 : /// (ExecutionEngine::lock) or otherwise ensure that no other thread calls a
449 : /// lazy stub. See http://llvm.org/PR5184 for details.
450 : void DisableLazyCompilation(bool Disabled = true) {
451 181 : CompilingLazily = !Disabled;
452 : }
453 : bool isCompilingLazily() const {
454 : return CompilingLazily;
455 : }
456 :
457 : /// DisableGVCompilation - If called, the JIT will abort if it's asked to
458 : /// allocate space and populate a GlobalVariable that is not internal to
459 : /// the module.
460 : void DisableGVCompilation(bool Disabled = true) {
461 : GVCompilationDisabled = Disabled;
462 : }
463 : bool isGVCompilationDisabled() const {
464 : return GVCompilationDisabled;
465 : }
466 :
467 : /// DisableSymbolSearching - If called, the JIT will not try to lookup unknown
468 : /// symbols with dlsym. A client can still use InstallLazyFunctionCreator to
469 : /// resolve symbols in a custom way.
470 : void DisableSymbolSearching(bool Disabled = true) {
471 : SymbolSearchingDisabled = Disabled;
472 : }
473 0 : bool isSymbolSearchingDisabled() const {
474 0 : return SymbolSearchingDisabled;
475 : }
476 :
477 : /// Enable/Disable IR module verification.
478 : ///
479 : /// Note: Module verification is enabled by default in Debug builds, and
480 : /// disabled by default in Release. Use this method to override the default.
481 : void setVerifyModules(bool Verify) {
482 198 : VerifyModules = Verify;
483 : }
484 0 : bool getVerifyModules() const {
485 0 : return VerifyModules;
486 : }
487 :
488 : /// InstallLazyFunctionCreator - If an unknown function is needed, the
489 : /// specified function pointer is invoked to create it. If it returns null,
490 : /// the JIT will abort.
491 : void InstallLazyFunctionCreator(FunctionCreator C) {
492 2 : LazyFunctionCreator = std::move(C);
493 : }
494 :
495 : protected:
496 154 : ExecutionEngine(DataLayout DL) : DL(std::move(DL)) {}
497 : explicit ExecutionEngine(DataLayout DL, std::unique_ptr<Module> M);
498 : explicit ExecutionEngine(std::unique_ptr<Module> M);
499 :
500 : void emitGlobals();
501 :
502 : void EmitGlobalVariable(const GlobalVariable *GV);
503 :
504 : GenericValue getConstantValue(const Constant *C);
505 : void LoadValueFromMemory(GenericValue &Result, GenericValue *Ptr,
506 : Type *Ty);
507 :
508 : private:
509 : void Init(std::unique_ptr<Module> M);
510 : };
511 :
512 : namespace EngineKind {
513 :
514 : // These are actually bitmasks that get or-ed together.
515 : enum Kind {
516 : JIT = 0x1,
517 : Interpreter = 0x2
518 : };
519 : const static Kind Either = (Kind)(JIT | Interpreter);
520 :
521 : } // end namespace EngineKind
522 :
523 : /// Builder class for ExecutionEngines. Use this by stack-allocating a builder,
524 : /// chaining the various set* methods, and terminating it with a .create()
525 : /// call.
526 168 : class EngineBuilder {
527 : private:
528 : std::unique_ptr<Module> M;
529 : EngineKind::Kind WhichEngine;
530 : std::string *ErrorStr;
531 : CodeGenOpt::Level OptLevel;
532 : std::shared_ptr<MCJITMemoryManager> MemMgr;
533 : std::shared_ptr<LegacyJITSymbolResolver> Resolver;
534 : TargetOptions Options;
535 : Optional<Reloc::Model> RelocModel;
536 : Optional<CodeModel::Model> CMModel;
537 : std::string MArch;
538 : std::string MCPU;
539 : SmallVector<std::string, 4> MAttrs;
540 : bool VerifyModules;
541 : bool UseOrcMCJITReplacement;
542 : bool EmulatedTLS = true;
543 :
544 : public:
545 : /// Default constructor for EngineBuilder.
546 : EngineBuilder();
547 :
548 : /// Constructor for EngineBuilder.
549 : EngineBuilder(std::unique_ptr<Module> M);
550 :
551 : // Out-of-line since we don't have the def'n of RTDyldMemoryManager here.
552 : ~EngineBuilder();
553 :
554 : /// setEngineKind - Controls whether the user wants the interpreter, the JIT,
555 : /// or whichever engine works. This option defaults to EngineKind::Either.
556 : EngineBuilder &setEngineKind(EngineKind::Kind w) {
557 217 : WhichEngine = w;
558 : return *this;
559 : }
560 :
561 : /// setMCJITMemoryManager - Sets the MCJIT memory manager to use. This allows
562 : /// clients to customize their memory allocation policies for the MCJIT. This
563 : /// is only appropriate for the MCJIT; setting this and configuring the builder
564 : /// to create anything other than MCJIT will cause a runtime error. If create()
565 : /// is called and is successful, the created engine takes ownership of the
566 : /// memory manager. This option defaults to NULL.
567 : EngineBuilder &setMCJITMemoryManager(std::unique_ptr<RTDyldMemoryManager> mcjmm);
568 :
569 : EngineBuilder&
570 : setMemoryManager(std::unique_ptr<MCJITMemoryManager> MM);
571 :
572 : EngineBuilder &setSymbolResolver(std::unique_ptr<LegacyJITSymbolResolver> SR);
573 :
574 : /// setErrorStr - Set the error string to write to on error. This option
575 : /// defaults to NULL.
576 : EngineBuilder &setErrorStr(std::string *e) {
577 222 : ErrorStr = e;
578 : return *this;
579 : }
580 :
581 : /// setOptLevel - Set the optimization level for the JIT. This option
582 : /// defaults to CodeGenOpt::Default.
583 : EngineBuilder &setOptLevel(CodeGenOpt::Level l) {
584 217 : OptLevel = l;
585 : return *this;
586 : }
587 :
588 : /// setTargetOptions - Set the target options that the ExecutionEngine
589 : /// target is using. Defaults to TargetOptions().
590 : EngineBuilder &setTargetOptions(const TargetOptions &Opts) {
591 189 : Options = Opts;
592 : return *this;
593 : }
594 :
595 : /// setRelocationModel - Set the relocation model that the ExecutionEngine
596 : /// target is using. Defaults to target specific default "Reloc::Default".
597 : EngineBuilder &setRelocationModel(Reloc::Model RM) {
598 : RelocModel = RM;
599 : return *this;
600 : }
601 :
602 : /// setCodeModel - Set the CodeModel that the ExecutionEngine target
603 : /// data is using. Defaults to target specific default
604 : /// "CodeModel::JITDefault".
605 : EngineBuilder &setCodeModel(CodeModel::Model M) {
606 : CMModel = M;
607 : return *this;
608 : }
609 :
610 : /// setMArch - Override the architecture set by the Module's triple.
611 : EngineBuilder &setMArch(StringRef march) {
612 28 : MArch.assign(march.begin(), march.end());
613 : return *this;
614 : }
615 :
616 : /// setMCPU - Target a specific cpu type.
617 : EngineBuilder &setMCPU(StringRef mcpu) {
618 28 : MCPU.assign(mcpu.begin(), mcpu.end());
619 : return *this;
620 : }
621 :
622 : /// setVerifyModules - Set whether the JIT implementation should verify
623 : /// IR modules during compilation.
624 : EngineBuilder &setVerifyModules(bool Verify) {
625 : VerifyModules = Verify;
626 : return *this;
627 : }
628 :
629 : /// setMAttrs - Set cpu-specific attributes.
630 : template<typename StringSequence>
631 181 : EngineBuilder &setMAttrs(const StringSequence &mattrs) {
632 181 : MAttrs.clear();
633 181 : MAttrs.append(mattrs.begin(), mattrs.end());
634 181 : return *this;
635 : }
636 :
637 : // Use OrcMCJITReplacement instead of MCJIT. Off by default.
638 : void setUseOrcMCJITReplacement(bool UseOrcMCJITReplacement) {
639 181 : this->UseOrcMCJITReplacement = UseOrcMCJITReplacement;
640 : }
641 :
642 : void setEmulatedTLS(bool EmulatedTLS) {
643 : this->EmulatedTLS = EmulatedTLS;
644 : }
645 :
646 : TargetMachine *selectTarget();
647 :
648 : /// selectTarget - Pick a target either via -march or by guessing the native
649 : /// arch. Add any CPU features specified via -mcpu or -mattr.
650 : TargetMachine *selectTarget(const Triple &TargetTriple,
651 : StringRef MArch,
652 : StringRef MCPU,
653 : const SmallVectorImpl<std::string>& MAttrs);
654 :
655 : ExecutionEngine *create() {
656 222 : return create(selectTarget());
657 : }
658 :
659 : ExecutionEngine *create(TargetMachine *TM);
660 : };
661 :
662 : // Create wrappers for C Binding types (see CBindingWrapping.h).
663 : DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ExecutionEngine, LLVMExecutionEngineRef)
664 :
665 : } // end namespace llvm
666 :
667 : #endif // LLVM_EXECUTIONENGINE_EXECUTIONENGINE_H
|
