LLVM API Documentation
00001 //===-- ExecutionEngineBindings.cpp - C bindings for EEs ------------------===// 00002 // 00003 // The LLVM Compiler Infrastructure 00004 // 00005 // This file is distributed under the University of Illinois Open Source 00006 // License. See LICENSE.TXT for details. 00007 // 00008 //===----------------------------------------------------------------------===// 00009 // 00010 // This file defines the C bindings for the ExecutionEngine library. 00011 // 00012 //===----------------------------------------------------------------------===// 00013 00014 #define DEBUG_TYPE "jit" 00015 #include "llvm-c/ExecutionEngine.h" 00016 #include "llvm/ExecutionEngine/GenericValue.h" 00017 #include "llvm/ExecutionEngine/ExecutionEngine.h" 00018 #include "llvm/Support/ErrorHandling.h" 00019 #include <cstring> 00020 00021 using namespace llvm; 00022 00023 /*===-- Operations on generic values --------------------------------------===*/ 00024 00025 LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty, 00026 unsigned long long N, 00027 int IsSigned) { 00028 GenericValue *GenVal = new GenericValue(); 00029 GenVal->IntVal = APInt(unwrap<IntegerType>(Ty)->getBitWidth(), N, IsSigned); 00030 return wrap(GenVal); 00031 } 00032 00033 LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P) { 00034 GenericValue *GenVal = new GenericValue(); 00035 GenVal->PointerVal = P; 00036 return wrap(GenVal); 00037 } 00038 00039 LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef TyRef, double N) { 00040 GenericValue *GenVal = new GenericValue(); 00041 switch (unwrap(TyRef)->getTypeID()) { 00042 case Type::FloatTyID: 00043 GenVal->FloatVal = N; 00044 break; 00045 case Type::DoubleTyID: 00046 GenVal->DoubleVal = N; 00047 break; 00048 default: 00049 llvm_unreachable("LLVMGenericValueToFloat supports only float and double."); 00050 } 00051 return wrap(GenVal); 00052 } 00053 00054 unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef) { 00055 return unwrap(GenValRef)->IntVal.getBitWidth(); 00056 } 00057 00058 unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef, 00059 int IsSigned) { 00060 GenericValue *GenVal = unwrap(GenValRef); 00061 if (IsSigned) 00062 return GenVal->IntVal.getSExtValue(); 00063 else 00064 return GenVal->IntVal.getZExtValue(); 00065 } 00066 00067 void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal) { 00068 return unwrap(GenVal)->PointerVal; 00069 } 00070 00071 double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal) { 00072 switch (unwrap(TyRef)->getTypeID()) { 00073 case Type::FloatTyID: 00074 return unwrap(GenVal)->FloatVal; 00075 case Type::DoubleTyID: 00076 return unwrap(GenVal)->DoubleVal; 00077 default: 00078 llvm_unreachable("LLVMGenericValueToFloat supports only float and double."); 00079 break; 00080 } 00081 return 0; // Not reached 00082 } 00083 00084 void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal) { 00085 delete unwrap(GenVal); 00086 } 00087 00088 /*===-- Operations on execution engines -----------------------------------===*/ 00089 00090 int LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE, 00091 LLVMModuleProviderRef MP, 00092 char **OutError) { 00093 std::string Error; 00094 EngineBuilder builder(unwrap(MP)); 00095 builder.setEngineKind(EngineKind::Either) 00096 .setErrorStr(&Error); 00097 if (ExecutionEngine *EE = builder.create()){ 00098 *OutEE = wrap(EE); 00099 return 0; 00100 } 00101 *OutError = strdup(Error.c_str()); 00102 return 1; 00103 } 00104 00105 int LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp, 00106 LLVMModuleProviderRef MP, 00107 char **OutError) { 00108 std::string Error; 00109 EngineBuilder builder(unwrap(MP)); 00110 builder.setEngineKind(EngineKind::Interpreter) 00111 .setErrorStr(&Error); 00112 if (ExecutionEngine *Interp = builder.create()) { 00113 *OutInterp = wrap(Interp); 00114 return 0; 00115 } 00116 *OutError = strdup(Error.c_str()); 00117 return 1; 00118 } 00119 00120 int LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT, 00121 LLVMModuleProviderRef MP, 00122 unsigned OptLevel, 00123 char **OutError) { 00124 std::string Error; 00125 EngineBuilder builder(unwrap(MP)); 00126 builder.setEngineKind(EngineKind::JIT) 00127 .setErrorStr(&Error) 00128 .setOptLevel((CodeGenOpt::Level)OptLevel); 00129 if (ExecutionEngine *JIT = builder.create()) { 00130 *OutJIT = wrap(JIT); 00131 return 0; 00132 } 00133 *OutError = strdup(Error.c_str()); 00134 return 1; 00135 } 00136 00137 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) { 00138 delete unwrap(EE); 00139 } 00140 00141 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) { 00142 unwrap(EE)->runStaticConstructorsDestructors(false); 00143 } 00144 00145 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) { 00146 unwrap(EE)->runStaticConstructorsDestructors(true); 00147 } 00148 00149 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F, 00150 unsigned ArgC, const char * const *ArgV, 00151 const char * const *EnvP) { 00152 std::vector<std::string> ArgVec; 00153 for (unsigned I = 0; I != ArgC; ++I) 00154 ArgVec.push_back(ArgV[I]); 00155 00156 return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP); 00157 } 00158 00159 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F, 00160 unsigned NumArgs, 00161 LLVMGenericValueRef *Args) { 00162 std::vector<GenericValue> ArgVec; 00163 ArgVec.reserve(NumArgs); 00164 for (unsigned I = 0; I != NumArgs; ++I) 00165 ArgVec.push_back(*unwrap(Args[I])); 00166 00167 GenericValue *Result = new GenericValue(); 00168 *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec); 00169 return wrap(Result); 00170 } 00171 00172 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) { 00173 unwrap(EE)->freeMachineCodeForFunction(unwrap<Function>(F)); 00174 } 00175 00176 void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP){ 00177 unwrap(EE)->addModuleProvider(unwrap(MP)); 00178 } 00179 00180 int LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE, 00181 LLVMModuleProviderRef MP, 00182 LLVMModuleRef *OutMod, char **OutError) { 00183 std::string Error; 00184 if (Module *Gone = unwrap(EE)->removeModuleProvider(unwrap(MP), &Error)) { 00185 *OutMod = wrap(Gone); 00186 return 0; 00187 } 00188 if (OutError) 00189 *OutError = strdup(Error.c_str()); 00190 return 1; 00191 } 00192 00193 int LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name, 00194 LLVMValueRef *OutFn) { 00195 if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) { 00196 *OutFn = wrap(F); 00197 return 0; 00198 } 00199 return 1; 00200 } 00201 00202 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE) { 00203 return wrap(unwrap(EE)->getTargetData()); 00204 } 00205 00206 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global, 00207 void* Addr) { 00208 unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr); 00209 } 00210 00211 void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global) { 00212 return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global)); 00213 }