lib/ExecutionEngine/ExecutionEngineBindings.cpp

   1 //===-- ExecutionEngineBindings.cpp - C bindings for EEs ------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the C bindings for the ExecutionEngine library.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "jit"
  15 #include "llvm-c/ExecutionEngine.h"
  16 #include "llvm/ExecutionEngine/GenericValue.h"
  17 #include "llvm/ExecutionEngine/ExecutionEngine.h"
  18 #include <cstring>
  19
  20 using namespace llvm;
  21
  22 /*===-- Operations on generic values --------------------------------------===*/
  23
  24 LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
  25                                                 unsigned long long N,
  26                                                 int IsSigned) {
  27   GenericValue *GenVal = new GenericValue();
  28   GenVal->IntVal = APInt(unwrap<IntegerType>(Ty)->getBitWidth(), N, IsSigned);
  29   return wrap(GenVal);
  30 }
  31
  32 LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P) {
  33   GenericValue *GenVal = new GenericValue();
  34   GenVal->PointerVal = P;
  35   return wrap(GenVal);
  36 }
  37
  38 LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef TyRef, double N) {
  39   GenericValue *GenVal = new GenericValue();
  40   switch (unwrap(TyRef)->getTypeID()) {
  41   case Type::FloatTyID:
  42     GenVal->FloatVal = N;
  43     break;
  44   case Type::DoubleTyID:
  45     GenVal->DoubleVal = N;
  46     break;
  47   default:
  48     assert(0 && "LLVMGenericValueToFloat supports only float and double.");
  49     break;
  50   }
  51   return wrap(GenVal);
  52 }
  53
  54 unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef) {
  55   return unwrap(GenValRef)->IntVal.getBitWidth();
  56 }
  57
  58 unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef,
  59                                          int IsSigned) {
  60   GenericValue *GenVal = unwrap(GenValRef);
  61   if (IsSigned)
  62     return GenVal->IntVal.getSExtValue();
  63   else
  64     return GenVal->IntVal.getZExtValue();
  65 }
  66
  67 void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal) {
  68   return unwrap(GenVal)->PointerVal;
  69 }
  70
  71 double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal) {
  72   switch (unwrap(TyRef)->getTypeID()) {
  73   case Type::FloatTyID:
  74     return unwrap(GenVal)->FloatVal;
  75   case Type::DoubleTyID:
  76     return unwrap(GenVal)->DoubleVal;
  77   default:
  78     assert(0 && "LLVMGenericValueToFloat supports only float and double.");
  79     break;
  80   }
  81 }
  82
  83 void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal) {
  84   delete unwrap(GenVal);
  85 }
  86
  87 /*===-- Operations on execution engines -----------------------------------===*/
  88
  89 int LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
  90                               LLVMModuleProviderRef MP,
  91                               char **OutError) {
  92   std::string Error;
  93   if (ExecutionEngine *EE = ExecutionEngine::create(unwrap(MP), false, &Error)){
  94     *OutEE = wrap(EE);
  95     return 0;
  96   }
  97   *OutError = strdup(Error.c_str());
  98   return 1;
  99 }
 100
 101 int LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
 102                           LLVMModuleProviderRef MP,
 103                           char **OutError) {
 104   std::string Error;
 105   if (ExecutionEngine *Interp =
 106       ExecutionEngine::create(unwrap(MP), false, &Error)) {
 107     *OutInterp = wrap(Interp);
 108     return 0;
 109   }
 110   *OutError = strdup(Error.c_str());
 111   return 1;
 112 }
 113
 114 int LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
 115                           LLVMModuleProviderRef MP,
 116                           char **OutError) {
 117   std::string Error;
 118   if (ExecutionEngine *JIT = ExecutionEngine::createJIT(unwrap(MP), &Error)) {
 119     *OutJIT = wrap(JIT);
 120     return 0;
 121   }
 122   *OutError = strdup(Error.c_str());
 123   return 1;
 124 }
 125
 126 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) {
 127   delete unwrap(EE);
 128 }
 129
 130 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) {
 131   unwrap(EE)->runStaticConstructorsDestructors(false);
 132 }
 133
 134 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) {
 135   unwrap(EE)->runStaticConstructorsDestructors(true);
 136 }
 137
 138 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
 139                           unsigned ArgC, const char * const *ArgV,
 140                           const char * const *EnvP) {
 141   std::vector<std::string> ArgVec;
 142   for (unsigned I = 0; I != ArgC; ++I)
 143     ArgVec.push_back(ArgV[I]);
 144
 145   return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
 146 }
 147
 148 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
 149                                     unsigned NumArgs,
 150                                     LLVMGenericValueRef *Args) {
 151   std::vector<GenericValue> ArgVec;
 152   ArgVec.reserve(NumArgs);
 153   for (unsigned I = 0; I != NumArgs; ++I)
 154     ArgVec.push_back(*unwrap(Args[I]));
 155
 156   GenericValue *Result = new GenericValue();
 157   *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
 158   return wrap(Result);
 159 }
 160
 161 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) {
 162   unwrap(EE)->freeMachineCodeForFunction(unwrap<Function>(F));
 163 }
 164
 165 void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP){
 166   unwrap(EE)->addModuleProvider(unwrap(MP));
 167 }
 168
 169 int LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
 170                              LLVMModuleProviderRef MP,
 171                              LLVMModuleRef *OutMod, char **OutError) {
 172   std::string Error;
 173   if (Module *Gone = unwrap(EE)->removeModuleProvider(unwrap(MP), &Error)) {
 174     *OutMod = wrap(Gone);
 175     return 0;
 176   }
 177   if (OutError)
 178     *OutError = strdup(Error.c_str());
 179   return 1;
 180 }
 181
 182 int LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
 183                      LLVMValueRef *OutFn) {
 184   if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {
 185     *OutFn = wrap(F);
 186     return 0;
 187   }
 188   return 1;
 189 }
 190
 191 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE) {
 192   return wrap(unwrap(EE)->getTargetData());
 193 }