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
27LLVM_C_EXTERN_C_BEGIN
28
29/**
30 * @defgroup LLVMCExecutionEngine Execution Engine
31 * @ingroup LLVMC
32 *
33 * @{
34 */
35
36void LLVMLinkInMCJIT(void);
37void LLVMLinkInInterpreter(void);
38
39typedef struct LLVMOpaqueGenericValue *LLVMGenericValueRef;
40typedef struct LLVMOpaqueExecutionEngine *LLVMExecutionEngineRef;
41typedef struct LLVMOpaqueMCJITMemoryManager *LLVMMCJITMemoryManagerRef;
42
43struct LLVMMCJITCompilerOptions {
44 unsigned OptLevel;
45 LLVMCodeModel CodeModel;
46 LLVMBool NoFramePointerElim;
47 LLVMBool EnableFastISel;
48 LLVMMCJITMemoryManagerRef MCJMM;
49};
50
51/*===-- Operations on generic values --------------------------------------===*/
52
53LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
54 unsigned long long N,
55 LLVMBool IsSigned);
56
57LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P);
58
59LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef Ty, double N);
60
61unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef);
62
63unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenVal,
64 LLVMBool IsSigned);
65
66void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal);
67
68double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal);
69
70void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal);
71
72/*===-- Operations on execution engines -----------------------------------===*/
73
74LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
75 LLVMModuleRef M,
76 char **OutError);
77
78LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
79 LLVMModuleRef M,
80 char **OutError);
81
82LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
83 LLVMModuleRef M,
84 unsigned OptLevel,
85 char **OutError);
86
87void 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 */
107LLVMBool LLVMCreateMCJITCompilerForModule(
108 LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M,
109 struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions,
110 char **OutError);
111
112void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE);
113
114void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE);
115
116void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE);
117
118int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
119 unsigned ArgC, const char * const *ArgV,
120 const char * const *EnvP);
121
122LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
123 unsigned NumArgs,
124 LLVMGenericValueRef *Args);
125
126void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F);
127
128void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M);
129
130LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
131 LLVMModuleRef *OutMod, char **OutError);
132
133LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
134 LLVMValueRef *OutFn);
135
136void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE,
137 LLVMValueRef Fn);
138
139LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE);
140LLVMTargetMachineRef
141LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE);
142
143void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
144 void* Addr);
145
146void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global);
147
148uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name);
149
150uint64_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.
154LLVMBool LLVMExecutionEngineGetErrMsg(LLVMExecutionEngineRef EE,
155 char **OutError);
156
157/*===-- Operations on memory managers -------------------------------------===*/
158
159typedef uint8_t *(*LLVMMemoryManagerAllocateCodeSectionCallback)(
160 void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
161 const char *SectionName);
162typedef uint8_t *(*LLVMMemoryManagerAllocateDataSectionCallback)(
163 void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
164 const char *SectionName, LLVMBool IsReadOnly);
165typedef LLVMBool (*LLVMMemoryManagerFinalizeMemoryCallback)(
166 void *Opaque, char **ErrMsg);
167typedef 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 */
180LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
181 void *Opaque,
182 LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
183 LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
184 LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
185 LLVMMemoryManagerDestroyCallback Destroy);
186
187void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM);
188
189/*===-- JIT Event Listener functions -------------------------------------===*/
190
191LLVMJITEventListenerRef LLVMCreateGDBRegistrationListener(void);
192LLVMJITEventListenerRef LLVMCreateIntelJITEventListener(void);
193LLVMJITEventListenerRef LLVMCreateOProfileJITEventListener(void);
194LLVMJITEventListenerRef LLVMCreatePerfJITEventListener(void);
195
196/**
197 * @}
198 */
199
200LLVM_C_EXTERN_C_END
201
202#endif
203

source code of llvm/include/llvm-c/ExecutionEngine.h