1 //===-- ExecutionEngineBindings.cpp - C bindings for EEs ------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the C bindings for the ExecutionEngine library.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "jit"
15 #include "llvm-c/ExecutionEngine.h"
16 #include "llvm/ExecutionEngine/ExecutionEngine.h"
17 #include "llvm/ExecutionEngine/GenericValue.h"
18 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
19 #include "llvm/Support/ErrorHandling.h"
24 // Wrapping the C bindings types.
25 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(GenericValue, LLVMGenericValueRef )
27 inline DataLayout *unwrap(LLVMTargetDataRef P) {
28 return reinterpret_cast<DataLayout*>(P);
31 inline LLVMTargetDataRef wrap(const DataLayout *P) {
32 return reinterpret_cast<LLVMTargetDataRef>(const_cast<DataLayout*>(P));
35 inline TargetLibraryInfo *unwrap(LLVMTargetLibraryInfoRef P) {
36 return reinterpret_cast<TargetLibraryInfo*>(P);
39 inline LLVMTargetLibraryInfoRef wrap(const TargetLibraryInfo *P) {
40 TargetLibraryInfo *X = const_cast<TargetLibraryInfo*>(P);
41 return reinterpret_cast<LLVMTargetLibraryInfoRef>(X);
44 /*===-- Operations on generic values --------------------------------------===*/
46 LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
49 GenericValue *GenVal = new GenericValue();
50 GenVal->IntVal = APInt(unwrap<IntegerType>(Ty)->getBitWidth(), N, IsSigned);
54 LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P) {
55 GenericValue *GenVal = new GenericValue();
56 GenVal->PointerVal = P;
60 LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef TyRef, double N) {
61 GenericValue *GenVal = new GenericValue();
62 switch (unwrap(TyRef)->getTypeID()) {
66 case Type::DoubleTyID:
67 GenVal->DoubleVal = N;
70 llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
75 unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef) {
76 return unwrap(GenValRef)->IntVal.getBitWidth();
79 unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef,
81 GenericValue *GenVal = unwrap(GenValRef);
83 return GenVal->IntVal.getSExtValue();
85 return GenVal->IntVal.getZExtValue();
88 void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal) {
89 return unwrap(GenVal)->PointerVal;
92 double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal) {
93 switch (unwrap(TyRef)->getTypeID()) {
95 return unwrap(GenVal)->FloatVal;
96 case Type::DoubleTyID:
97 return unwrap(GenVal)->DoubleVal;
99 llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
103 void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal) {
104 delete unwrap(GenVal);
107 /*===-- Operations on execution engines -----------------------------------===*/
109 LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
113 EngineBuilder builder(unwrap(M));
114 builder.setEngineKind(EngineKind::Either)
115 .setErrorStr(&Error);
116 if (ExecutionEngine *EE = builder.create()){
120 *OutError = strdup(Error.c_str());
124 LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
128 EngineBuilder builder(unwrap(M));
129 builder.setEngineKind(EngineKind::Interpreter)
130 .setErrorStr(&Error);
131 if (ExecutionEngine *Interp = builder.create()) {
132 *OutInterp = wrap(Interp);
135 *OutError = strdup(Error.c_str());
139 LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
144 EngineBuilder builder(unwrap(M));
145 builder.setEngineKind(EngineKind::JIT)
147 .setOptLevel((CodeGenOpt::Level)OptLevel);
148 if (ExecutionEngine *JIT = builder.create()) {
152 *OutError = strdup(Error.c_str());
156 LLVMBool LLVMCreateMCJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
158 LLVMMCJITCompilerOptions *PassedOptions,
159 size_t SizeOfPassedOptions,
161 LLVMMCJITCompilerOptions options;
162 // If the user passed a larger sized options struct, then they were compiled
163 // against a newer LLVM. Tell them that something is wrong.
164 if (SizeOfPassedOptions > sizeof(options)) {
166 "Refusing to use options struct that is larger than my own; assuming LLVM "
167 "library mismatch.");
171 // Defend against the user having an old version of the API by ensuring that
172 // any fields they didn't see are cleared. We must defend against fields being
173 // set to the bitwise equivalent of zero, and assume that this means "do the
174 // default" as if that option hadn't been available.
175 memset(&options, 0, sizeof(options));
176 memcpy(&options, PassedOptions, SizeOfPassedOptions);
178 TargetOptions targetOptions;
179 targetOptions.NoFramePointerElim = options.NoFramePointerElim;
182 EngineBuilder builder(unwrap(M));
183 builder.setEngineKind(EngineKind::JIT)
186 .setOptLevel((CodeGenOpt::Level)options.OptLevel)
187 .setJITMemoryManager(new SectionMemoryManager())
188 .setTargetOptions(targetOptions);
189 if (ExecutionEngine *JIT = builder.create()) {
193 *OutError = strdup(Error.c_str());
197 LLVMBool LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
198 LLVMModuleProviderRef MP,
200 /* The module provider is now actually a module. */
201 return LLVMCreateExecutionEngineForModule(OutEE,
202 reinterpret_cast<LLVMModuleRef>(MP),
206 LLVMBool LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
207 LLVMModuleProviderRef MP,
209 /* The module provider is now actually a module. */
210 return LLVMCreateInterpreterForModule(OutInterp,
211 reinterpret_cast<LLVMModuleRef>(MP),
215 LLVMBool LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
216 LLVMModuleProviderRef MP,
219 /* The module provider is now actually a module. */
220 return LLVMCreateJITCompilerForModule(OutJIT,
221 reinterpret_cast<LLVMModuleRef>(MP),
226 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) {
230 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) {
231 unwrap(EE)->runStaticConstructorsDestructors(false);
234 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) {
235 unwrap(EE)->runStaticConstructorsDestructors(true);
238 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
239 unsigned ArgC, const char * const *ArgV,
240 const char * const *EnvP) {
241 unwrap(EE)->finalizeObject();
243 std::vector<std::string> ArgVec;
244 for (unsigned I = 0; I != ArgC; ++I)
245 ArgVec.push_back(ArgV[I]);
247 return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
250 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
252 LLVMGenericValueRef *Args) {
253 unwrap(EE)->finalizeObject();
255 std::vector<GenericValue> ArgVec;
256 ArgVec.reserve(NumArgs);
257 for (unsigned I = 0; I != NumArgs; ++I)
258 ArgVec.push_back(*unwrap(Args[I]));
260 GenericValue *Result = new GenericValue();
261 *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
265 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) {
266 unwrap(EE)->freeMachineCodeForFunction(unwrap<Function>(F));
269 void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M){
270 unwrap(EE)->addModule(unwrap(M));
273 void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP){
274 /* The module provider is now actually a module. */
275 LLVMAddModule(EE, reinterpret_cast<LLVMModuleRef>(MP));
278 LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
279 LLVMModuleRef *OutMod, char **OutError) {
280 Module *Mod = unwrap(M);
281 unwrap(EE)->removeModule(Mod);
286 LLVMBool LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
287 LLVMModuleProviderRef MP,
288 LLVMModuleRef *OutMod, char **OutError) {
289 /* The module provider is now actually a module. */
290 return LLVMRemoveModule(EE, reinterpret_cast<LLVMModuleRef>(MP), OutMod,
294 LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
295 LLVMValueRef *OutFn) {
296 if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {
303 void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE, LLVMValueRef Fn) {
304 return unwrap(EE)->recompileAndRelinkFunction(unwrap<Function>(Fn));
307 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE) {
308 return wrap(unwrap(EE)->getDataLayout());
311 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
313 unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr);
316 void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global) {
317 unwrap(EE)->finalizeObject();
319 return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global));