1 //===- ExecutionEngine.h - Abstract Execution Engine Interface --*- C++ -*-===//
3 // This file defines the abstract interface that implements execution support
6 //===----------------------------------------------------------------------===//
8 #ifndef EXECUTION_ENGINE_H
9 #define EXECUTION_ENGINE_H
23 class ExecutionEngine {
28 // GlobalAddress - A mapping between LLVM global values and their actualized
30 std::map<const GlobalValue*, void *> GlobalAddress;
32 void setTargetData(const TargetData &td) {
36 ExecutionEngine(Module *M) : CurMod(*M) {
37 assert(M && "Module is null?");
39 virtual ~ExecutionEngine();
41 Module &getModule() const { return CurMod; }
42 const TargetData &getTargetData() const { return *TD; }
44 /// run - Start execution with the specified function, arguments, and
47 virtual int run(const std::string &FnName,
48 const std::vector<std::string> &Args,
49 const char ** envp) = 0;
51 static ExecutionEngine *create (Module *M, bool ForceInterpreter,
54 /// createJIT - Create an return a new JIT compiler if there is one available
55 /// for the current target. Otherwise it returns null.
57 static ExecutionEngine *createJIT(Module *M);
59 /// createInterpreter - Create a new interpreter object. This can never fail.
61 static ExecutionEngine *createInterpreter(Module *M, bool TraceMode);
63 void addGlobalMapping(const Function *F, void *Addr) {
64 void *&CurVal = GlobalAddress[(const GlobalValue*)F];
65 assert(CurVal == 0 && "GlobalMapping already established!");
69 // getPointerToGlobalIfAvailable - This returns the address of the specified
70 // global value if it is available, otherwise it returns null.
72 void *getPointerToGlobalIfAvailable(const GlobalValue *GV) {
73 std::map<const GlobalValue*, void*>::iterator I = GlobalAddress.find(GV);
74 return I != GlobalAddress.end() ? I->second : 0;
77 // getPointerToGlobal - This returns the address of the specified global
78 // value. This may involve code generation if it's a function.
80 void *getPointerToGlobal(const GlobalValue *GV);
82 // getPointerToFunction - The different EE's represent function bodies in
83 // different ways. They should each implement this to say what a function
84 // pointer should look like.
86 virtual void *getPointerToFunction(Function *F) = 0;
91 public: // FIXME: protected: // API shared among subclasses
92 GenericValue getConstantValue(const Constant *C);
93 void StoreValueToMemory(GenericValue Val, GenericValue *Ptr, const Type *Ty);
94 GenericValue LoadValueFromMemory(GenericValue *Ptr, const Type *Ty);
95 void *CreateArgv(const std::vector<std::string> &InputArgv);
96 void InitializeMemory(const Constant *Init, void *Addr);