218 lines
8.8 KiB
C++
218 lines
8.8 KiB
C++
/*===-- llvm-c/ExecutionEngine.h - ExecutionEngine Lib C Iface --*- C++ -*-===*\
|
|
|* *|
|
|
|* The LLVM Compiler Infrastructure *|
|
|
|* *|
|
|
|* This file is distributed under the University of Illinois Open Source *|
|
|
|* License. See LICENSE.TXT for details. *|
|
|
|* *|
|
|
|*===----------------------------------------------------------------------===*|
|
|
|* *|
|
|
|* This header declares the C interface to libLLVMExecutionEngine.o, which *|
|
|
|* implements various analyses of the LLVM IR. *|
|
|
|* *|
|
|
|* Many exotic languages can interoperate with C code but have a harder time *|
|
|
|* with C++ due to name mangling. So in addition to C, this interface enables *|
|
|
|* tools written in such languages. *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
#ifndef LLVM_C_EXECUTIONENGINE_H
|
|
#define LLVM_C_EXECUTIONENGINE_H
|
|
|
|
#include "llvm-c/Core.h"
|
|
#include "llvm-c/Target.h"
|
|
#include "llvm-c/TargetMachine.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* @defgroup LLVMCExecutionEngine Execution Engine
|
|
* @ingroup LLVMC
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
void LLVMLinkInMCJIT(void);
|
|
void LLVMLinkInInterpreter(void);
|
|
|
|
typedef struct LLVMOpaqueGenericValue *LLVMGenericValueRef;
|
|
typedef struct LLVMOpaqueExecutionEngine *LLVMExecutionEngineRef;
|
|
typedef struct LLVMOpaqueMCJITMemoryManager *LLVMMCJITMemoryManagerRef;
|
|
|
|
struct LLVMMCJITCompilerOptions {
|
|
unsigned OptLevel;
|
|
LLVMCodeModel CodeModel;
|
|
LLVMBool NoFramePointerElim;
|
|
LLVMBool EnableFastISel;
|
|
LLVMMCJITMemoryManagerRef MCJMM;
|
|
};
|
|
|
|
/*===-- Operations on generic values --------------------------------------===*/
|
|
|
|
LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
|
|
unsigned long long N,
|
|
LLVMBool IsSigned);
|
|
|
|
LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P);
|
|
|
|
LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef Ty, double N);
|
|
|
|
unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef);
|
|
|
|
unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenVal,
|
|
LLVMBool IsSigned);
|
|
|
|
void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal);
|
|
|
|
double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal);
|
|
|
|
void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal);
|
|
|
|
/*===-- Operations on execution engines -----------------------------------===*/
|
|
|
|
LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
|
|
LLVMModuleRef M,
|
|
char **OutError);
|
|
|
|
LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
|
|
LLVMModuleRef M,
|
|
char **OutError);
|
|
|
|
LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
|
|
LLVMModuleRef M,
|
|
unsigned OptLevel,
|
|
char **OutError);
|
|
|
|
void LLVMInitializeMCJITCompilerOptions(
|
|
struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions);
|
|
|
|
/**
|
|
* Create an MCJIT execution engine for a module, with the given options. It is
|
|
* the responsibility of the caller to ensure that all fields in Options up to
|
|
* the given SizeOfOptions are initialized. It is correct to pass a smaller
|
|
* value of SizeOfOptions that omits some fields. The canonical way of using
|
|
* this is:
|
|
*
|
|
* LLVMMCJITCompilerOptions options;
|
|
* LLVMInitializeMCJITCompilerOptions(&options, sizeof(options));
|
|
* ... fill in those options you care about
|
|
* LLVMCreateMCJITCompilerForModule(&jit, mod, &options, sizeof(options),
|
|
* &error);
|
|
*
|
|
* Note that this is also correct, though possibly suboptimal:
|
|
*
|
|
* LLVMCreateMCJITCompilerForModule(&jit, mod, 0, 0, &error);
|
|
*/
|
|
LLVMBool LLVMCreateMCJITCompilerForModule(
|
|
LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M,
|
|
struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions,
|
|
char **OutError);
|
|
|
|
/** Deprecated: Use LLVMCreateExecutionEngineForModule instead. */
|
|
LLVMBool LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
|
|
LLVMModuleProviderRef MP,
|
|
char **OutError);
|
|
|
|
/** Deprecated: Use LLVMCreateInterpreterForModule instead. */
|
|
LLVMBool LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
|
|
LLVMModuleProviderRef MP,
|
|
char **OutError);
|
|
|
|
/** Deprecated: Use LLVMCreateJITCompilerForModule instead. */
|
|
LLVMBool LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
|
|
LLVMModuleProviderRef MP,
|
|
unsigned OptLevel,
|
|
char **OutError);
|
|
|
|
void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE);
|
|
|
|
void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE);
|
|
|
|
void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE);
|
|
|
|
int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
|
|
unsigned ArgC, const char * const *ArgV,
|
|
const char * const *EnvP);
|
|
|
|
LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
|
|
unsigned NumArgs,
|
|
LLVMGenericValueRef *Args);
|
|
|
|
void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F);
|
|
|
|
void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M);
|
|
|
|
/** Deprecated: Use LLVMAddModule instead. */
|
|
void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP);
|
|
|
|
LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
|
|
LLVMModuleRef *OutMod, char **OutError);
|
|
|
|
/** Deprecated: Use LLVMRemoveModule instead. */
|
|
LLVMBool LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
|
|
LLVMModuleProviderRef MP,
|
|
LLVMModuleRef *OutMod, char **OutError);
|
|
|
|
LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
|
|
LLVMValueRef *OutFn);
|
|
|
|
void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE,
|
|
LLVMValueRef Fn);
|
|
|
|
LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE);
|
|
LLVMTargetMachineRef
|
|
LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE);
|
|
|
|
void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
|
|
void* Addr);
|
|
|
|
void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global);
|
|
|
|
uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name);
|
|
|
|
uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name);
|
|
|
|
/*===-- Operations on memory managers -------------------------------------===*/
|
|
|
|
typedef uint8_t *(*LLVMMemoryManagerAllocateCodeSectionCallback)(
|
|
void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
|
|
const char *SectionName);
|
|
typedef uint8_t *(*LLVMMemoryManagerAllocateDataSectionCallback)(
|
|
void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
|
|
const char *SectionName, LLVMBool IsReadOnly);
|
|
typedef LLVMBool (*LLVMMemoryManagerFinalizeMemoryCallback)(
|
|
void *Opaque, char **ErrMsg);
|
|
typedef void (*LLVMMemoryManagerDestroyCallback)(void *Opaque);
|
|
|
|
/**
|
|
* Create a simple custom MCJIT memory manager. This memory manager can
|
|
* intercept allocations in a module-oblivious way. This will return NULL
|
|
* if any of the passed functions are NULL.
|
|
*
|
|
* @param Opaque An opaque client object to pass back to the callbacks.
|
|
* @param AllocateCodeSection Allocate a block of memory for executable code.
|
|
* @param AllocateDataSection Allocate a block of memory for data.
|
|
* @param FinalizeMemory Set page permissions and flush cache. Return 0 on
|
|
* success, 1 on error.
|
|
*/
|
|
LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
|
|
void *Opaque,
|
|
LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
|
|
LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
|
|
LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
|
|
LLVMMemoryManagerDestroyCallback Destroy);
|
|
|
|
void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM);
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* defined(__cplusplus) */
|
|
|
|
#endif
|