summaryrefslogtreecommitdiffstats
path: root/include/llvm/ExecutionEngine
diff options
context:
space:
mode:
Diffstat (limited to 'include/llvm/ExecutionEngine')
-rw-r--r--include/llvm/ExecutionEngine/ExecutionEngine.h354
-rw-r--r--include/llvm/ExecutionEngine/GenericValue.h44
-rw-r--r--include/llvm/ExecutionEngine/Interpreter.h40
-rw-r--r--include/llvm/ExecutionEngine/JIT.h40
-rw-r--r--include/llvm/ExecutionEngine/JITMemoryManager.h135
5 files changed, 613 insertions, 0 deletions
diff --git a/include/llvm/ExecutionEngine/ExecutionEngine.h b/include/llvm/ExecutionEngine/ExecutionEngine.h
new file mode 100644
index 0000000..0d171f6
--- /dev/null
+++ b/include/llvm/ExecutionEngine/ExecutionEngine.h
@@ -0,0 +1,354 @@
+//===- ExecutionEngine.h - Abstract Execution Engine Interface --*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the abstract interface that implements execution support
+// for LLVM.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTION_ENGINE_H
+#define LLVM_EXECUTION_ENGINE_H
+
+#include <vector>
+#include <map>
+#include <string>
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/System/Mutex.h"
+#include "llvm/Target/TargetMachine.h"
+
+namespace llvm {
+
+struct GenericValue;
+class Constant;
+class Function;
+class GlobalVariable;
+class GlobalValue;
+class Module;
+class ModuleProvider;
+class TargetData;
+class Type;
+class MutexGuard;
+class JITMemoryManager;
+class MachineCodeInfo;
+
+class ExecutionEngineState {
+private:
+ /// GlobalAddressMap - A mapping between LLVM global values and their
+ /// actualized version...
+ std::map<const GlobalValue*, void *> GlobalAddressMap;
+
+ /// GlobalAddressReverseMap - This is the reverse mapping of GlobalAddressMap,
+ /// used to convert raw addresses into the LLVM global value that is emitted
+ /// at the address. This map is not computed unless getGlobalValueAtAddress
+ /// is called at some point.
+ std::map<void *, const GlobalValue*> GlobalAddressReverseMap;
+
+public:
+ std::map<const GlobalValue*, void *> &
+ getGlobalAddressMap(const MutexGuard &) {
+ return GlobalAddressMap;
+ }
+
+ std::map<void*, const GlobalValue*> &
+ getGlobalAddressReverseMap(const MutexGuard &) {
+ return GlobalAddressReverseMap;
+ }
+};
+
+
+class ExecutionEngine {
+ const TargetData *TD;
+ ExecutionEngineState state;
+ bool LazyCompilationDisabled;
+ bool GVCompilationDisabled;
+ bool SymbolSearchingDisabled;
+ bool DlsymStubsEnabled;
+
+protected:
+ /// Modules - This is a list of ModuleProvider's that we are JIT'ing from. We
+ /// use a smallvector to optimize for the case where there is only one module.
+ SmallVector<ModuleProvider*, 1> Modules;
+
+ void setTargetData(const TargetData *td) {
+ TD = td;
+ }
+
+ /// getMemoryforGV - Allocate memory for a global variable.
+ virtual char* getMemoryForGV(const GlobalVariable* GV);
+
+ // To avoid having libexecutionengine depend on the JIT and interpreter
+ // libraries, the JIT and Interpreter set these functions to ctor pointers
+ // at startup time if they are linked in.
+ typedef ExecutionEngine *(*EECtorFn)(ModuleProvider*, std::string*,
+ CodeGenOpt::Level OptLevel);
+ static EECtorFn JITCtor, InterpCtor;
+
+ /// LazyFunctionCreator - If an unknown function is needed, this function
+ /// pointer is invoked to create it. If this returns null, the JIT will abort.
+ void* (*LazyFunctionCreator)(const std::string &);
+
+ /// ExceptionTableRegister - If Exception Handling is set, the JIT will
+ /// register dwarf tables with this function
+ typedef void (*EERegisterFn)(void*);
+ static EERegisterFn ExceptionTableRegister;
+
+public:
+ /// lock - This lock is protects the ExecutionEngine, JIT, JITResolver and
+ /// JITEmitter classes. It must be held while changing the internal state of
+ /// any of those classes.
+ sys::Mutex lock; // Used to make this class and subclasses thread-safe
+
+ //===--------------------------------------------------------------------===//
+ // ExecutionEngine Startup
+ //===--------------------------------------------------------------------===//
+
+ virtual ~ExecutionEngine();
+
+ /// create - This is the factory method for creating an execution engine which
+ /// is appropriate for the current machine. This takes ownership of the
+ /// module provider.
+ static ExecutionEngine *create(ModuleProvider *MP,
+ bool ForceInterpreter = false,
+ std::string *ErrorStr = 0,
+ CodeGenOpt::Level OptLevel =
+ CodeGenOpt::Default);
+
+ /// create - This is the factory method for creating an execution engine which
+ /// is appropriate for the current machine. This takes ownership of the
+ /// module.
+ static ExecutionEngine *create(Module *M);
+
+ /// createJIT - This is the factory method for creating a JIT for the current
+ /// machine, it does not fall back to the interpreter. This takes ownership
+ /// of the ModuleProvider and JITMemoryManager if successful.
+ static ExecutionEngine *createJIT(ModuleProvider *MP,
+ std::string *ErrorStr = 0,
+ JITMemoryManager *JMM = 0,
+ CodeGenOpt::Level OptLevel =
+ CodeGenOpt::Default);
+
+ /// addModuleProvider - Add a ModuleProvider to the list of modules that we
+ /// can JIT from. Note that this takes ownership of the ModuleProvider: when
+ /// the ExecutionEngine is destroyed, it destroys the MP as well.
+ virtual void addModuleProvider(ModuleProvider *P) {
+ Modules.push_back(P);
+ }
+
+ //===----------------------------------------------------------------------===//
+
+ const TargetData *getTargetData() const { return TD; }
+
+
+ /// removeModuleProvider - Remove a ModuleProvider from the list of modules.
+ /// Relases the Module from the ModuleProvider, materializing it in the
+ /// process, and returns the materialized Module.
+ virtual Module* removeModuleProvider(ModuleProvider *P,
+ std::string *ErrInfo = 0);
+
+ /// deleteModuleProvider - Remove a ModuleProvider from the list of modules,
+ /// and deletes the ModuleProvider and owned Module. Avoids materializing
+ /// the underlying module.
+ virtual void deleteModuleProvider(ModuleProvider *P,std::string *ErrInfo = 0);
+
+ /// FindFunctionNamed - Search all of the active modules to find the one that
+ /// defines FnName. This is very slow operation and shouldn't be used for
+ /// general code.
+ Function *FindFunctionNamed(const char *FnName);
+
+ /// runFunction - Execute the specified function with the specified arguments,
+ /// and return the result.
+ ///
+ virtual GenericValue runFunction(Function *F,
+ const std::vector<GenericValue> &ArgValues) = 0;
+
+ /// runStaticConstructorsDestructors - This method is used to execute all of
+ /// the static constructors or destructors for a program, depending on the
+ /// value of isDtors.
+ void runStaticConstructorsDestructors(bool isDtors);
+ /// runStaticConstructorsDestructors - This method is used to execute all of
+ /// the static constructors or destructors for a module, depending on the
+ /// value of isDtors.
+ void runStaticConstructorsDestructors(Module *module, bool isDtors);
+
+
+ /// runFunctionAsMain - This is a helper function which wraps runFunction to
+ /// handle the common task of starting up main with the specified argc, argv,
+ /// and envp parameters.
+ int runFunctionAsMain(Function *Fn, const std::vector<std::string> &argv,
+ const char * const * envp);
+
+
+ /// addGlobalMapping - Tell the execution engine that the specified global is
+ /// at the specified location. This is used internally as functions are JIT'd
+ /// and as global variables are laid out in memory. It can and should also be
+ /// used by clients of the EE that want to have an LLVM global overlay
+ /// existing data in memory. After adding a mapping for GV, you must not
+ /// destroy it until you've removed the mapping.
+ void addGlobalMapping(const GlobalValue *GV, void *Addr);
+
+ /// clearAllGlobalMappings - Clear all global mappings and start over again
+ /// use in dynamic compilation scenarios when you want to move globals
+ void clearAllGlobalMappings();
+
+ /// clearGlobalMappingsFromModule - Clear all global mappings that came from a
+ /// particular module, because it has been removed from the JIT.
+ void clearGlobalMappingsFromModule(Module *M);
+
+ /// updateGlobalMapping - Replace an existing mapping for GV with a new
+ /// address. This updates both maps as required. If "Addr" is null, the
+ /// entry for the global is removed from the mappings. This returns the old
+ /// value of the pointer, or null if it was not in the map.
+ void *updateGlobalMapping(const GlobalValue *GV, void *Addr);
+
+ /// getPointerToGlobalIfAvailable - This returns the address of the specified
+ /// global value if it is has already been codegen'd, otherwise it returns
+ /// null.
+ ///
+ void *getPointerToGlobalIfAvailable(const GlobalValue *GV);
+
+ /// getPointerToGlobal - This returns the address of the specified global
+ /// value. This may involve code generation if it's a function. After
+ /// getting a pointer to GV, it and all globals it transitively refers to have
+ /// been passed to addGlobalMapping. You must clear the mapping for each
+ /// referred-to global before destroying it. If a referred-to global RTG is a
+ /// function and this ExecutionEngine is a JIT compiler, calling
+ /// updateGlobalMapping(RTG, 0) will leak the function's machine code, so you
+ /// should call freeMachineCodeForFunction(RTG) instead. Note that
+ /// optimizations can move and delete non-external GlobalValues without
+ /// notifying the ExecutionEngine.
+ ///
+ void *getPointerToGlobal(const GlobalValue *GV);
+
+ /// getPointerToFunction - The different EE's represent function bodies in
+ /// different ways. They should each implement this to say what a function
+ /// pointer should look like. See getPointerToGlobal for the requirements on
+ /// destroying F and any GlobalValues it refers to.
+ ///
+ virtual void *getPointerToFunction(Function *F) = 0;
+
+ /// getPointerToFunctionOrStub - If the specified function has been
+ /// code-gen'd, return a pointer to the function. If not, compile it, or use
+ /// a stub to implement lazy compilation if available. See getPointerToGlobal
+ /// for the requirements on destroying F and any GlobalValues it refers to.
+ ///
+ virtual void *getPointerToFunctionOrStub(Function *F) {
+ // Default implementation, just codegen the function.
+ return getPointerToFunction(F);
+ }
+
+ // The JIT overrides a version that actually does this.
+ virtual void runJITOnFunction(Function *F, MachineCodeInfo *MCI = 0) { }
+
+ /// getGlobalValueAtAddress - Return the LLVM global value object that starts
+ /// at the specified address.
+ ///
+ const GlobalValue *getGlobalValueAtAddress(void *Addr);
+
+
+ void StoreValueToMemory(const GenericValue &Val, GenericValue *Ptr,
+ const Type *Ty);
+ void InitializeMemory(const Constant *Init, void *Addr);
+
+ /// recompileAndRelinkFunction - This method is used to force a function
+ /// which has already been compiled to be compiled again, possibly
+ /// after it has been modified. Then the entry to the old copy is overwritten
+ /// with a branch to the new copy. If there was no old copy, this acts
+ /// just like VM::getPointerToFunction().
+ ///
+ virtual void *recompileAndRelinkFunction(Function *F) = 0;
+
+ /// freeMachineCodeForFunction - Release memory in the ExecutionEngine
+ /// corresponding to the machine code emitted to execute this function, useful
+ /// for garbage-collecting generated code.
+ ///
+ virtual void freeMachineCodeForFunction(Function *F) = 0;
+
+ /// getOrEmitGlobalVariable - Return the address of the specified global
+ /// variable, possibly emitting it to memory if needed. This is used by the
+ /// Emitter. See getPointerToGlobal for the requirements on destroying GV and
+ /// any GlobalValues it refers to.
+ virtual void *getOrEmitGlobalVariable(const GlobalVariable *GV) {
+ return getPointerToGlobal((GlobalValue*)GV);
+ }
+
+ /// DisableLazyCompilation - If called, the JIT will abort if lazy compilation
+ /// is ever attempted.
+ void DisableLazyCompilation(bool Disabled = true) {
+ LazyCompilationDisabled = Disabled;
+ }
+ bool isLazyCompilationDisabled() const {
+ return LazyCompilationDisabled;
+ }
+
+ /// DisableGVCompilation - If called, the JIT will abort if it's asked to
+ /// allocate space and populate a GlobalVariable that is not internal to
+ /// the module.
+ void DisableGVCompilation(bool Disabled = true) {
+ GVCompilationDisabled = Disabled;
+ }
+ bool isGVCompilationDisabled() const {
+ return GVCompilationDisabled;
+ }
+
+ /// DisableSymbolSearching - If called, the JIT will not try to lookup unknown
+ /// symbols with dlsym. A client can still use InstallLazyFunctionCreator to
+ /// resolve symbols in a custom way.
+ void DisableSymbolSearching(bool Disabled = true) {
+ SymbolSearchingDisabled = Disabled;
+ }
+ bool isSymbolSearchingDisabled() const {
+ return SymbolSearchingDisabled;
+ }
+
+ /// EnableDlsymStubs -
+ void EnableDlsymStubs(bool Enabled = true) {
+ DlsymStubsEnabled = Enabled;
+ }
+ bool areDlsymStubsEnabled() const {
+ return DlsymStubsEnabled;
+ }
+
+ /// InstallLazyFunctionCreator - If an unknown function is needed, the
+ /// specified function pointer is invoked to create it. If it returns null,
+ /// the JIT will abort.
+ void InstallLazyFunctionCreator(void* (*P)(const std::string &)) {
+ LazyFunctionCreator = P;
+ }
+
+ /// InstallExceptionTableRegister - The JIT will use the given function
+ /// to register the exception tables it generates.
+ static void InstallExceptionTableRegister(void (*F)(void*)) {
+ ExceptionTableRegister = F;
+ }
+
+ /// RegisterTable - Registers the given pointer as an exception table. It uses
+ /// the ExceptionTableRegister function.
+ static void RegisterTable(void* res) {
+ if (ExceptionTableRegister)
+ ExceptionTableRegister(res);
+ }
+
+protected:
+ explicit ExecutionEngine(ModuleProvider *P);
+
+ void emitGlobals();
+
+ // EmitGlobalVariable - This method emits the specified global variable to the
+ // address specified in GlobalAddresses, or allocates new memory if it's not
+ // already in the map.
+ void EmitGlobalVariable(const GlobalVariable *GV);
+
+ GenericValue getConstantValue(const Constant *C);
+ void LoadValueFromMemory(GenericValue &Result, GenericValue *Ptr,
+ const Type *Ty);
+};
+
+} // End llvm namespace
+
+#endif
diff --git a/include/llvm/ExecutionEngine/GenericValue.h b/include/llvm/ExecutionEngine/GenericValue.h
new file mode 100644
index 0000000..a2fed98
--- /dev/null
+++ b/include/llvm/ExecutionEngine/GenericValue.h
@@ -0,0 +1,44 @@
+//===-- GenericValue.h - Represent any type of LLVM value -------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// The GenericValue class is used to represent an LLVM value of arbitrary type.
+//
+//===----------------------------------------------------------------------===//
+
+
+#ifndef GENERIC_VALUE_H
+#define GENERIC_VALUE_H
+
+#include "llvm/ADT/APInt.h"
+#include "llvm/Support/DataTypes.h"
+
+namespace llvm {
+
+typedef void* PointerTy;
+class APInt;
+
+struct GenericValue {
+ union {
+ double DoubleVal;
+ float FloatVal;
+ PointerTy PointerVal;
+ struct { unsigned int first; unsigned int second; } UIntPairVal;
+ unsigned char Untyped[8];
+ };
+ APInt IntVal; // also used for long doubles
+
+ GenericValue() : DoubleVal(0.0), IntVal(1,0) {}
+ explicit GenericValue(void *V) : PointerVal(V), IntVal(1,0) { }
+};
+
+inline GenericValue PTOGV(void *P) { return GenericValue(P); }
+inline void* GVTOP(const GenericValue &GV) { return GV.PointerVal; }
+
+} // End llvm namespace
+#endif
diff --git a/include/llvm/ExecutionEngine/Interpreter.h b/include/llvm/ExecutionEngine/Interpreter.h
new file mode 100644
index 0000000..b2b0464
--- /dev/null
+++ b/include/llvm/ExecutionEngine/Interpreter.h
@@ -0,0 +1,40 @@
+//===-- Interpreter.h - Abstract Execution Engine Interface -----*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file forces the interpreter to link in on certain operating systems.
+// (Windows).
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef EXECUTION_ENGINE_INTERPRETER_H
+#define EXECUTION_ENGINE_INTERPRETER_H
+
+#include "llvm/ExecutionEngine/ExecutionEngine.h"
+#include <cstdlib>
+
+namespace llvm {
+ extern void LinkInInterpreter();
+}
+
+namespace {
+ struct ForceInterpreterLinking {
+ ForceInterpreterLinking() {
+ // We must reference the passes in such a way that compilers will not
+ // delete it all as dead code, even with whole program optimization,
+ // yet is effectively a NO-OP. As the compiler isn't smart enough
+ // to know that getenv() never returns -1, this will do the job.
+ if (std::getenv("bar") != (char*) -1)
+ return;
+
+ llvm::LinkInInterpreter();
+ }
+ } ForceInterpreterLinking;
+}
+
+#endif
diff --git a/include/llvm/ExecutionEngine/JIT.h b/include/llvm/ExecutionEngine/JIT.h
new file mode 100644
index 0000000..d4d1e73
--- /dev/null
+++ b/include/llvm/ExecutionEngine/JIT.h
@@ -0,0 +1,40 @@
+//===-- JIT.h - Abstract Execution Engine Interface -------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file forces the JIT to link in on certain operating systems.
+// (Windows).
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTION_ENGINE_JIT_H
+#define LLVM_EXECUTION_ENGINE_JIT_H
+
+#include "llvm/ExecutionEngine/ExecutionEngine.h"
+#include <cstdlib>
+
+namespace llvm {
+ extern void LinkInJIT();
+}
+
+namespace {
+ struct ForceJITLinking {
+ ForceJITLinking() {
+ // We must reference the passes in such a way that compilers will not
+ // delete it all as dead code, even with whole program optimization,
+ // yet is effectively a NO-OP. As the compiler isn't smart enough
+ // to know that getenv() never returns -1, this will do the job.
+ if (std::getenv("bar") != (char*) -1)
+ return;
+
+ llvm::LinkInJIT();
+ }
+ } ForceJITLinking;
+}
+
+#endif
diff --git a/include/llvm/ExecutionEngine/JITMemoryManager.h b/include/llvm/ExecutionEngine/JITMemoryManager.h
new file mode 100644
index 0000000..688a162
--- /dev/null
+++ b/include/llvm/ExecutionEngine/JITMemoryManager.h
@@ -0,0 +1,135 @@
+//===-- JITMemoryManager.h - Interface JIT uses to Allocate Mem -*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the JITMemoryManagerInterface
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTION_ENGINE_JIT_MEMMANAGER_H
+#define LLVM_EXECUTION_ENGINE_JIT_MEMMANAGER_H
+
+#include "llvm/Support/DataTypes.h"
+
+namespace llvm {
+ class Function;
+
+/// JITMemoryManager - This interface is used by the JIT to allocate and manage
+/// memory for the code generated by the JIT. This can be reimplemented by
+/// clients that have a strong desire to control how the layout of JIT'd memory
+/// works.
+class JITMemoryManager {
+protected:
+ bool HasGOT;
+ bool SizeRequired;
+public:
+ JITMemoryManager() : HasGOT(false), SizeRequired(false) {}
+ virtual ~JITMemoryManager();
+
+ /// CreateDefaultMemManager - This is used to create the default
+ /// JIT Memory Manager if the client does not provide one to the JIT.
+ static JITMemoryManager *CreateDefaultMemManager();
+
+ /// setMemoryWritable - When code generation is in progress,
+ /// the code pages may need permissions changed.
+ virtual void setMemoryWritable(void) = 0;
+
+ /// setMemoryExecutable - When code generation is done and we're ready to
+ /// start execution, the code pages may need permissions changed.
+ virtual void setMemoryExecutable(void) = 0;
+
+ //===--------------------------------------------------------------------===//
+ // Global Offset Table Management
+ //===--------------------------------------------------------------------===//
+
+ /// AllocateGOT - If the current table requires a Global Offset Table, this
+ /// method is invoked to allocate it. This method is required to set HasGOT
+ /// to true.
+ virtual void AllocateGOT() = 0;
+
+ /// isManagingGOT - Return true if the AllocateGOT method is called.
+ ///
+ bool isManagingGOT() const {
+ return HasGOT;
+ }
+
+ /// getGOTBase - If this is managing a Global Offset Table, this method should
+ /// return a pointer to its base.
+ virtual uint8_t *getGOTBase() const = 0;
+
+ /// SetDlsymTable - If the JIT must be able to relocate stubs after they have
+ /// been emitted, potentially because they are being copied to a process
+ /// where external symbols live at different addresses than in the JITing
+ /// process, allocate a table with sufficient information to do so.
+ virtual void SetDlsymTable(void *ptr) = 0;
+
+ /// getDlsymTable - If this is managing a table of entries so that stubs to
+ /// external symbols can be later relocated, this method should return a
+ /// pointer to it.
+ virtual void *getDlsymTable() const = 0;
+
+ /// NeedsExactSize - If the memory manager requires to know the size of the
+ /// objects to be emitted
+ bool NeedsExactSize() const {
+ return SizeRequired;
+ }
+
+ //===--------------------------------------------------------------------===//
+ // Main Allocation Functions
+ //===--------------------------------------------------------------------===//
+
+ /// startFunctionBody - When we start JITing a function, the JIT calls this
+ /// method to allocate a block of free RWX memory, which returns a pointer to
+ /// it. The JIT doesn't know ahead of time how much space it will need to
+ /// emit the function, so it doesn't pass in the size. Instead, this method
+ /// is required to pass back a "valid size". The JIT will be careful to not
+ /// write more than the returned ActualSize bytes of memory.
+ virtual uint8_t *startFunctionBody(const Function *F,
+ uintptr_t &ActualSize) = 0;
+
+ /// allocateStub - This method is called by the JIT to allocate space for a
+ /// function stub (used to handle limited branch displacements) while it is
+ /// JIT compiling a function. For example, if foo calls bar, and if bar
+ /// either needs to be lazily compiled or is a native function that exists too
+ /// far away from the call site to work, this method will be used to make a
+ /// thunk for it. The stub should be "close" to the current function body,
+ /// but should not be included in the 'actualsize' returned by
+ /// startFunctionBody.
+ virtual uint8_t *allocateStub(const GlobalValue* F, unsigned StubSize,
+ unsigned Alignment) = 0;
+
+ /// endFunctionBody - This method is called when the JIT is done codegen'ing
+ /// the specified function. At this point we know the size of the JIT
+ /// compiled function. This passes in FunctionStart (which was returned by
+ /// the startFunctionBody method) and FunctionEnd which is a pointer to the
+ /// actual end of the function. This method should mark the space allocated
+ /// and remember where it is in case the client wants to deallocate it.
+ virtual void endFunctionBody(const Function *F, uint8_t *FunctionStart,
+ uint8_t *FunctionEnd) = 0;
+
+ /// allocateSpace - Allocate a memory block of the given size.
+ virtual uint8_t *allocateSpace(intptr_t Size, unsigned Alignment) = 0;
+
+ /// deallocateMemForFunction - Free JIT memory for the specified function.
+ /// This is never called when the JIT is currently emitting a function.
+ virtual void deallocateMemForFunction(const Function *F) = 0;
+
+ /// startExceptionTable - When we finished JITing the function, if exception
+ /// handling is set, we emit the exception table.
+ virtual uint8_t* startExceptionTable(const Function* F,
+ uintptr_t &ActualSize) = 0;
+
+ /// endExceptionTable - This method is called when the JIT is done emitting
+ /// the exception table.
+ virtual void endExceptionTable(const Function *F, uint8_t *TableStart,
+ uint8_t *TableEnd, uint8_t* FrameRegister) = 0;
+};
+
+} // end namespace llvm.
+
+#endif
OpenPOWER on IntegriCloud