src/llvm/include/llvm-c/ExecutionEngine.h

   1 /*===-- llvm-c/ExecutionEngine.h - ExecutionEngine Lib C Iface --*- C++ -*-===*\
   2 |*                                                                            *|
   3 |*                     The LLVM Compiler Infrastructure                       *|
   4 |*                                                                            *|
   5 |* This file is distributed under the University of Illinois Open Source      *|
   6 |* License. See LICENSE.TXT for details.                                      *|
   7 |*                                                                            *|
   8 |*===----------------------------------------------------------------------===*|
   9 |*                                                                            *|
  10 |* This header declares the C interface to libLLVMExecutionEngine.o, which    *|
  11 |* implements various analyses of the LLVM IR.                                *|
  12 |*                                                                            *|
  13 |* Many exotic languages can interoperate with C code but have a harder time  *|
  14 |* with C++ due to name mangling. So in addition to C, this interface enables *|
  15 |* tools written in such languages.                                           *|
  16 |*                                                                            *|
  17 \*===----------------------------------------------------------------------===*/
  18
  19 #ifndef LLVM_C_EXECUTIONENGINE_H
  20 #define LLVM_C_EXECUTIONENGINE_H
  21
  22 #include "llvm-c/Core.h"
  23 #include "llvm-c/Target.h"
  24 #include "llvm-c/TargetMachine.h"
  25
  26 #ifdef __cplusplus
  27 extern "C" {
  28 #endif
  29
  30 /**
  31  * @defgroup LLVMCExecutionEngine Execution Engine
  32  * @ingroup LLVMC
  33  *
  34  * @{
  35  */
  36
  37 void LLVMLinkInMCJIT(void);
  38 void LLVMLinkInInterpreter(void);
  39
  40 typedef struct LLVMOpaqueGenericValue *LLVMGenericValueRef;
  41 typedef struct LLVMOpaqueExecutionEngine *LLVMExecutionEngineRef;
  42 typedef struct LLVMOpaqueMCJITMemoryManager *LLVMMCJITMemoryManagerRef;
  43
  44 struct LLVMMCJITCompilerOptions {
  45   unsigned OptLevel;
  46   LLVMCodeModel CodeModel;
  47   LLVMBool NoFramePointerElim;
  48   LLVMBool EnableFastISel;
  49   LLVMMCJITMemoryManagerRef MCJMM;
  50 };
  51
  52 /*===-- Operations on generic values --------------------------------------===*/
  53
  54 LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
  55                                                 unsigned long long N,
  56                                                 LLVMBool IsSigned);
  57
  58 LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P);
  59
  60 LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef Ty, double N);
  61
  62 unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef);
  63
  64 unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenVal,
  65                                          LLVMBool IsSigned);
  66
  67 void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal);
  68
  69 double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal);
  70
  71 void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal);
  72
  73 /*===-- Operations on execution engines -----------------------------------===*/
  74
  75 LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
  76                                             LLVMModuleRef M,
  77                                             char **OutError);
  78
  79 LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
  80                                         LLVMModuleRef M,
  81                                         char **OutError);
  82
  83 LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
  84                                         LLVMModuleRef M,
  85                                         unsigned OptLevel,
  86                                         char **OutError);
  87
  88 void LLVMInitializeMCJITCompilerOptions(
  89   struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions);
  90
  91 /**
  92  * Create an MCJIT execution engine for a module, with the given options. It is
  93  * the responsibility of the caller to ensure that all fields in Options up to
  94  * the given SizeOfOptions are initialized. It is correct to pass a smaller
  95  * value of SizeOfOptions that omits some fields. The canonical way of using
  96  * this is:
  97  *
  98  * LLVMMCJITCompilerOptions options;
  99  * LLVMInitializeMCJITCompilerOptions(&options, sizeof(options));
 100  * ... fill in those options you care about
 101  * LLVMCreateMCJITCompilerForModule(&jit, mod, &options, sizeof(options),
 102  *                                  &error);
 103  *
 104  * Note that this is also correct, though possibly suboptimal:
 105  *
 106  * LLVMCreateMCJITCompilerForModule(&jit, mod, 0, 0, &error);
 107  */
 108 LLVMBool LLVMCreateMCJITCompilerForModule(
 109   LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M,
 110   struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions,
 111   char **OutError);
 112
 113 /** Deprecated: Use LLVMCreateExecutionEngineForModule instead. */
 114 LLVMBool LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
 115                                    LLVMModuleProviderRef MP,
 116                                    char **OutError);
 117
 118 /** Deprecated: Use LLVMCreateInterpreterForModule instead. */
 119 LLVMBool LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
 120                                LLVMModuleProviderRef MP,
 121                                char **OutError);
 122
 123 /** Deprecated: Use LLVMCreateJITCompilerForModule instead. */
 124 LLVMBool LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
 125                                LLVMModuleProviderRef MP,
 126                                unsigned OptLevel,
 127                                char **OutError);
 128
 129 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE);
 130
 131 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE);
 132
 133 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE);
 134
 135 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
 136                           unsigned ArgC, const char * const *ArgV,
 137                           const char * const *EnvP);
 138
 139 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
 140                                     unsigned NumArgs,
 141                                     LLVMGenericValueRef *Args);
 142
 143 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F);
 144
 145 void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M);
 146
 147 /** Deprecated: Use LLVMAddModule instead. */
 148 void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP);
 149
 150 LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
 151                           LLVMModuleRef *OutMod, char **OutError);
 152
 153 /** Deprecated: Use LLVMRemoveModule instead. */
 154 LLVMBool LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
 155                                   LLVMModuleProviderRef MP,
 156                                   LLVMModuleRef *OutMod, char **OutError);
 157
 158 LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
 159                           LLVMValueRef *OutFn);
 160
 161 void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE,
 162                                      LLVMValueRef Fn);
 163
 164 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE);
 165 LLVMTargetMachineRef
 166 LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE);
 167
 168 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
 169                           void* Addr);
 170
 171 void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global);
 172
 173 uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name);
 174
 175 uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name);
 176
 177 /*===-- Operations on memory managers -------------------------------------===*/
 178
 179 typedef uint8_t *(*LLVMMemoryManagerAllocateCodeSectionCallback)(
 180   void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
 181   const char *SectionName);
 182 typedef uint8_t *(*LLVMMemoryManagerAllocateDataSectionCallback)(
 183   void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
 184   const char *SectionName, LLVMBool IsReadOnly);
 185 typedef LLVMBool (*LLVMMemoryManagerFinalizeMemoryCallback)(
 186   void *Opaque, char **ErrMsg);
 187 typedef void (*LLVMMemoryManagerDestroyCallback)(void *Opaque);
 188
 189 /**
 190  * Create a simple custom MCJIT memory manager. This memory manager can
 191  * intercept allocations in a module-oblivious way. This will return NULL
 192  * if any of the passed functions are NULL.
 193  *
 194  * @param Opaque An opaque client object to pass back to the callbacks.
 195  * @param AllocateCodeSection Allocate a block of memory for executable code.
 196  * @param AllocateDataSection Allocate a block of memory for data.
 197  * @param FinalizeMemory Set page permissions and flush cache. Return 0 on
 198  *   success, 1 on error.
 199  */
 200 LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
 201   void *Opaque,
 202   LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
 203   LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
 204   LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
 205   LLVMMemoryManagerDestroyCallback Destroy);
 206
 207 void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM);
 208
 209 /**
 210  * @}
 211  */
 212
 213 #ifdef __cplusplus
 214 }
 215 #endif /* defined(__cplusplus) */
 216
 217 #endif