| /*===-- llvm-c/ExecutionEngine.h - ExecutionEngine Lib C Iface --*- C++ -*-===*\ |
| |* *| |
| |* Part of the LLVM Project, under the Apache License v2.0 with LLVM *| |
| |* Exceptions. *| |
| |* See https://llvm.org/LICENSE.txt for license information. *| |
| |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception *| |
| |* *| |
| |*===----------------------------------------------------------------------===*| |
| |* *| |
| |* 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/Target.h" |
| #include "llvm-c/TargetMachine.h" |
| #include "llvm-c/Types.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); |
| |
| 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); |
| |
| LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M, |
| 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); |
| |
| /*===-- JIT Event Listener functions -------------------------------------===*/ |
| |
| LLVMJITEventListenerRef LLVMCreateGDBRegistrationListener(void); |
| LLVMJITEventListenerRef LLVMCreateIntelJITEventListener(void); |
| LLVMJITEventListenerRef LLVMCreateOProfileJITEventListener(void); |
| LLVMJITEventListenerRef LLVMCreatePerfJITEventListener(void); |
| |
| /** |
| * @} |
| */ |
| |
| #ifdef __cplusplus |
| } |
| #endif /* defined(__cplusplus) */ |
| |
| #endif |