llvm/include/llvm-c/ExecutionEngine.h

   1 /*===-- llvm-c/ExecutionEngine.h - ExecutionEngine Lib C Iface --*- C++ -*-===*\
   2 |*                                                                            *|
   3 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
   4 |* Exceptions.                                                                *|
   5 |* See https://llvm.org/LICENSE.txt for license information.                  *|
   6 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
   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/ExternC.h"
  23 #include "llvm-c/Target.h"
  24 #include "llvm-c/TargetMachine.h"
  25 #include "llvm-c/Types.h"
  26
  27 LLVM_C_EXTERN_C_BEGIN
  28
  29 /**
  30  * @defgroup LLVMCExecutionEngine Execution Engine
  31  * @ingroup LLVMC
  32  *
  33  * @{
  34  */
  35
  36 void LLVMLinkInMCJIT(void);
  37 void LLVMLinkInInterpreter(void);
  38
  39 typedef struct LLVMOpaqueGenericValue *LLVMGenericValueRef;
  40 typedef struct LLVMOpaqueExecutionEngine *LLVMExecutionEngineRef;
  41 typedef struct LLVMOpaqueMCJITMemoryManager *LLVMMCJITMemoryManagerRef;
  42
  43 struct LLVMMCJITCompilerOptions {
  44   unsigned OptLevel;
  45   LLVMCodeModel CodeModel;
  46   LLVMBool NoFramePointerElim;
  47   LLVMBool EnableFastISel;
  48   LLVMMCJITMemoryManagerRef MCJMM;
  49 };
  50
  51 /*===-- Operations on generic values --------------------------------------===*/
  52
  53 LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
  54                                                 unsigned long long N,
  55                                                 LLVMBool IsSigned);
  56
  57 LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P);
  58
  59 LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef Ty, double N);
  60
  61 unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef);
  62
  63 unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenVal,
  64                                          LLVMBool IsSigned);
  65
  66 void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal);
  67
  68 double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal);
  69
  70 void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal);
  71
  72 /*===-- Operations on execution engines -----------------------------------===*/
  73
  74 LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
  75                                             LLVMModuleRef M,
  76                                             char **OutError);
  77
  78 LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
  79                                         LLVMModuleRef M,
  80                                         char **OutError);
  81
  82 LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
  83                                         LLVMModuleRef M,
  84                                         unsigned OptLevel,
  85                                         char **OutError);
  86
  87 void LLVMInitializeMCJITCompilerOptions(
  88   struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions);
  89
  90 /**
  91  * Create an MCJIT execution engine for a module, with the given options. It is
  92  * the responsibility of the caller to ensure that all fields in Options up to
  93  * the given SizeOfOptions are initialized. It is correct to pass a smaller
  94  * value of SizeOfOptions that omits some fields. The canonical way of using
  95  * this is:
  96  *
  97  * LLVMMCJITCompilerOptions options;
  98  * LLVMInitializeMCJITCompilerOptions(&options, sizeof(options));
  99  * ... fill in those options you care about
 100  * LLVMCreateMCJITCompilerForModule(&jit, mod, &options, sizeof(options),
 101  *                                  &error);
 102  *
 103  * Note that this is also correct, though possibly suboptimal:
 104  *
 105  * LLVMCreateMCJITCompilerForModule(&jit, mod, 0, 0, &error);
 106  */
 107 LLVMBool LLVMCreateMCJITCompilerForModule(
 108   LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M,
 109   struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions,
 110   char **OutError);
 111
 112 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE);
 113
 114 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE);
 115
 116 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE);
 117
 118 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
 119                           unsigned ArgC, const char * const *ArgV,
 120                           const char * const *EnvP);
 121
 122 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
 123                                     unsigned NumArgs,
 124                                     LLVMGenericValueRef *Args);
 125
 126 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F);
 127
 128 void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M);
 129
 130 LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
 131                           LLVMModuleRef *OutMod, char **OutError);
 132
 133 LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
 134                           LLVMValueRef *OutFn);
 135
 136 void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE,
 137                                      LLVMValueRef Fn);
 138
 139 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE);
 140 LLVMTargetMachineRef
 141 LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE);
 142
 143 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
 144                           void* Addr);
 145
 146 void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global);
 147
 148 uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name);
 149
 150 uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name);
 151
 152 /// Returns true on error, false on success. If true is returned then the error
 153 /// message is copied to OutStr and cleared in the ExecutionEngine instance.
 154 LLVMBool LLVMExecutionEngineGetErrMsg(LLVMExecutionEngineRef EE,
 155                                       char **OutError);
 156
 157 /*===-- Operations on memory managers -------------------------------------===*/
 158
 159 typedef uint8_t *(*LLVMMemoryManagerAllocateCodeSectionCallback)(
 160   void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
 161   const char *SectionName);
 162 typedef uint8_t *(*LLVMMemoryManagerAllocateDataSectionCallback)(
 163   void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
 164   const char *SectionName, LLVMBool IsReadOnly);
 165 typedef LLVMBool (*LLVMMemoryManagerFinalizeMemoryCallback)(
 166   void *Opaque, char **ErrMsg);
 167 typedef void (*LLVMMemoryManagerDestroyCallback)(void *Opaque);
 168
 169 /**
 170  * Create a simple custom MCJIT memory manager. This memory manager can
 171  * intercept allocations in a module-oblivious way. This will return NULL
 172  * if any of the passed functions are NULL.
 173  *
 174  * @param Opaque An opaque client object to pass back to the callbacks.
 175  * @param AllocateCodeSection Allocate a block of memory for executable code.
 176  * @param AllocateDataSection Allocate a block of memory for data.
 177  * @param FinalizeMemory Set page permissions and flush cache. Return 0 on
 178  *   success, 1 on error.
 179  */
 180 LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
 181   void *Opaque,
 182   LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
 183   LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
 184   LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
 185   LLVMMemoryManagerDestroyCallback Destroy);
 186
 187 void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM);
 188
 189 /*===-- JIT Event Listener functions -------------------------------------===*/
 190
 191 LLVMJITEventListenerRef LLVMCreateGDBRegistrationListener(void);
 192 LLVMJITEventListenerRef LLVMCreateIntelJITEventListener(void);
 193 LLVMJITEventListenerRef LLVMCreateOProfileJITEventListener(void);
 194 LLVMJITEventListenerRef LLVMCreatePerfJITEventListener(void);
 195
 196 /**
 197  * @}
 198  */
 199
 200 LLVM_C_EXTERN_C_END
 201
 202 #endif