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 23 using namespace llvm; 24 25 #define DEBUG_TYPE "jit" 26 27 // Wrapping the C bindings types. 28 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(GenericValue, LLVMGenericValueRef) 29 30 31 inline LLVMTargetMachineRef wrap(const TargetMachine *P) { 32 return 33 reinterpret_cast<LLVMTargetMachineRef>(const_cast<TargetMachine*>(P)); 34 } 35 36 /*===-- Operations on generic values --------------------------------------===*/ 37 38 LLVMGenericValueRef 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 46 LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P) { 47 GenericValue *GenVal = new GenericValue(); 48 GenVal->PointerVal = P; 49 return wrap(GenVal); 50 } 51 52 LLVMGenericValueRef 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 67 unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef) { 68 return unwrap(GenValRef)->IntVal.getBitWidth(); 69 } 70 71 unsigned 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 80 void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal) { 81 return unwrap(GenVal)->PointerVal; 82 } 83 84 double 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 95 void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal) { 96 delete unwrap(GenVal); 97 } 98 99 /*===-- Operations on execution engines -----------------------------------===*/ 100 101 LLVMBool 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 116 LLVMBool 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 131 LLVMBool 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 148 void 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 158 LLVMBool 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 201 LLVMBool 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 210 LLVMBool 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 219 LLVMBool 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 230 void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) { 231 delete unwrap(EE); 232 } 233 234 void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) { 235 unwrap(EE)->runStaticConstructorsDestructors(false); 236 } 237 238 void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) { 239 unwrap(EE)->runStaticConstructorsDestructors(true); 240 } 241 242 int 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 254 LLVMGenericValueRef 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 269 void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) { 270 } 271 272 void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M){ 273 unwrap(EE)->addModule(std::unique_ptr<Module>(unwrap(M))); 274 } 275 276 void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP){ 277 /* The module provider is now actually a module. */ 278 LLVMAddModule(EE, reinterpret_cast<LLVMModuleRef>(MP)); 279 } 280 281 LLVMBool 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 289 LLVMBool 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 297 LLVMBool 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 306 void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE, 307 LLVMValueRef Fn) { 308 return nullptr; 309 } 310 311 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE) { 312 return wrap(unwrap(EE)->getDataLayout()); 313 } 314 315 LLVMTargetMachineRef 316 LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE) { 317 return wrap(unwrap(EE)->getTargetMachine()); 318 } 319 320 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global, 321 void* Addr) { 322 unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr); 323 } 324 325 void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global) { 326 unwrap(EE)->finalizeObject(); 327 328 return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global)); 329 } 330 331 uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name) { 332 return unwrap(EE)->getGlobalValueAddress(Name); 333 } 334 335 uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name) { 336 return unwrap(EE)->getFunctionAddress(Name); 337 } 338 339 /*===-- Operations on memory managers -------------------------------------===*/ 340 341 namespace { 342 343 struct SimpleBindingMMFunctions { 344 LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection; 345 LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection; 346 LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory; 347 LLVMMemoryManagerDestroyCallback Destroy; 348 }; 349 350 class SimpleBindingMemoryManager : public RTDyldMemoryManager { 351 public: 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 366 private: 367 SimpleBindingMMFunctions Functions; 368 void *Opaque; 369 }; 370 371 SimpleBindingMemoryManager::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 385 SimpleBindingMemoryManager::~SimpleBindingMemoryManager() { 386 Functions.Destroy(Opaque); 387 } 388 389 uint8_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 396 uint8_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 404 bool 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 419 LLVMMCJITMemoryManagerRef 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 438 void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM) { 439 delete unwrap(MM); 440 } 441 442