1 //===-- ExecutionEngineBindings.cpp - C bindings for EEs ------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by Gordon Henriksen and is distributed under the
6 // University of Illinois Open Source 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/GenericValue.h"
17 #include "llvm/ExecutionEngine/ExecutionEngine.h"
21 /*===-- Operations on generic values --------------------------------------===*/
23 LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
26 GenericValue *GenVal = new GenericValue();
27 GenVal->IntVal = APInt(unwrap<IntegerType>(Ty)->getBitWidth(), N, IsSigned);
31 LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P) {
32 GenericValue *GenVal = new GenericValue();
33 GenVal->PointerVal = P;
37 LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef TyRef, double N) {
38 GenericValue *GenVal = new GenericValue();
39 switch (unwrap(TyRef)->getTypeID()) {
43 case Type::DoubleTyID:
44 GenVal->DoubleVal = N;
47 assert(0 && "LLVMGenericValueToFloat supports only float and double.");
53 unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef) {
54 return unwrap(GenValRef)->IntVal.getBitWidth();
57 unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef,
59 GenericValue *GenVal = unwrap(GenValRef);
61 return GenVal->IntVal.getSExtValue();
63 return GenVal->IntVal.getZExtValue();
66 void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal) {
67 return unwrap(GenVal)->PointerVal;
70 double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal) {
71 switch (unwrap(TyRef)->getTypeID()) {
73 return unwrap(GenVal)->FloatVal;
74 case Type::DoubleTyID:
75 return unwrap(GenVal)->DoubleVal;
77 assert(0 && "LLVMGenericValueToFloat supports only float and double.");
82 void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal) {
83 delete unwrap(GenVal);
86 /*===-- Operations on execution engines -----------------------------------===*/
88 int LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
89 LLVMModuleProviderRef MP,
92 if (ExecutionEngine *EE = ExecutionEngine::create(unwrap(MP), false, &Error)){
96 *OutError = strdup(Error.c_str());
100 int LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
101 LLVMModuleProviderRef MP,
104 if (ExecutionEngine *Interp = ExecutionEngine::create(unwrap(MP), &Error)) {
105 *OutInterp = wrap(Interp);
108 *OutError = strdup(Error.c_str());
112 int LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
113 LLVMModuleProviderRef MP,
116 if (ExecutionEngine *JIT = ExecutionEngine::createJIT(unwrap(MP), &Error)) {
120 *OutError = strdup(Error.c_str());
124 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) {
128 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) {
129 unwrap(EE)->runStaticConstructorsDestructors(false);
132 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) {
133 unwrap(EE)->runStaticConstructorsDestructors(true);
136 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
137 unsigned ArgC, const char * const *ArgV,
138 const char * const *EnvP) {
139 std::vector<std::string> ArgVec;
140 for (unsigned I = 0; I != ArgC; ++I)
141 ArgVec.push_back(ArgV[I]);
143 return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
146 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
148 LLVMGenericValueRef *Args) {
149 std::vector<GenericValue> ArgVec;
150 ArgVec.reserve(NumArgs);
151 for (unsigned I = 0; I != NumArgs; ++I)
152 ArgVec.push_back(*unwrap(Args[I]));
154 GenericValue *Result = new GenericValue();
155 *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
159 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) {
160 unwrap(EE)->freeMachineCodeForFunction(unwrap<Function>(F));
163 void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP){
164 unwrap(EE)->addModuleProvider(unwrap(MP));
167 int LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
168 LLVMModuleProviderRef MP,
169 LLVMModuleRef *OutMod, char **OutError) {
171 if (Module *Gone = unwrap(EE)->removeModuleProvider(unwrap(MP), &Error)) {
172 *OutMod = wrap(Gone);
176 *OutError = strdup(Error.c_str());
180 int LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
181 LLVMValueRef *OutFn) {
182 if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {