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                           char **OutError) {
 118   std::string Error;
 119   if (ExecutionEngine *JIT = ExecutionEngine::createJIT(unwrap(MP), &Error)) {
 120     *OutJIT = wrap(JIT);
 121     return 0;
 122   }
 123   *OutError = strdup(Error.c_str());
 124   return 1;
 125 }
 126
 127 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) {
 128   delete unwrap(EE);
 129 }
 130
 131 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) {
 132   unwrap(EE)->runStaticConstructorsDestructors(false);
 133 }
 134
 135 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) {
 136   unwrap(EE)->runStaticConstructorsDestructors(true);
 137 }
 138
 139 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
 140                           unsigned ArgC, const char * const *ArgV,
 141                           const char * const *EnvP) {
 142   std::vector<std::string> ArgVec;
 143   for (unsigned I = 0; I != ArgC; ++I)
 144     ArgVec.push_back(ArgV[I]);
 145
 146   return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
 147 }
 148
 149 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
 150                                     unsigned NumArgs,
 151                                     LLVMGenericValueRef *Args) {
 152   std::vector<GenericValue> ArgVec;
 153   ArgVec.reserve(NumArgs);
 154   for (unsigned I = 0; I != NumArgs; ++I)
 155     ArgVec.push_back(*unwrap(Args[I]));
 156
 157   GenericValue *Result = new GenericValue();
 158   *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
 159   return wrap(Result);
 160 }
 161
 162 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) {
 163   unwrap(EE)->freeMachineCodeForFunction(unwrap<Function>(F));
 164 }
 165
 166 void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP){
 167   unwrap(EE)->addModuleProvider(unwrap(MP));
 168 }
 169
 170 int LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
 171                              LLVMModuleProviderRef MP,
 172                              LLVMModuleRef *OutMod, char **OutError) {
 173   std::string Error;
 174   if (Module *Gone = unwrap(EE)->removeModuleProvider(unwrap(MP), &Error)) {
 175     *OutMod = wrap(Gone);
 176     return 0;
 177   }
 178   if (OutError)
 179     *OutError = strdup(Error.c_str());
 180   return 1;
 181 }
 182
 183 int LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
 184                      LLVMValueRef *OutFn) {
 185   if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {
 186     *OutFn = wrap(F);
 187     return 0;
 188   }
 189   return 1;
 190 }
 191
 192 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE) {
 193   return wrap(unwrap(EE)->getTargetData());
 194 }
 195
 196 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
 197                           void* Addr) {
 198   unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr);
 199 }