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   return 0; // Not reached
  82 }
  83
  84 void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal) {
  85   delete unwrap(GenVal);
  86 }
  87
  88 /*===-- Operations on execution engines -----------------------------------===*/
  89
  90 int LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
  91                               LLVMModuleProviderRef MP,
  92                               char **OutError) {
  93   std::string Error;
  94   if (ExecutionEngine *EE = ExecutionEngine::create(unwrap(MP), false, &Error)){
  95     *OutEE = wrap(EE);
  96     return 0;
  97   }
  98   *OutError = strdup(Error.c_str());
  99   return 1;
 100 }
 101
 102 int LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
 103                           LLVMModuleProviderRef MP,
 104                           char **OutError) {
 105   std::string Error;
 106   if (ExecutionEngine *Interp =
 107       ExecutionEngine::create(unwrap(MP), true, &Error)) {
 108     *OutInterp = wrap(Interp);
 109     return 0;
 110   }
 111   *OutError = strdup(Error.c_str());
 112   return 1;
 113 }
 114
 115 int LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
 116                           LLVMModuleProviderRef MP,
 117                           unsigned OptLevel,
 118                           char **OutError) {
 119   std::string Error;
 120   if (ExecutionEngine *JIT =
 121       ExecutionEngine::createJIT(unwrap(MP), &Error, 0,
 122                                  (CodeGenOpt::Level)OptLevel)) {
 123     *OutJIT = wrap(JIT);
 124     return 0;
 125   }
 126   *OutError = strdup(Error.c_str());
 127   return 1;
 128 }
 129
 130 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) {
 131   delete unwrap(EE);
 132 }
 133
 134 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) {
 135   unwrap(EE)->runStaticConstructorsDestructors(false);
 136 }
 137
 138 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) {
 139   unwrap(EE)->runStaticConstructorsDestructors(true);
 140 }
 141
 142 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
 143                           unsigned ArgC, const char * const *ArgV,
 144                           const char * const *EnvP) {
 145   std::vector<std::string> ArgVec;
 146   for (unsigned I = 0; I != ArgC; ++I)
 147     ArgVec.push_back(ArgV[I]);
 148
 149   return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
 150 }
 151
 152 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
 153                                     unsigned NumArgs,
 154                                     LLVMGenericValueRef *Args) {
 155   std::vector<GenericValue> ArgVec;
 156   ArgVec.reserve(NumArgs);
 157   for (unsigned I = 0; I != NumArgs; ++I)
 158     ArgVec.push_back(*unwrap(Args[I]));
 159
 160   GenericValue *Result = new GenericValue();
 161   *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
 162   return wrap(Result);
 163 }
 164
 165 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) {
 166   unwrap(EE)->freeMachineCodeForFunction(unwrap<Function>(F));
 167 }
 168
 169 void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP){
 170   unwrap(EE)->addModuleProvider(unwrap(MP));
 171 }
 172
 173 int LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
 174                              LLVMModuleProviderRef MP,
 175                              LLVMModuleRef *OutMod, char **OutError) {
 176   std::string Error;
 177   if (Module *Gone = unwrap(EE)->removeModuleProvider(unwrap(MP), &Error)) {
 178     *OutMod = wrap(Gone);
 179     return 0;
 180   }
 181   if (OutError)
 182     *OutError = strdup(Error.c_str());
 183   return 1;
 184 }
 185
 186 int LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
 187                      LLVMValueRef *OutFn) {
 188   if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {
 189     *OutFn = wrap(F);
 190     return 0;
 191   }
 192   return 1;
 193 }
 194
 195 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE) {
 196   return wrap(unwrap(EE)->getTargetData());
 197 }
 198
 199 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
 200                           void* Addr) {
 201   unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr);
 202 }
 203
 204 void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global) {
 205   return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global));
 206 }