LLVM API Documentation

ExecutionEngineBindings.cpp

Go to the documentation of this file.
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 }