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