Home | History | Annotate | Download | only in ExecutionEngine 
      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 #include "llvm-c/ExecutionEngine.h"
     15 #include "llvm/ExecutionEngine/ExecutionEngine.h"
     16 #include "llvm/ExecutionEngine/GenericValue.h"
     17 #include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
     18 #include "llvm/IR/DerivedTypes.h"
     19 #include "llvm/IR/Module.h"
     20 #include "llvm/Support/ErrorHandling.h"
     21 #include "llvm/Target/TargetOptions.h"
     22 #include <cstring>
     23 
     24 using namespace llvm;
     25 
     26 #define DEBUG_TYPE "jit"
     27 
     28 // Wrapping the C bindings types.
     29 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(GenericValue, LLVMGenericValueRef)
     30 
     31 
     32 static LLVMTargetMachineRef wrap(const TargetMachine *P) {
     33   return
     34   reinterpret_cast<LLVMTargetMachineRef>(const_cast<TargetMachine*>(P));
     35 }
     36 
     37 /*===-- Operations on generic values --------------------------------------===*/
     38 
     39 LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
     40                                                 unsigned long long N,
     41                                                 LLVMBool IsSigned) {
     42   GenericValue *GenVal = new GenericValue();
     43   GenVal->IntVal = APInt(unwrap<IntegerType>(Ty)->getBitWidth(), N, IsSigned);
     44   return wrap(GenVal);
     45 }
     46 
     47 LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P) {
     48   GenericValue *GenVal = new GenericValue();
     49   GenVal->PointerVal = P;
     50   return wrap(GenVal);
     51 }
     52 
     53 LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef TyRef, double N) {
     54   GenericValue *GenVal = new GenericValue();
     55   switch (unwrap(TyRef)->getTypeID()) {
     56   case Type::FloatTyID:
     57     GenVal->FloatVal = N;
     58     break;
     59   case Type::DoubleTyID:
     60     GenVal->DoubleVal = N;
     61     break;
     62   default:
     63     llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
     64   }
     65   return wrap(GenVal);
     66 }
     67 
     68 unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef) {
     69   return unwrap(GenValRef)->IntVal.getBitWidth();
     70 }
     71 
     72 unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef,
     73                                          LLVMBool IsSigned) {
     74   GenericValue *GenVal = unwrap(GenValRef);
     75   if (IsSigned)
     76     return GenVal->IntVal.getSExtValue();
     77   else
     78     return GenVal->IntVal.getZExtValue();
     79 }
     80 
     81 void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal) {
     82   return unwrap(GenVal)->PointerVal;
     83 }
     84 
     85 double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal) {
     86   switch (unwrap(TyRef)->getTypeID()) {
     87   case Type::FloatTyID:
     88     return unwrap(GenVal)->FloatVal;
     89   case Type::DoubleTyID:
     90     return unwrap(GenVal)->DoubleVal;
     91   default:
     92     llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
     93   }
     94 }
     95 
     96 void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal) {
     97   delete unwrap(GenVal);
     98 }
     99 
    100 /*===-- Operations on execution engines -----------------------------------===*/
    101 
    102 LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
    103                                             LLVMModuleRef M,
    104                                             char **OutError) {
    105   std::string Error;
    106   EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
    107   builder.setEngineKind(EngineKind::Either)
    108          .setErrorStr(&Error);
    109   if (ExecutionEngine *EE = builder.create()){
    110     *OutEE = wrap(EE);
    111     return 0;
    112   }
    113   *OutError = strdup(Error.c_str());
    114   return 1;
    115 }
    116 
    117 LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
    118                                         LLVMModuleRef M,
    119                                         char **OutError) {
    120   std::string Error;
    121   EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
    122   builder.setEngineKind(EngineKind::Interpreter)
    123          .setErrorStr(&Error);
    124   if (ExecutionEngine *Interp = builder.create()) {
    125     *OutInterp = wrap(Interp);
    126     return 0;
    127   }
    128   *OutError = strdup(Error.c_str());
    129   return 1;
    130 }
    131 
    132 LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
    133                                         LLVMModuleRef M,
    134                                         unsigned OptLevel,
    135                                         char **OutError) {
    136   std::string Error;
    137   EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
    138   builder.setEngineKind(EngineKind::JIT)
    139          .setErrorStr(&Error)
    140          .setOptLevel((CodeGenOpt::Level)OptLevel);
    141   if (ExecutionEngine *JIT = builder.create()) {
    142     *OutJIT = wrap(JIT);
    143     return 0;
    144   }
    145   *OutError = strdup(Error.c_str());
    146   return 1;
    147 }
    148 
    149 void LLVMInitializeMCJITCompilerOptions(LLVMMCJITCompilerOptions *PassedOptions,
    150                                         size_t SizeOfPassedOptions) {
    151   LLVMMCJITCompilerOptions options;
    152   memset(&options, 0, sizeof(options)); // Most fields are zero by default.
    153   options.CodeModel = LLVMCodeModelJITDefault;
    154 
    155   memcpy(PassedOptions, &options,
    156          std::min(sizeof(options), SizeOfPassedOptions));
    157 }
    158 
    159 LLVMBool LLVMCreateMCJITCompilerForModule(
    160     LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M,
    161     LLVMMCJITCompilerOptions *PassedOptions, size_t SizeOfPassedOptions,
    162     char **OutError) {
    163   LLVMMCJITCompilerOptions options;
    164   // If the user passed a larger sized options struct, then they were compiled
    165   // against a newer LLVM. Tell them that something is wrong.
    166   if (SizeOfPassedOptions > sizeof(options)) {
    167     *OutError = strdup(
    168       "Refusing to use options struct that is larger than my own; assuming "
    169       "LLVM library mismatch.");
    170     return 1;
    171   }
    172 
    173   // Defend against the user having an old version of the API by ensuring that
    174   // any fields they didn't see are cleared. We must defend against fields being
    175   // set to the bitwise equivalent of zero, and assume that this means "do the
    176   // default" as if that option hadn't been available.
    177   LLVMInitializeMCJITCompilerOptions(&options, sizeof(options));
    178   memcpy(&options, PassedOptions, SizeOfPassedOptions);
    179 
    180   TargetOptions targetOptions;
    181   targetOptions.EnableFastISel = options.EnableFastISel;
    182   std::unique_ptr<Module> Mod(unwrap(M));
    183 
    184   if (Mod)
    185     // Set function attribute "no-frame-pointer-elim" based on
    186     // NoFramePointerElim.
    187     for (auto &F : *Mod) {
    188       auto Attrs = F.getAttributes();
    189       auto Value = options.NoFramePointerElim ? "true" : "false";
    190       Attrs = Attrs.addAttribute(F.getContext(), AttributeSet::FunctionIndex,
    191                                  "no-frame-pointer-elim", Value);
    192       F.setAttributes(Attrs);
    193     }
    194 
    195   std::string Error;
    196   EngineBuilder builder(std::move(Mod));
    197   builder.setEngineKind(EngineKind::JIT)
    198          .setErrorStr(&Error)
    199          .setOptLevel((CodeGenOpt::Level)options.OptLevel)
    200          .setCodeModel(unwrap(options.CodeModel))
    201          .setTargetOptions(targetOptions);
    202   if (options.MCJMM)
    203     builder.setMCJITMemoryManager(
    204       std::unique_ptr<RTDyldMemoryManager>(unwrap(options.MCJMM)));
    205   if (ExecutionEngine *JIT = builder.create()) {
    206     *OutJIT = wrap(JIT);
    207     return 0;
    208   }
    209   *OutError = strdup(Error.c_str());
    210   return 1;
    211 }
    212 
    213 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) {
    214   delete unwrap(EE);
    215 }
    216 
    217 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) {
    218   unwrap(EE)->runStaticConstructorsDestructors(false);
    219 }
    220 
    221 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) {
    222   unwrap(EE)->runStaticConstructorsDestructors(true);
    223 }
    224 
    225 int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
    226                           unsigned ArgC, const char * const *ArgV,
    227                           const char * const *EnvP) {
    228   unwrap(EE)->finalizeObject();
    229 
    230   std::vector<std::string> ArgVec(ArgV, ArgV + ArgC);
    231   return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
    232 }
    233 
    234 LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
    235                                     unsigned NumArgs,
    236                                     LLVMGenericValueRef *Args) {
    237   unwrap(EE)->finalizeObject();
    238 
    239   std::vector<GenericValue> ArgVec;
    240   ArgVec.reserve(NumArgs);
    241   for (unsigned I = 0; I != NumArgs; ++I)
    242     ArgVec.push_back(*unwrap(Args[I]));
    243 
    244   GenericValue *Result = new GenericValue();
    245   *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
    246   return wrap(Result);
    247 }
    248 
    249 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) {
    250 }
    251 
    252 void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M){
    253   unwrap(EE)->addModule(std::unique_ptr<Module>(unwrap(M)));
    254 }
    255 
    256 LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
    257                           LLVMModuleRef *OutMod, char **OutError) {
    258   Module *Mod = unwrap(M);
    259   unwrap(EE)->removeModule(Mod);
    260   *OutMod = wrap(Mod);
    261   return 0;
    262 }
    263 
    264 LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
    265                           LLVMValueRef *OutFn) {
    266   if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {
    267     *OutFn = wrap(F);
    268     return 0;
    269   }
    270   return 1;
    271 }
    272 
    273 void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE,
    274                                      LLVMValueRef Fn) {
    275   return nullptr;
    276 }
    277 
    278 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE) {
    279   return wrap(&unwrap(EE)->getDataLayout());
    280 }
    281 
    282 LLVMTargetMachineRef
    283 LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE) {
    284   return wrap(unwrap(EE)->getTargetMachine());
    285 }
    286 
    287 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
    288                           void* Addr) {
    289   unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr);
    290 }
    291 
    292 void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global) {
    293   unwrap(EE)->finalizeObject();
    294 
    295   return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global));
    296 }
    297 
    298 uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name) {
    299   return unwrap(EE)->getGlobalValueAddress(Name);
    300 }
    301 
    302 uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name) {
    303   return unwrap(EE)->getFunctionAddress(Name);
    304 }
    305 
    306 /*===-- Operations on memory managers -------------------------------------===*/
    307 
    308 namespace {
    309 
    310 struct SimpleBindingMMFunctions {
    311   LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection;
    312   LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection;
    313   LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory;
    314   LLVMMemoryManagerDestroyCallback Destroy;
    315 };
    316 
    317 class SimpleBindingMemoryManager : public RTDyldMemoryManager {
    318 public:
    319   SimpleBindingMemoryManager(const SimpleBindingMMFunctions& Functions,
    320                              void *Opaque);
    321   ~SimpleBindingMemoryManager() override;
    322 
    323   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
    324                                unsigned SectionID,
    325                                StringRef SectionName) override;
    326 
    327   uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
    328                                unsigned SectionID, StringRef SectionName,
    329                                bool isReadOnly) override;
    330 
    331   bool finalizeMemory(std::string *ErrMsg) override;
    332 
    333 private:
    334   SimpleBindingMMFunctions Functions;
    335   void *Opaque;
    336 };
    337 
    338 SimpleBindingMemoryManager::SimpleBindingMemoryManager(
    339   const SimpleBindingMMFunctions& Functions,
    340   void *Opaque)
    341   : Functions(Functions), Opaque(Opaque) {
    342   assert(Functions.AllocateCodeSection &&
    343          "No AllocateCodeSection function provided!");
    344   assert(Functions.AllocateDataSection &&
    345          "No AllocateDataSection function provided!");
    346   assert(Functions.FinalizeMemory &&
    347          "No FinalizeMemory function provided!");
    348   assert(Functions.Destroy &&
    349          "No Destroy function provided!");
    350 }
    351 
    352 SimpleBindingMemoryManager::~SimpleBindingMemoryManager() {
    353   Functions.Destroy(Opaque);
    354 }
    355 
    356 uint8_t *SimpleBindingMemoryManager::allocateCodeSection(
    357   uintptr_t Size, unsigned Alignment, unsigned SectionID,
    358   StringRef SectionName) {
    359   return Functions.AllocateCodeSection(Opaque, Size, Alignment, SectionID,
    360                                        SectionName.str().c_str());
    361 }
    362 
    363 uint8_t *SimpleBindingMemoryManager::allocateDataSection(
    364   uintptr_t Size, unsigned Alignment, unsigned SectionID,
    365   StringRef SectionName, bool isReadOnly) {
    366   return Functions.AllocateDataSection(Opaque, Size, Alignment, SectionID,
    367                                        SectionName.str().c_str(),
    368                                        isReadOnly);
    369 }
    370 
    371 bool SimpleBindingMemoryManager::finalizeMemory(std::string *ErrMsg) {
    372   char *errMsgCString = nullptr;
    373   bool result = Functions.FinalizeMemory(Opaque, &errMsgCString);
    374   assert((result || !errMsgCString) &&
    375          "Did not expect an error message if FinalizeMemory succeeded");
    376   if (errMsgCString) {
    377     if (ErrMsg)
    378       *ErrMsg = errMsgCString;
    379     free(errMsgCString);
    380   }
    381   return result;
    382 }
    383 
    384 } // anonymous namespace
    385 
    386 LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
    387   void *Opaque,
    388   LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
    389   LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
    390   LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
    391   LLVMMemoryManagerDestroyCallback Destroy) {
    392 
    393   if (!AllocateCodeSection || !AllocateDataSection || !FinalizeMemory ||
    394       !Destroy)
    395     return nullptr;
    396 
    397   SimpleBindingMMFunctions functions;
    398   functions.AllocateCodeSection = AllocateCodeSection;
    399   functions.AllocateDataSection = AllocateDataSection;
    400   functions.FinalizeMemory = FinalizeMemory;
    401   functions.Destroy = Destroy;
    402   return wrap(new SimpleBindingMemoryManager(functions, Opaque));
    403 }
    404 
    405 void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM) {
    406   delete unwrap(MM);
    407 }
    408 
    409