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/Support/ErrorHandling.h"
19 #include "llvm/Wrap.h"
24 // Wrapping the C bindings types.
25 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(GenericValue, LLVMGenericValueRef )
26 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ExecutionEngine, LLVMExecutionEngineRef)
28 inline DataLayout *unwrap(LLVMTargetDataRef P) {
29 return reinterpret_cast<DataLayout*>(P);
32 inline LLVMTargetDataRef wrap(const DataLayout *P) {
33 return reinterpret_cast<LLVMTargetDataRef>(const_cast<DataLayout*>(P));
36 inline TargetLibraryInfo *unwrap(LLVMTargetLibraryInfoRef P) {
37 return reinterpret_cast<TargetLibraryInfo*>(P);
40 inline LLVMTargetLibraryInfoRef wrap(const TargetLibraryInfo *P) {
41 TargetLibraryInfo *X = const_cast<TargetLibraryInfo*>(P);
42 return reinterpret_cast<LLVMTargetLibraryInfoRef>(X);
45 /*===-- Operations on generic values --------------------------------------===*/
47 LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
50 GenericValue *GenVal = new GenericValue();
51 GenVal->IntVal = APInt(unwrap<IntegerType>(Ty)->getBitWidth(), N, IsSigned);
55 LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P) {
56 GenericValue *GenVal = new GenericValue();
57 GenVal->PointerVal = P;
61 LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef TyRef, double N) {
62 GenericValue *GenVal = new GenericValue();
63 switch (unwrap(TyRef)->getTypeID()) {
67 case Type::DoubleTyID:
68 GenVal->DoubleVal = N;
71 llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
76 unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef) {
77 return unwrap(GenValRef)->IntVal.getBitWidth();
80 unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef,
82 GenericValue *GenVal = unwrap(GenValRef);
84 return GenVal->IntVal.getSExtValue();
86 return GenVal->IntVal.getZExtValue();
89 void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal) {
90 return unwrap(GenVal)->PointerVal;
93 double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal) {
94 switch (unwrap(TyRef)->getTypeID()) {
96 return unwrap(GenVal)->FloatVal;
97 case Type::DoubleTyID:
98 return unwrap(GenVal)->DoubleVal;
100 llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
104 void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal) {
105 delete unwrap(GenVal);
108 /*===-- Operations on execution engines -----------------------------------===*/
110 LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
114 EngineBuilder builder(unwrap(M));
115 builder.setEngineKind(EngineKind::Either)
116 .setErrorStr(&Error);
117 if (ExecutionEngine *EE = builder.create()){
121 *OutError = strdup(Error.c_str());
125 LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
129 EngineBuilder builder(unwrap(M));
130 builder.setEngineKind(EngineKind::Interpreter)
131 .setErrorStr(&Error);
132 if (ExecutionEngine *Interp = builder.create()) {
133 *OutInterp = wrap(Interp);
136 *OutError = strdup(Error.c_str());
140 LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
145 EngineBuilder builder(unwrap(M));
146 builder.setEngineKind(EngineKind::JIT)
148 .setOptLevel((CodeGenOpt::Level)OptLevel);
149 if (ExecutionEngine *JIT = builder.create()) {
153 *OutError = strdup(Error.c_str());
157 LLVMBool LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
158 LLVMModuleProviderRef MP,
160 /* The module provider is now actually a module. */
161 return LLVMCreateExecutionEngineForModule(OutEE,
162 reinterpret_cast<LLVMModuleRef>(MP),
166 LLVMBool LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
167 LLVMModuleProviderRef MP,
169 /* The module provider is now actually a module. */
170 return LLVMCreateInterpreterForModule(OutInterp,
171 reinterpret_cast<LLVMModuleRef>(MP),
175 LLVMBool LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
176 LLVMModuleProviderRef MP,
179 /* The module provider is now actually a module. */
180 return LLVMCreateJITCompilerForModule(OutJIT,
181 reinterpret_cast<LLVMModuleRef>(MP),
186 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) {
190 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) {
191 unwrap(EE)->runStaticConstructorsDestructors(false);
194 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) {
195 unwrap(EE)->runStaticConstructorsDestructors(true);
198 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
199 unsigned ArgC, const char * const *ArgV,
200 const char * const *EnvP) {
201 std::vector<std::string> ArgVec;
202 for (unsigned I = 0; I != ArgC; ++I)
203 ArgVec.push_back(ArgV[I]);
205 return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
208 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
210 LLVMGenericValueRef *Args) {
211 std::vector<GenericValue> ArgVec;
212 ArgVec.reserve(NumArgs);
213 for (unsigned I = 0; I != NumArgs; ++I)
214 ArgVec.push_back(*unwrap(Args[I]));
216 GenericValue *Result = new GenericValue();
217 *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
221 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) {
222 unwrap(EE)->freeMachineCodeForFunction(unwrap<Function>(F));
225 void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M){
226 unwrap(EE)->addModule(unwrap(M));
229 void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP){
230 /* The module provider is now actually a module. */
231 LLVMAddModule(EE, reinterpret_cast<LLVMModuleRef>(MP));
234 LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
235 LLVMModuleRef *OutMod, char **OutError) {
236 Module *Mod = unwrap(M);
237 unwrap(EE)->removeModule(Mod);
242 LLVMBool LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
243 LLVMModuleProviderRef MP,
244 LLVMModuleRef *OutMod, char **OutError) {
245 /* The module provider is now actually a module. */
246 return LLVMRemoveModule(EE, reinterpret_cast<LLVMModuleRef>(MP), OutMod,
250 LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
251 LLVMValueRef *OutFn) {
252 if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {
259 void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE, LLVMValueRef Fn) {
260 return unwrap(EE)->recompileAndRelinkFunction(unwrap<Function>(Fn));
263 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE) {
264 return wrap(unwrap(EE)->getDataLayout());
267 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
269 unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr);
272 void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global) {
273 return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global));