LLVM  8.0.0svn
ExecutionEngine.h
Go to the documentation of this file.
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/Target.h"
23 #include "llvm-c/TargetMachine.h"
24 #include "llvm-c/Types.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 
45  unsigned OptLevel;
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 
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  */
109  LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M,
110  struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions,
111  char **OutError);
112 
113 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE);
114 
115 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE);
116 
117 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE);
118 
119 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
120  unsigned ArgC, const char * const *ArgV,
121  const char * const *EnvP);
122 
123 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
124  unsigned NumArgs,
125  LLVMGenericValueRef *Args);
126 
127 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F);
128 
129 void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M);
130 
131 LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
132  LLVMModuleRef *OutMod, char **OutError);
133 
134 LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
135  LLVMValueRef *OutFn);
136 
137 void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE,
138  LLVMValueRef Fn);
139 
140 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE);
142 LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE);
143 
144 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
145  void* Addr);
146 
147 void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global);
148 
149 uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name);
150 
151 uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name);
152 
153 /*===-- Operations on memory managers -------------------------------------===*/
154 
155 typedef uint8_t *(*LLVMMemoryManagerAllocateCodeSectionCallback)(
156  void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
157  const char *SectionName);
158 typedef uint8_t *(*LLVMMemoryManagerAllocateDataSectionCallback)(
159  void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
160  const char *SectionName, LLVMBool IsReadOnly);
162  void *Opaque, char **ErrMsg);
163 typedef void (*LLVMMemoryManagerDestroyCallback)(void *Opaque);
164 
165 /**
166  * Create a simple custom MCJIT memory manager. This memory manager can
167  * intercept allocations in a module-oblivious way. This will return NULL
168  * if any of the passed functions are NULL.
169  *
170  * @param Opaque An opaque client object to pass back to the callbacks.
171  * @param AllocateCodeSection Allocate a block of memory for executable code.
172  * @param AllocateDataSection Allocate a block of memory for data.
173  * @param FinalizeMemory Set page permissions and flush cache. Return 0 on
174  * success, 1 on error.
175  */
176 LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
177  void *Opaque,
182 
183 void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM);
184 
185 /*===-- JIT Event Listener functions -------------------------------------===*/
186 
191 
192 /**
193  * @}
194  */
195 
196 #ifdef __cplusplus
197 }
198 #endif /* defined(__cplusplus) */
199 
200 #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:62
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)
amdgpu Simplify well known AMD library false Value Value const Twine & Name
struct LLVMOpaqueMCJITMemoryManager * LLVMMCJITMemoryManagerRef
struct LLVMOpaqueTargetData * LLVMTargetDataRef
Definition: DataLayout.h:39
struct LLVMOpaqueTargetMachine * LLVMTargetMachineRef
Definition: TargetMachine.h:28
LLVMJITEventListenerRef LLVMCreateOProfileJITEventListener(void)
LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P)
void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global, void *Addr)
struct LLVMOpaqueType * LLVMTypeRef
Each value in the LLVM IR has a type, an LLVMTypeRef.
Definition: Types.h:69
uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name)
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:45
void LLVMLinkInMCJIT(void)
Definition: MCJIT.cpp:39
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)
void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE)
int LLVMBool
Definition: Types.h:29
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:31
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
uint32_t Size
Definition: Profile.cpp:47
LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F, unsigned NumArgs, LLVMGenericValueRef *Args)
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:164
void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F)
const char SectionName[]
Definition: AMDGPUPTNote.h:24
struct LLVMOpaqueGenericValue * LLVMGenericValueRef
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
struct LLVMOpaqueValue * LLVMValueRef
Represents an individual value in LLVM IR.
Definition: Types.h:76
LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name, LLVMValueRef *OutFn)
LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M, LLVMModuleRef *OutMod, char **OutError)