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