ExecutionEngine.cpp revision 5b3701256c6706182ebfaeed8d50a66c6afe2a40
1//===-- ExecutionEngine.cpp - Common Implementation shared by 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 common interface used by the various execution engine 11// subclasses. 12// 13//===----------------------------------------------------------------------===// 14 15#define DEBUG_TYPE "jit" 16#include "llvm/ExecutionEngine/ExecutionEngine.h" 17 18#include "llvm/Constants.h" 19#include "llvm/DerivedTypes.h" 20#include "llvm/Module.h" 21#include "llvm/ModuleProvider.h" 22#include "llvm/ExecutionEngine/GenericValue.h" 23#include "llvm/ADT/Statistic.h" 24#include "llvm/Support/Debug.h" 25#include "llvm/Support/ErrorHandling.h" 26#include "llvm/Support/MutexGuard.h" 27#include "llvm/Support/ValueHandle.h" 28#include "llvm/Support/raw_ostream.h" 29#include "llvm/System/DynamicLibrary.h" 30#include "llvm/System/Host.h" 31#include "llvm/Target/TargetData.h" 32#include <cmath> 33#include <cstring> 34using namespace llvm; 35 36STATISTIC(NumInitBytes, "Number of bytes of global vars initialized"); 37STATISTIC(NumGlobals , "Number of global vars initialized"); 38 39ExecutionEngine *(*ExecutionEngine::JITCtor)(ModuleProvider *MP, 40 std::string *ErrorStr, 41 JITMemoryManager *JMM, 42 CodeGenOpt::Level OptLevel, 43 bool GVsWithCode, 44 CodeModel::Model CMM) = 0; 45ExecutionEngine *(*ExecutionEngine::InterpCtor)(ModuleProvider *MP, 46 std::string *ErrorStr) = 0; 47ExecutionEngine::EERegisterFn ExecutionEngine::ExceptionTableRegister = 0; 48 49 50ExecutionEngine::ExecutionEngine(ModuleProvider *P) 51 : EEState(*this), 52 LazyFunctionCreator(0) { 53 CompilingLazily = false; 54 GVCompilationDisabled = false; 55 SymbolSearchingDisabled = false; 56 Modules.push_back(P); 57 assert(P && "ModuleProvider is null?"); 58} 59 60ExecutionEngine::~ExecutionEngine() { 61 clearAllGlobalMappings(); 62 for (unsigned i = 0, e = Modules.size(); i != e; ++i) 63 delete Modules[i]; 64} 65 66char* ExecutionEngine::getMemoryForGV(const GlobalVariable* GV) { 67 const Type *ElTy = GV->getType()->getElementType(); 68 size_t GVSize = (size_t)getTargetData()->getTypeAllocSize(ElTy); 69 return new char[GVSize]; 70} 71 72/// removeModuleProvider - Remove a ModuleProvider from the list of modules. 73/// Relases the Module from the ModuleProvider, materializing it in the 74/// process, and returns the materialized Module. 75Module* ExecutionEngine::removeModuleProvider(ModuleProvider *P, 76 std::string *ErrInfo) { 77 for(SmallVector<ModuleProvider *, 1>::iterator I = Modules.begin(), 78 E = Modules.end(); I != E; ++I) { 79 ModuleProvider *MP = *I; 80 if (MP == P) { 81 Modules.erase(I); 82 clearGlobalMappingsFromModule(MP->getModule()); 83 return MP->releaseModule(ErrInfo); 84 } 85 } 86 return NULL; 87} 88 89/// deleteModuleProvider - Remove a ModuleProvider from the list of modules, 90/// and deletes the ModuleProvider and owned Module. Avoids materializing 91/// the underlying module. 92void ExecutionEngine::deleteModuleProvider(ModuleProvider *P, 93 std::string *ErrInfo) { 94 for(SmallVector<ModuleProvider *, 1>::iterator I = Modules.begin(), 95 E = Modules.end(); I != E; ++I) { 96 ModuleProvider *MP = *I; 97 if (MP == P) { 98 Modules.erase(I); 99 clearGlobalMappingsFromModule(MP->getModule()); 100 delete MP; 101 return; 102 } 103 } 104} 105 106/// FindFunctionNamed - Search all of the active modules to find the one that 107/// defines FnName. This is very slow operation and shouldn't be used for 108/// general code. 109Function *ExecutionEngine::FindFunctionNamed(const char *FnName) { 110 for (unsigned i = 0, e = Modules.size(); i != e; ++i) { 111 if (Function *F = Modules[i]->getModule()->getFunction(FnName)) 112 return F; 113 } 114 return 0; 115} 116 117 118void *ExecutionEngineState::RemoveMapping( 119 const MutexGuard &, const GlobalValue *ToUnmap) { 120 GlobalAddressMapTy::iterator I = GlobalAddressMap.find(ToUnmap); 121 void *OldVal; 122 if (I == GlobalAddressMap.end()) 123 OldVal = 0; 124 else { 125 OldVal = I->second; 126 GlobalAddressMap.erase(I); 127 } 128 129 GlobalAddressReverseMap.erase(OldVal); 130 return OldVal; 131} 132 133/// addGlobalMapping - Tell the execution engine that the specified global is 134/// at the specified location. This is used internally as functions are JIT'd 135/// and as global variables are laid out in memory. It can and should also be 136/// used by clients of the EE that want to have an LLVM global overlay 137/// existing data in memory. 138void ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) { 139 MutexGuard locked(lock); 140 141 DEBUG(dbgs() << "JIT: Map \'" << GV->getName() 142 << "\' to [" << Addr << "]\n";); 143 void *&CurVal = EEState.getGlobalAddressMap(locked)[GV]; 144 assert((CurVal == 0 || Addr == 0) && "GlobalMapping already established!"); 145 CurVal = Addr; 146 147 // If we are using the reverse mapping, add it too 148 if (!EEState.getGlobalAddressReverseMap(locked).empty()) { 149 AssertingVH<const GlobalValue> &V = 150 EEState.getGlobalAddressReverseMap(locked)[Addr]; 151 assert((V == 0 || GV == 0) && "GlobalMapping already established!"); 152 V = GV; 153 } 154} 155 156/// clearAllGlobalMappings - Clear all global mappings and start over again 157/// use in dynamic compilation scenarios when you want to move globals 158void ExecutionEngine::clearAllGlobalMappings() { 159 MutexGuard locked(lock); 160 161 EEState.getGlobalAddressMap(locked).clear(); 162 EEState.getGlobalAddressReverseMap(locked).clear(); 163} 164 165/// clearGlobalMappingsFromModule - Clear all global mappings that came from a 166/// particular module, because it has been removed from the JIT. 167void ExecutionEngine::clearGlobalMappingsFromModule(Module *M) { 168 MutexGuard locked(lock); 169 170 for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI) { 171 EEState.RemoveMapping(locked, FI); 172 } 173 for (Module::global_iterator GI = M->global_begin(), GE = M->global_end(); 174 GI != GE; ++GI) { 175 EEState.RemoveMapping(locked, GI); 176 } 177} 178 179/// updateGlobalMapping - Replace an existing mapping for GV with a new 180/// address. This updates both maps as required. If "Addr" is null, the 181/// entry for the global is removed from the mappings. 182void *ExecutionEngine::updateGlobalMapping(const GlobalValue *GV, void *Addr) { 183 MutexGuard locked(lock); 184 185 ExecutionEngineState::GlobalAddressMapTy &Map = 186 EEState.getGlobalAddressMap(locked); 187 188 // Deleting from the mapping? 189 if (Addr == 0) { 190 return EEState.RemoveMapping(locked, GV); 191 } 192 193 void *&CurVal = Map[GV]; 194 void *OldVal = CurVal; 195 196 if (CurVal && !EEState.getGlobalAddressReverseMap(locked).empty()) 197 EEState.getGlobalAddressReverseMap(locked).erase(CurVal); 198 CurVal = Addr; 199 200 // If we are using the reverse mapping, add it too 201 if (!EEState.getGlobalAddressReverseMap(locked).empty()) { 202 AssertingVH<const GlobalValue> &V = 203 EEState.getGlobalAddressReverseMap(locked)[Addr]; 204 assert((V == 0 || GV == 0) && "GlobalMapping already established!"); 205 V = GV; 206 } 207 return OldVal; 208} 209 210/// getPointerToGlobalIfAvailable - This returns the address of the specified 211/// global value if it is has already been codegen'd, otherwise it returns null. 212/// 213void *ExecutionEngine::getPointerToGlobalIfAvailable(const GlobalValue *GV) { 214 MutexGuard locked(lock); 215 216 ExecutionEngineState::GlobalAddressMapTy::iterator I = 217 EEState.getGlobalAddressMap(locked).find(GV); 218 return I != EEState.getGlobalAddressMap(locked).end() ? I->second : 0; 219} 220 221/// getGlobalValueAtAddress - Return the LLVM global value object that starts 222/// at the specified address. 223/// 224const GlobalValue *ExecutionEngine::getGlobalValueAtAddress(void *Addr) { 225 MutexGuard locked(lock); 226 227 // If we haven't computed the reverse mapping yet, do so first. 228 if (EEState.getGlobalAddressReverseMap(locked).empty()) { 229 for (ExecutionEngineState::GlobalAddressMapTy::iterator 230 I = EEState.getGlobalAddressMap(locked).begin(), 231 E = EEState.getGlobalAddressMap(locked).end(); I != E; ++I) 232 EEState.getGlobalAddressReverseMap(locked).insert(std::make_pair(I->second, 233 I->first)); 234 } 235 236 std::map<void *, AssertingVH<const GlobalValue> >::iterator I = 237 EEState.getGlobalAddressReverseMap(locked).find(Addr); 238 return I != EEState.getGlobalAddressReverseMap(locked).end() ? I->second : 0; 239} 240 241// CreateArgv - Turn a vector of strings into a nice argv style array of 242// pointers to null terminated strings. 243// 244static void *CreateArgv(LLVMContext &C, ExecutionEngine *EE, 245 const std::vector<std::string> &InputArgv) { 246 unsigned PtrSize = EE->getTargetData()->getPointerSize(); 247 char *Result = new char[(InputArgv.size()+1)*PtrSize]; 248 249 DEBUG(dbgs() << "JIT: ARGV = " << (void*)Result << "\n"); 250 const Type *SBytePtr = Type::getInt8PtrTy(C); 251 252 for (unsigned i = 0; i != InputArgv.size(); ++i) { 253 unsigned Size = InputArgv[i].size()+1; 254 char *Dest = new char[Size]; 255 DEBUG(dbgs() << "JIT: ARGV[" << i << "] = " << (void*)Dest << "\n"); 256 257 std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest); 258 Dest[Size-1] = 0; 259 260 // Endian safe: Result[i] = (PointerTy)Dest; 261 EE->StoreValueToMemory(PTOGV(Dest), (GenericValue*)(Result+i*PtrSize), 262 SBytePtr); 263 } 264 265 // Null terminate it 266 EE->StoreValueToMemory(PTOGV(0), 267 (GenericValue*)(Result+InputArgv.size()*PtrSize), 268 SBytePtr); 269 return Result; 270} 271 272 273/// runStaticConstructorsDestructors - This method is used to execute all of 274/// the static constructors or destructors for a module, depending on the 275/// value of isDtors. 276void ExecutionEngine::runStaticConstructorsDestructors(Module *module, 277 bool isDtors) { 278 const char *Name = isDtors ? "llvm.global_dtors" : "llvm.global_ctors"; 279 280 // Execute global ctors/dtors for each module in the program. 281 282 GlobalVariable *GV = module->getNamedGlobal(Name); 283 284 // If this global has internal linkage, or if it has a use, then it must be 285 // an old-style (llvmgcc3) static ctor with __main linked in and in use. If 286 // this is the case, don't execute any of the global ctors, __main will do 287 // it. 288 if (!GV || GV->isDeclaration() || GV->hasLocalLinkage()) return; 289 290 // Should be an array of '{ int, void ()* }' structs. The first value is 291 // the init priority, which we ignore. 292 ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer()); 293 if (!InitList) return; 294 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) 295 if (ConstantStruct *CS = 296 dyn_cast<ConstantStruct>(InitList->getOperand(i))) { 297 if (CS->getNumOperands() != 2) return; // Not array of 2-element structs. 298 299 Constant *FP = CS->getOperand(1); 300 if (FP->isNullValue()) 301 break; // Found a null terminator, exit. 302 303 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP)) 304 if (CE->isCast()) 305 FP = CE->getOperand(0); 306 if (Function *F = dyn_cast<Function>(FP)) { 307 // Execute the ctor/dtor function! 308 runFunction(F, std::vector<GenericValue>()); 309 } 310 } 311} 312 313/// runStaticConstructorsDestructors - This method is used to execute all of 314/// the static constructors or destructors for a program, depending on the 315/// value of isDtors. 316void ExecutionEngine::runStaticConstructorsDestructors(bool isDtors) { 317 // Execute global ctors/dtors for each module in the program. 318 for (unsigned m = 0, e = Modules.size(); m != e; ++m) 319 runStaticConstructorsDestructors(Modules[m]->getModule(), isDtors); 320} 321 322#ifndef NDEBUG 323/// isTargetNullPtr - Return whether the target pointer stored at Loc is null. 324static bool isTargetNullPtr(ExecutionEngine *EE, void *Loc) { 325 unsigned PtrSize = EE->getTargetData()->getPointerSize(); 326 for (unsigned i = 0; i < PtrSize; ++i) 327 if (*(i + (uint8_t*)Loc)) 328 return false; 329 return true; 330} 331#endif 332 333/// runFunctionAsMain - This is a helper function which wraps runFunction to 334/// handle the common task of starting up main with the specified argc, argv, 335/// and envp parameters. 336int ExecutionEngine::runFunctionAsMain(Function *Fn, 337 const std::vector<std::string> &argv, 338 const char * const * envp) { 339 std::vector<GenericValue> GVArgs; 340 GenericValue GVArgc; 341 GVArgc.IntVal = APInt(32, argv.size()); 342 343 // Check main() type 344 unsigned NumArgs = Fn->getFunctionType()->getNumParams(); 345 const FunctionType *FTy = Fn->getFunctionType(); 346 const Type* PPInt8Ty = Type::getInt8PtrTy(Fn->getContext())->getPointerTo(); 347 switch (NumArgs) { 348 case 3: 349 if (FTy->getParamType(2) != PPInt8Ty) { 350 llvm_report_error("Invalid type for third argument of main() supplied"); 351 } 352 // FALLS THROUGH 353 case 2: 354 if (FTy->getParamType(1) != PPInt8Ty) { 355 llvm_report_error("Invalid type for second argument of main() supplied"); 356 } 357 // FALLS THROUGH 358 case 1: 359 if (!FTy->getParamType(0)->isInteger(32)) { 360 llvm_report_error("Invalid type for first argument of main() supplied"); 361 } 362 // FALLS THROUGH 363 case 0: 364 if (!isa<IntegerType>(FTy->getReturnType()) && 365 !FTy->getReturnType()->isVoidTy()) { 366 llvm_report_error("Invalid return type of main() supplied"); 367 } 368 break; 369 default: 370 llvm_report_error("Invalid number of arguments of main() supplied"); 371 } 372 373 if (NumArgs) { 374 GVArgs.push_back(GVArgc); // Arg #0 = argc. 375 if (NumArgs > 1) { 376 // Arg #1 = argv. 377 GVArgs.push_back(PTOGV(CreateArgv(Fn->getContext(), this, argv))); 378 assert(!isTargetNullPtr(this, GVTOP(GVArgs[1])) && 379 "argv[0] was null after CreateArgv"); 380 if (NumArgs > 2) { 381 std::vector<std::string> EnvVars; 382 for (unsigned i = 0; envp[i]; ++i) 383 EnvVars.push_back(envp[i]); 384 // Arg #2 = envp. 385 GVArgs.push_back(PTOGV(CreateArgv(Fn->getContext(), this, EnvVars))); 386 } 387 } 388 } 389 return runFunction(Fn, GVArgs).IntVal.getZExtValue(); 390} 391 392/// If possible, create a JIT, unless the caller specifically requests an 393/// Interpreter or there's an error. If even an Interpreter cannot be created, 394/// NULL is returned. 395/// 396ExecutionEngine *ExecutionEngine::create(ModuleProvider *MP, 397 bool ForceInterpreter, 398 std::string *ErrorStr, 399 CodeGenOpt::Level OptLevel, 400 bool GVsWithCode) { 401 return EngineBuilder(MP) 402 .setEngineKind(ForceInterpreter 403 ? EngineKind::Interpreter 404 : EngineKind::JIT) 405 .setErrorStr(ErrorStr) 406 .setOptLevel(OptLevel) 407 .setAllocateGVsWithCode(GVsWithCode) 408 .create(); 409} 410 411ExecutionEngine *ExecutionEngine::create(Module *M) { 412 return EngineBuilder(M).create(); 413} 414 415/// EngineBuilder - Overloaded constructor that automatically creates an 416/// ExistingModuleProvider for an existing module. 417EngineBuilder::EngineBuilder(Module *m) : MP(new ExistingModuleProvider(m)) { 418 InitEngine(); 419} 420 421ExecutionEngine *EngineBuilder::create() { 422 // Make sure we can resolve symbols in the program as well. The zero arg 423 // to the function tells DynamicLibrary to load the program, not a library. 424 if (sys::DynamicLibrary::LoadLibraryPermanently(0, ErrorStr)) 425 return 0; 426 427 // If the user specified a memory manager but didn't specify which engine to 428 // create, we assume they only want the JIT, and we fail if they only want 429 // the interpreter. 430 if (JMM) { 431 if (WhichEngine & EngineKind::JIT) 432 WhichEngine = EngineKind::JIT; 433 else { 434 if (ErrorStr) 435 *ErrorStr = "Cannot create an interpreter with a memory manager."; 436 return 0; 437 } 438 } 439 440 // Unless the interpreter was explicitly selected or the JIT is not linked, 441 // try making a JIT. 442 if (WhichEngine & EngineKind::JIT) { 443 if (ExecutionEngine::JITCtor) { 444 ExecutionEngine *EE = 445 ExecutionEngine::JITCtor(MP, ErrorStr, JMM, OptLevel, 446 AllocateGVsWithCode, CMModel); 447 if (EE) return EE; 448 } 449 } 450 451 // If we can't make a JIT and we didn't request one specifically, try making 452 // an interpreter instead. 453 if (WhichEngine & EngineKind::Interpreter) { 454 if (ExecutionEngine::InterpCtor) 455 return ExecutionEngine::InterpCtor(MP, ErrorStr); 456 if (ErrorStr) 457 *ErrorStr = "Interpreter has not been linked in."; 458 return 0; 459 } 460 461 if ((WhichEngine & EngineKind::JIT) && ExecutionEngine::JITCtor == 0) { 462 if (ErrorStr) 463 *ErrorStr = "JIT has not been linked in."; 464 } 465 return 0; 466} 467 468/// getPointerToGlobal - This returns the address of the specified global 469/// value. This may involve code generation if it's a function. 470/// 471void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) { 472 if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV))) 473 return getPointerToFunction(F); 474 475 MutexGuard locked(lock); 476 void *p = EEState.getGlobalAddressMap(locked)[GV]; 477 if (p) 478 return p; 479 480 // Global variable might have been added since interpreter started. 481 if (GlobalVariable *GVar = 482 const_cast<GlobalVariable *>(dyn_cast<GlobalVariable>(GV))) 483 EmitGlobalVariable(GVar); 484 else 485 llvm_unreachable("Global hasn't had an address allocated yet!"); 486 return EEState.getGlobalAddressMap(locked)[GV]; 487} 488 489/// This function converts a Constant* into a GenericValue. The interesting 490/// part is if C is a ConstantExpr. 491/// @brief Get a GenericValue for a Constant* 492GenericValue ExecutionEngine::getConstantValue(const Constant *C) { 493 // If its undefined, return the garbage. 494 if (isa<UndefValue>(C)) { 495 GenericValue Result; 496 switch (C->getType()->getTypeID()) { 497 case Type::IntegerTyID: 498 case Type::X86_FP80TyID: 499 case Type::FP128TyID: 500 case Type::PPC_FP128TyID: 501 // Although the value is undefined, we still have to construct an APInt 502 // with the correct bit width. 503 Result.IntVal = APInt(C->getType()->getPrimitiveSizeInBits(), 0); 504 break; 505 default: 506 break; 507 } 508 return Result; 509 } 510 511 // If the value is a ConstantExpr 512 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 513 Constant *Op0 = CE->getOperand(0); 514 switch (CE->getOpcode()) { 515 case Instruction::GetElementPtr: { 516 // Compute the index 517 GenericValue Result = getConstantValue(Op0); 518 SmallVector<Value*, 8> Indices(CE->op_begin()+1, CE->op_end()); 519 uint64_t Offset = 520 TD->getIndexedOffset(Op0->getType(), &Indices[0], Indices.size()); 521 522 char* tmp = (char*) Result.PointerVal; 523 Result = PTOGV(tmp + Offset); 524 return Result; 525 } 526 case Instruction::Trunc: { 527 GenericValue GV = getConstantValue(Op0); 528 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); 529 GV.IntVal = GV.IntVal.trunc(BitWidth); 530 return GV; 531 } 532 case Instruction::ZExt: { 533 GenericValue GV = getConstantValue(Op0); 534 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); 535 GV.IntVal = GV.IntVal.zext(BitWidth); 536 return GV; 537 } 538 case Instruction::SExt: { 539 GenericValue GV = getConstantValue(Op0); 540 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); 541 GV.IntVal = GV.IntVal.sext(BitWidth); 542 return GV; 543 } 544 case Instruction::FPTrunc: { 545 // FIXME long double 546 GenericValue GV = getConstantValue(Op0); 547 GV.FloatVal = float(GV.DoubleVal); 548 return GV; 549 } 550 case Instruction::FPExt:{ 551 // FIXME long double 552 GenericValue GV = getConstantValue(Op0); 553 GV.DoubleVal = double(GV.FloatVal); 554 return GV; 555 } 556 case Instruction::UIToFP: { 557 GenericValue GV = getConstantValue(Op0); 558 if (CE->getType()->isFloatTy()) 559 GV.FloatVal = float(GV.IntVal.roundToDouble()); 560 else if (CE->getType()->isDoubleTy()) 561 GV.DoubleVal = GV.IntVal.roundToDouble(); 562 else if (CE->getType()->isX86_FP80Ty()) { 563 const uint64_t zero[] = {0, 0}; 564 APFloat apf = APFloat(APInt(80, 2, zero)); 565 (void)apf.convertFromAPInt(GV.IntVal, 566 false, 567 APFloat::rmNearestTiesToEven); 568 GV.IntVal = apf.bitcastToAPInt(); 569 } 570 return GV; 571 } 572 case Instruction::SIToFP: { 573 GenericValue GV = getConstantValue(Op0); 574 if (CE->getType()->isFloatTy()) 575 GV.FloatVal = float(GV.IntVal.signedRoundToDouble()); 576 else if (CE->getType()->isDoubleTy()) 577 GV.DoubleVal = GV.IntVal.signedRoundToDouble(); 578 else if (CE->getType()->isX86_FP80Ty()) { 579 const uint64_t zero[] = { 0, 0}; 580 APFloat apf = APFloat(APInt(80, 2, zero)); 581 (void)apf.convertFromAPInt(GV.IntVal, 582 true, 583 APFloat::rmNearestTiesToEven); 584 GV.IntVal = apf.bitcastToAPInt(); 585 } 586 return GV; 587 } 588 case Instruction::FPToUI: // double->APInt conversion handles sign 589 case Instruction::FPToSI: { 590 GenericValue GV = getConstantValue(Op0); 591 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); 592 if (Op0->getType()->isFloatTy()) 593 GV.IntVal = APIntOps::RoundFloatToAPInt(GV.FloatVal, BitWidth); 594 else if (Op0->getType()->isDoubleTy()) 595 GV.IntVal = APIntOps::RoundDoubleToAPInt(GV.DoubleVal, BitWidth); 596 else if (Op0->getType()->isX86_FP80Ty()) { 597 APFloat apf = APFloat(GV.IntVal); 598 uint64_t v; 599 bool ignored; 600 (void)apf.convertToInteger(&v, BitWidth, 601 CE->getOpcode()==Instruction::FPToSI, 602 APFloat::rmTowardZero, &ignored); 603 GV.IntVal = v; // endian? 604 } 605 return GV; 606 } 607 case Instruction::PtrToInt: { 608 GenericValue GV = getConstantValue(Op0); 609 uint32_t PtrWidth = TD->getPointerSizeInBits(); 610 GV.IntVal = APInt(PtrWidth, uintptr_t(GV.PointerVal)); 611 return GV; 612 } 613 case Instruction::IntToPtr: { 614 GenericValue GV = getConstantValue(Op0); 615 uint32_t PtrWidth = TD->getPointerSizeInBits(); 616 if (PtrWidth != GV.IntVal.getBitWidth()) 617 GV.IntVal = GV.IntVal.zextOrTrunc(PtrWidth); 618 assert(GV.IntVal.getBitWidth() <= 64 && "Bad pointer width"); 619 GV.PointerVal = PointerTy(uintptr_t(GV.IntVal.getZExtValue())); 620 return GV; 621 } 622 case Instruction::BitCast: { 623 GenericValue GV = getConstantValue(Op0); 624 const Type* DestTy = CE->getType(); 625 switch (Op0->getType()->getTypeID()) { 626 default: llvm_unreachable("Invalid bitcast operand"); 627 case Type::IntegerTyID: 628 assert(DestTy->isFloatingPoint() && "invalid bitcast"); 629 if (DestTy->isFloatTy()) 630 GV.FloatVal = GV.IntVal.bitsToFloat(); 631 else if (DestTy->isDoubleTy()) 632 GV.DoubleVal = GV.IntVal.bitsToDouble(); 633 break; 634 case Type::FloatTyID: 635 assert(DestTy->isInteger(32) && "Invalid bitcast"); 636 GV.IntVal.floatToBits(GV.FloatVal); 637 break; 638 case Type::DoubleTyID: 639 assert(DestTy->isInteger(64) && "Invalid bitcast"); 640 GV.IntVal.doubleToBits(GV.DoubleVal); 641 break; 642 case Type::PointerTyID: 643 assert(isa<PointerType>(DestTy) && "Invalid bitcast"); 644 break; // getConstantValue(Op0) above already converted it 645 } 646 return GV; 647 } 648 case Instruction::Add: 649 case Instruction::FAdd: 650 case Instruction::Sub: 651 case Instruction::FSub: 652 case Instruction::Mul: 653 case Instruction::FMul: 654 case Instruction::UDiv: 655 case Instruction::SDiv: 656 case Instruction::URem: 657 case Instruction::SRem: 658 case Instruction::And: 659 case Instruction::Or: 660 case Instruction::Xor: { 661 GenericValue LHS = getConstantValue(Op0); 662 GenericValue RHS = getConstantValue(CE->getOperand(1)); 663 GenericValue GV; 664 switch (CE->getOperand(0)->getType()->getTypeID()) { 665 default: llvm_unreachable("Bad add type!"); 666 case Type::IntegerTyID: 667 switch (CE->getOpcode()) { 668 default: llvm_unreachable("Invalid integer opcode"); 669 case Instruction::Add: GV.IntVal = LHS.IntVal + RHS.IntVal; break; 670 case Instruction::Sub: GV.IntVal = LHS.IntVal - RHS.IntVal; break; 671 case Instruction::Mul: GV.IntVal = LHS.IntVal * RHS.IntVal; break; 672 case Instruction::UDiv:GV.IntVal = LHS.IntVal.udiv(RHS.IntVal); break; 673 case Instruction::SDiv:GV.IntVal = LHS.IntVal.sdiv(RHS.IntVal); break; 674 case Instruction::URem:GV.IntVal = LHS.IntVal.urem(RHS.IntVal); break; 675 case Instruction::SRem:GV.IntVal = LHS.IntVal.srem(RHS.IntVal); break; 676 case Instruction::And: GV.IntVal = LHS.IntVal & RHS.IntVal; break; 677 case Instruction::Or: GV.IntVal = LHS.IntVal | RHS.IntVal; break; 678 case Instruction::Xor: GV.IntVal = LHS.IntVal ^ RHS.IntVal; break; 679 } 680 break; 681 case Type::FloatTyID: 682 switch (CE->getOpcode()) { 683 default: llvm_unreachable("Invalid float opcode"); 684 case Instruction::FAdd: 685 GV.FloatVal = LHS.FloatVal + RHS.FloatVal; break; 686 case Instruction::FSub: 687 GV.FloatVal = LHS.FloatVal - RHS.FloatVal; break; 688 case Instruction::FMul: 689 GV.FloatVal = LHS.FloatVal * RHS.FloatVal; break; 690 case Instruction::FDiv: 691 GV.FloatVal = LHS.FloatVal / RHS.FloatVal; break; 692 case Instruction::FRem: 693 GV.FloatVal = ::fmodf(LHS.FloatVal,RHS.FloatVal); break; 694 } 695 break; 696 case Type::DoubleTyID: 697 switch (CE->getOpcode()) { 698 default: llvm_unreachable("Invalid double opcode"); 699 case Instruction::FAdd: 700 GV.DoubleVal = LHS.DoubleVal + RHS.DoubleVal; break; 701 case Instruction::FSub: 702 GV.DoubleVal = LHS.DoubleVal - RHS.DoubleVal; break; 703 case Instruction::FMul: 704 GV.DoubleVal = LHS.DoubleVal * RHS.DoubleVal; break; 705 case Instruction::FDiv: 706 GV.DoubleVal = LHS.DoubleVal / RHS.DoubleVal; break; 707 case Instruction::FRem: 708 GV.DoubleVal = ::fmod(LHS.DoubleVal,RHS.DoubleVal); break; 709 } 710 break; 711 case Type::X86_FP80TyID: 712 case Type::PPC_FP128TyID: 713 case Type::FP128TyID: { 714 APFloat apfLHS = APFloat(LHS.IntVal); 715 switch (CE->getOpcode()) { 716 default: llvm_unreachable("Invalid long double opcode");llvm_unreachable(0); 717 case Instruction::FAdd: 718 apfLHS.add(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); 719 GV.IntVal = apfLHS.bitcastToAPInt(); 720 break; 721 case Instruction::FSub: 722 apfLHS.subtract(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); 723 GV.IntVal = apfLHS.bitcastToAPInt(); 724 break; 725 case Instruction::FMul: 726 apfLHS.multiply(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); 727 GV.IntVal = apfLHS.bitcastToAPInt(); 728 break; 729 case Instruction::FDiv: 730 apfLHS.divide(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); 731 GV.IntVal = apfLHS.bitcastToAPInt(); 732 break; 733 case Instruction::FRem: 734 apfLHS.mod(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); 735 GV.IntVal = apfLHS.bitcastToAPInt(); 736 break; 737 } 738 } 739 break; 740 } 741 return GV; 742 } 743 default: 744 break; 745 } 746 std::string msg; 747 raw_string_ostream Msg(msg); 748 Msg << "ConstantExpr not handled: " << *CE; 749 llvm_report_error(Msg.str()); 750 } 751 752 GenericValue Result; 753 switch (C->getType()->getTypeID()) { 754 case Type::FloatTyID: 755 Result.FloatVal = cast<ConstantFP>(C)->getValueAPF().convertToFloat(); 756 break; 757 case Type::DoubleTyID: 758 Result.DoubleVal = cast<ConstantFP>(C)->getValueAPF().convertToDouble(); 759 break; 760 case Type::X86_FP80TyID: 761 case Type::FP128TyID: 762 case Type::PPC_FP128TyID: 763 Result.IntVal = cast <ConstantFP>(C)->getValueAPF().bitcastToAPInt(); 764 break; 765 case Type::IntegerTyID: 766 Result.IntVal = cast<ConstantInt>(C)->getValue(); 767 break; 768 case Type::PointerTyID: 769 if (isa<ConstantPointerNull>(C)) 770 Result.PointerVal = 0; 771 else if (const Function *F = dyn_cast<Function>(C)) 772 Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F))); 773 else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) 774 Result = PTOGV(getOrEmitGlobalVariable(const_cast<GlobalVariable*>(GV))); 775 else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C)) 776 Result = PTOGV(getPointerToBasicBlock(const_cast<BasicBlock*>( 777 BA->getBasicBlock()))); 778 else 779 llvm_unreachable("Unknown constant pointer type!"); 780 break; 781 default: 782 std::string msg; 783 raw_string_ostream Msg(msg); 784 Msg << "ERROR: Constant unimplemented for type: " << *C->getType(); 785 llvm_report_error(Msg.str()); 786 } 787 return Result; 788} 789 790/// StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst 791/// with the integer held in IntVal. 792static void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst, 793 unsigned StoreBytes) { 794 assert((IntVal.getBitWidth()+7)/8 >= StoreBytes && "Integer too small!"); 795 uint8_t *Src = (uint8_t *)IntVal.getRawData(); 796 797 if (sys::isLittleEndianHost()) 798 // Little-endian host - the source is ordered from LSB to MSB. Order the 799 // destination from LSB to MSB: Do a straight copy. 800 memcpy(Dst, Src, StoreBytes); 801 else { 802 // Big-endian host - the source is an array of 64 bit words ordered from 803 // LSW to MSW. Each word is ordered from MSB to LSB. Order the destination 804 // from MSB to LSB: Reverse the word order, but not the bytes in a word. 805 while (StoreBytes > sizeof(uint64_t)) { 806 StoreBytes -= sizeof(uint64_t); 807 // May not be aligned so use memcpy. 808 memcpy(Dst + StoreBytes, Src, sizeof(uint64_t)); 809 Src += sizeof(uint64_t); 810 } 811 812 memcpy(Dst, Src + sizeof(uint64_t) - StoreBytes, StoreBytes); 813 } 814} 815 816/// StoreValueToMemory - Stores the data in Val of type Ty at address Ptr. Ptr 817/// is the address of the memory at which to store Val, cast to GenericValue *. 818/// It is not a pointer to a GenericValue containing the address at which to 819/// store Val. 820void ExecutionEngine::StoreValueToMemory(const GenericValue &Val, 821 GenericValue *Ptr, const Type *Ty) { 822 const unsigned StoreBytes = getTargetData()->getTypeStoreSize(Ty); 823 824 switch (Ty->getTypeID()) { 825 case Type::IntegerTyID: 826 StoreIntToMemory(Val.IntVal, (uint8_t*)Ptr, StoreBytes); 827 break; 828 case Type::FloatTyID: 829 *((float*)Ptr) = Val.FloatVal; 830 break; 831 case Type::DoubleTyID: 832 *((double*)Ptr) = Val.DoubleVal; 833 break; 834 case Type::X86_FP80TyID: 835 memcpy(Ptr, Val.IntVal.getRawData(), 10); 836 break; 837 case Type::PointerTyID: 838 // Ensure 64 bit target pointers are fully initialized on 32 bit hosts. 839 if (StoreBytes != sizeof(PointerTy)) 840 memset(Ptr, 0, StoreBytes); 841 842 *((PointerTy*)Ptr) = Val.PointerVal; 843 break; 844 default: 845 dbgs() << "Cannot store value of type " << *Ty << "!\n"; 846 } 847 848 if (sys::isLittleEndianHost() != getTargetData()->isLittleEndian()) 849 // Host and target are different endian - reverse the stored bytes. 850 std::reverse((uint8_t*)Ptr, StoreBytes + (uint8_t*)Ptr); 851} 852 853/// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting 854/// from Src into IntVal, which is assumed to be wide enough and to hold zero. 855static void LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes) { 856 assert((IntVal.getBitWidth()+7)/8 >= LoadBytes && "Integer too small!"); 857 uint8_t *Dst = (uint8_t *)IntVal.getRawData(); 858 859 if (sys::isLittleEndianHost()) 860 // Little-endian host - the destination must be ordered from LSB to MSB. 861 // The source is ordered from LSB to MSB: Do a straight copy. 862 memcpy(Dst, Src, LoadBytes); 863 else { 864 // Big-endian - the destination is an array of 64 bit words ordered from 865 // LSW to MSW. Each word must be ordered from MSB to LSB. The source is 866 // ordered from MSB to LSB: Reverse the word order, but not the bytes in 867 // a word. 868 while (LoadBytes > sizeof(uint64_t)) { 869 LoadBytes -= sizeof(uint64_t); 870 // May not be aligned so use memcpy. 871 memcpy(Dst, Src + LoadBytes, sizeof(uint64_t)); 872 Dst += sizeof(uint64_t); 873 } 874 875 memcpy(Dst + sizeof(uint64_t) - LoadBytes, Src, LoadBytes); 876 } 877} 878 879/// FIXME: document 880/// 881void ExecutionEngine::LoadValueFromMemory(GenericValue &Result, 882 GenericValue *Ptr, 883 const Type *Ty) { 884 const unsigned LoadBytes = getTargetData()->getTypeStoreSize(Ty); 885 886 switch (Ty->getTypeID()) { 887 case Type::IntegerTyID: 888 // An APInt with all words initially zero. 889 Result.IntVal = APInt(cast<IntegerType>(Ty)->getBitWidth(), 0); 890 LoadIntFromMemory(Result.IntVal, (uint8_t*)Ptr, LoadBytes); 891 break; 892 case Type::FloatTyID: 893 Result.FloatVal = *((float*)Ptr); 894 break; 895 case Type::DoubleTyID: 896 Result.DoubleVal = *((double*)Ptr); 897 break; 898 case Type::PointerTyID: 899 Result.PointerVal = *((PointerTy*)Ptr); 900 break; 901 case Type::X86_FP80TyID: { 902 // This is endian dependent, but it will only work on x86 anyway. 903 // FIXME: Will not trap if loading a signaling NaN. 904 uint64_t y[2]; 905 memcpy(y, Ptr, 10); 906 Result.IntVal = APInt(80, 2, y); 907 break; 908 } 909 default: 910 std::string msg; 911 raw_string_ostream Msg(msg); 912 Msg << "Cannot load value of type " << *Ty << "!"; 913 llvm_report_error(Msg.str()); 914 } 915} 916 917// InitializeMemory - Recursive function to apply a Constant value into the 918// specified memory location... 919// 920void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) { 921 DEBUG(dbgs() << "JIT: Initializing " << Addr << " "); 922 DEBUG(Init->dump()); 923 if (isa<UndefValue>(Init)) { 924 return; 925 } else if (const ConstantVector *CP = dyn_cast<ConstantVector>(Init)) { 926 unsigned ElementSize = 927 getTargetData()->getTypeAllocSize(CP->getType()->getElementType()); 928 for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i) 929 InitializeMemory(CP->getOperand(i), (char*)Addr+i*ElementSize); 930 return; 931 } else if (isa<ConstantAggregateZero>(Init)) { 932 memset(Addr, 0, (size_t)getTargetData()->getTypeAllocSize(Init->getType())); 933 return; 934 } else if (const ConstantArray *CPA = dyn_cast<ConstantArray>(Init)) { 935 unsigned ElementSize = 936 getTargetData()->getTypeAllocSize(CPA->getType()->getElementType()); 937 for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i) 938 InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize); 939 return; 940 } else if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(Init)) { 941 const StructLayout *SL = 942 getTargetData()->getStructLayout(cast<StructType>(CPS->getType())); 943 for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i) 944 InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->getElementOffset(i)); 945 return; 946 } else if (Init->getType()->isFirstClassType()) { 947 GenericValue Val = getConstantValue(Init); 948 StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType()); 949 return; 950 } 951 952 dbgs() << "Bad Type: " << *Init->getType() << "\n"; 953 llvm_unreachable("Unknown constant type to initialize memory with!"); 954} 955 956/// EmitGlobals - Emit all of the global variables to memory, storing their 957/// addresses into GlobalAddress. This must make sure to copy the contents of 958/// their initializers into the memory. 959/// 960void ExecutionEngine::emitGlobals() { 961 962 // Loop over all of the global variables in the program, allocating the memory 963 // to hold them. If there is more than one module, do a prepass over globals 964 // to figure out how the different modules should link together. 965 // 966 std::map<std::pair<std::string, const Type*>, 967 const GlobalValue*> LinkedGlobalsMap; 968 969 if (Modules.size() != 1) { 970 for (unsigned m = 0, e = Modules.size(); m != e; ++m) { 971 Module &M = *Modules[m]->getModule(); 972 for (Module::const_global_iterator I = M.global_begin(), 973 E = M.global_end(); I != E; ++I) { 974 const GlobalValue *GV = I; 975 if (GV->hasLocalLinkage() || GV->isDeclaration() || 976 GV->hasAppendingLinkage() || !GV->hasName()) 977 continue;// Ignore external globals and globals with internal linkage. 978 979 const GlobalValue *&GVEntry = 980 LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())]; 981 982 // If this is the first time we've seen this global, it is the canonical 983 // version. 984 if (!GVEntry) { 985 GVEntry = GV; 986 continue; 987 } 988 989 // If the existing global is strong, never replace it. 990 if (GVEntry->hasExternalLinkage() || 991 GVEntry->hasDLLImportLinkage() || 992 GVEntry->hasDLLExportLinkage()) 993 continue; 994 995 // Otherwise, we know it's linkonce/weak, replace it if this is a strong 996 // symbol. FIXME is this right for common? 997 if (GV->hasExternalLinkage() || GVEntry->hasExternalWeakLinkage()) 998 GVEntry = GV; 999 } 1000 } 1001 } 1002 1003 std::vector<const GlobalValue*> NonCanonicalGlobals; 1004 for (unsigned m = 0, e = Modules.size(); m != e; ++m) { 1005 Module &M = *Modules[m]->getModule(); 1006 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 1007 I != E; ++I) { 1008 // In the multi-module case, see what this global maps to. 1009 if (!LinkedGlobalsMap.empty()) { 1010 if (const GlobalValue *GVEntry = 1011 LinkedGlobalsMap[std::make_pair(I->getName(), I->getType())]) { 1012 // If something else is the canonical global, ignore this one. 1013 if (GVEntry != &*I) { 1014 NonCanonicalGlobals.push_back(I); 1015 continue; 1016 } 1017 } 1018 } 1019 1020 if (!I->isDeclaration()) { 1021 addGlobalMapping(I, getMemoryForGV(I)); 1022 } else { 1023 // External variable reference. Try to use the dynamic loader to 1024 // get a pointer to it. 1025 if (void *SymAddr = 1026 sys::DynamicLibrary::SearchForAddressOfSymbol(I->getName())) 1027 addGlobalMapping(I, SymAddr); 1028 else { 1029 llvm_report_error("Could not resolve external global address: " 1030 +I->getName()); 1031 } 1032 } 1033 } 1034 1035 // If there are multiple modules, map the non-canonical globals to their 1036 // canonical location. 1037 if (!NonCanonicalGlobals.empty()) { 1038 for (unsigned i = 0, e = NonCanonicalGlobals.size(); i != e; ++i) { 1039 const GlobalValue *GV = NonCanonicalGlobals[i]; 1040 const GlobalValue *CGV = 1041 LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())]; 1042 void *Ptr = getPointerToGlobalIfAvailable(CGV); 1043 assert(Ptr && "Canonical global wasn't codegen'd!"); 1044 addGlobalMapping(GV, Ptr); 1045 } 1046 } 1047 1048 // Now that all of the globals are set up in memory, loop through them all 1049 // and initialize their contents. 1050 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 1051 I != E; ++I) { 1052 if (!I->isDeclaration()) { 1053 if (!LinkedGlobalsMap.empty()) { 1054 if (const GlobalValue *GVEntry = 1055 LinkedGlobalsMap[std::make_pair(I->getName(), I->getType())]) 1056 if (GVEntry != &*I) // Not the canonical variable. 1057 continue; 1058 } 1059 EmitGlobalVariable(I); 1060 } 1061 } 1062 } 1063} 1064 1065// EmitGlobalVariable - This method emits the specified global variable to the 1066// address specified in GlobalAddresses, or allocates new memory if it's not 1067// already in the map. 1068void ExecutionEngine::EmitGlobalVariable(const GlobalVariable *GV) { 1069 void *GA = getPointerToGlobalIfAvailable(GV); 1070 1071 if (GA == 0) { 1072 // If it's not already specified, allocate memory for the global. 1073 GA = getMemoryForGV(GV); 1074 addGlobalMapping(GV, GA); 1075 } 1076 1077 // Don't initialize if it's thread local, let the client do it. 1078 if (!GV->isThreadLocal()) 1079 InitializeMemory(GV->getInitializer(), GA); 1080 1081 const Type *ElTy = GV->getType()->getElementType(); 1082 size_t GVSize = (size_t)getTargetData()->getTypeAllocSize(ElTy); 1083 NumInitBytes += (unsigned)GVSize; 1084 ++NumGlobals; 1085} 1086 1087ExecutionEngineState::ExecutionEngineState(ExecutionEngine &EE) 1088 : EE(EE), GlobalAddressMap(this) { 1089} 1090 1091sys::Mutex *ExecutionEngineState::AddressMapConfig::getMutex( 1092 ExecutionEngineState *EES) { 1093 return &EES->EE.lock; 1094} 1095void ExecutionEngineState::AddressMapConfig::onDelete( 1096 ExecutionEngineState *EES, const GlobalValue *Old) { 1097 void *OldVal = EES->GlobalAddressMap.lookup(Old); 1098 EES->GlobalAddressReverseMap.erase(OldVal); 1099} 1100 1101void ExecutionEngineState::AddressMapConfig::onRAUW( 1102 ExecutionEngineState *, const GlobalValue *, const GlobalValue *) { 1103 assert(false && "The ExecutionEngine doesn't know how to handle a" 1104 " RAUW on a value it has a global mapping for."); 1105} 1106