LLVM  12.0.0git
ExecutionEngine.h
Go to the documentation of this file.
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 
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 
44  unsigned OptLevel;
49 };
50 
51 /*===-- Operations on generic values --------------------------------------===*/
52 
54  unsigned long long N,
55  LLVMBool IsSigned);
56 
58 
60 
62 
63 unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenVal,
64  LLVMBool IsSigned);
65 
67 
69 
71 
72 /*===-- Operations on execution engines -----------------------------------===*/
73 
75  LLVMModuleRef M,
76  char **OutError);
77 
79  LLVMModuleRef M,
80  char **OutError);
81 
83  LLVMModuleRef M,
84  unsigned OptLevel,
85  char **OutError);
86 
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  */
109  struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions,
110  char **OutError);
111 
113 
115 
117 
119  unsigned ArgC, const char * const *ArgV,
120  const char * const *EnvP);
121 
123  unsigned NumArgs,
125 
127 
129 
131  LLVMModuleRef *OutMod, char **OutError);
132 
134  LLVMValueRef *OutFn);
135 
137  LLVMValueRef Fn);
138 
142 
144  void* Addr);
145 
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.
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);
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  */
181  void *Opaque,
186 
188 
189 /*===-- JIT Event Listener functions -------------------------------------===*/
190 
195 
196 /**
197  * @}
198  */
199 
201 
202 #endif
uint8_t *(* LLVMMemoryManagerAllocateCodeSectionCallback)(void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID, const char *SectionName)
LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef Ty, double N)
void LLVMInitializeMCJITCompilerOptions(struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions)
struct LLVMOpaqueModule * LLVMModuleRef
The top-level container for all other LLVM Intermediate Representation (IR) objects.
Definition: Types.h:61
LLVMMCJITMemoryManagerRef MCJMM
struct LLVMOpaqueExecutionEngine * LLVMExecutionEngineRef
void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE)
void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal)
void * LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE, LLVMValueRef Fn)
F(f)
LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M, unsigned OptLevel, char **OutError)
double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal)
void * LLVMGenericValueToPointer(LLVMGenericValueRef GenVal)
struct LLVMOpaqueMCJITMemoryManager * LLVMMCJITMemoryManagerRef
struct LLVMOpaqueTargetData * LLVMTargetDataRef
Definition: DataLayout.h:39
LLVMJITEventListenerRef LLVMCreateOProfileJITEventListener(void)
LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P)
void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global, void *Addr)
uint64_t Addr
struct LLVMOpaqueType * LLVMTypeRef
Each value in the LLVM IR has a type, an LLVMTypeRef.
Definition: Types.h:68
uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name)
const char SectionName[]
Definition: AMDGPUPTNote.h:24
LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(void *Opaque, LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection, LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection, LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory, LLVMMemoryManagerDestroyCallback Destroy)
Create a simple custom MCJIT memory manager.
LLVMJITEventListenerRef LLVMCreateIntelJITEventListener(void)
int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F, unsigned ArgC, const char *const *ArgV, const char *const *EnvP)
#define P(N)
LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE, LLVMModuleRef M, char **OutError)
LLVMCodeModel
Definition: TargetMachine.h:48
void LLVMLinkInMCJIT(void)
Definition: MCJIT.cpp:40
LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty, unsigned long long N, LLVMBool IsSigned)
LLVMJITEventListenerRef LLVMCreatePerfJITEventListener(void)
LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE)
LLVMBool(* LLVMMemoryManagerFinalizeMemoryCallback)(void *Opaque, char **ErrMsg)
void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM)
typedefLLVM_C_EXTERN_C_BEGIN struct LLVMOpaqueTargetMachine * LLVMTargetMachineRef
Definition: TargetMachine.h:28
void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE)
int LLVMBool
Definition: Types.h:28
void * LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global)
uint8_t *(* LLVMMemoryManagerAllocateDataSectionCallback)(void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID, const char *SectionName, LLVMBool IsReadOnly)
LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp, LLVMModuleRef M, char **OutError)
LLVMJITEventListenerRef LLVMCreateGDBRegistrationListener(void)
void LLVMLinkInInterpreter(void)
Definition: Interpreter.cpp:30
void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE)
void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M)
uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name)
unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenVal, LLVMBool IsSigned)
LLVMTargetMachineRef LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE)
#define N
LLVMBool LLVMExecutionEngineGetErrMsg(LLVMExecutionEngineRef EE, char **OutError)
Returns true on error, false on success.
LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F, unsigned NumArgs, LLVMGenericValueRef *Args)
#define LLVM_C_EXTERN_C_END
Definition: ExternC.h:36
#define LLVM_C_EXTERN_C_BEGIN
Definition: ExternC.h:35
unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef)
void(* LLVMMemoryManagerDestroyCallback)(void *Opaque)
LLVMBool LLVMCreateMCJITCompilerForModule(LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M, struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions, char **OutError)
Create an MCJIT execution engine for a module, with the given options.
struct LLVMOpaqueJITEventListener * LLVMJITEventListenerRef
Definition: Types.h:163
void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F)
struct LLVMOpaqueGenericValue * LLVMGenericValueRef
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
struct LLVMOpaqueValue * LLVMValueRef
Represents an individual value in LLVM IR.
Definition: Types.h:75
LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name, LLVMValueRef *OutFn)
LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M, LLVMModuleRef *OutMod, char **OutError)