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 #include "llvm/ExecutionEngine/ExecutionEngine.h" 16 #include "llvm/ADT/STLExtras.h" 17 #include "llvm/ADT/SmallString.h" 18 #include "llvm/ADT/Statistic.h" 19 #include "llvm/ExecutionEngine/GenericValue.h" 20 #include "llvm/ExecutionEngine/JITEventListener.h" 21 #include "llvm/ExecutionEngine/RTDyldMemoryManager.h" 22 #include "llvm/IR/Constants.h" 23 #include "llvm/IR/DataLayout.h" 24 #include "llvm/IR/DerivedTypes.h" 25 #include "llvm/IR/Mangler.h" 26 #include "llvm/IR/Module.h" 27 #include "llvm/IR/Operator.h" 28 #include "llvm/IR/ValueHandle.h" 29 #include "llvm/Object/Archive.h" 30 #include "llvm/Object/ObjectFile.h" 31 #include "llvm/Support/Debug.h" 32 #include "llvm/Support/DynamicLibrary.h" 33 #include "llvm/Support/ErrorHandling.h" 34 #include "llvm/Support/Host.h" 35 #include "llvm/Support/MutexGuard.h" 36 #include "llvm/Support/TargetRegistry.h" 37 #include "llvm/Support/raw_ostream.h" 38 #include "llvm/Target/TargetMachine.h" 39 #include <cmath> 40 #include <cstring> 41 using namespace llvm; 42 43 #define DEBUG_TYPE "jit" 44 45 STATISTIC(NumInitBytes, "Number of bytes of global vars initialized"); 46 STATISTIC(NumGlobals , "Number of global vars initialized"); 47 48 ExecutionEngine *(*ExecutionEngine::MCJITCtor)( 49 std::unique_ptr<Module> M, std::string *ErrorStr, 50 std::shared_ptr<MCJITMemoryManager> MemMgr, 51 std::shared_ptr<RuntimeDyld::SymbolResolver> Resolver, 52 std::unique_ptr<TargetMachine> TM) = nullptr; 53 54 ExecutionEngine *(*ExecutionEngine::OrcMCJITReplacementCtor)( 55 std::string *ErrorStr, std::shared_ptr<MCJITMemoryManager> MemMgr, 56 std::shared_ptr<RuntimeDyld::SymbolResolver> Resolver, 57 std::unique_ptr<TargetMachine> TM) = nullptr; 58 59 ExecutionEngine *(*ExecutionEngine::InterpCtor)(std::unique_ptr<Module> M, 60 std::string *ErrorStr) =nullptr; 61 62 void JITEventListener::anchor() {} 63 64 ExecutionEngine::ExecutionEngine(std::unique_ptr<Module> M) 65 : LazyFunctionCreator(nullptr) { 66 CompilingLazily = false; 67 GVCompilationDisabled = false; 68 SymbolSearchingDisabled = false; 69 70 // IR module verification is enabled by default in debug builds, and disabled 71 // by default in release builds. 72 #ifndef NDEBUG 73 VerifyModules = true; 74 #else 75 VerifyModules = false; 76 #endif 77 78 assert(M && "Module is null?"); 79 Modules.push_back(std::move(M)); 80 } 81 82 ExecutionEngine::~ExecutionEngine() { 83 clearAllGlobalMappings(); 84 } 85 86 namespace { 87 /// \brief Helper class which uses a value handler to automatically deletes the 88 /// memory block when the GlobalVariable is destroyed. 89 class GVMemoryBlock : public CallbackVH { 90 GVMemoryBlock(const GlobalVariable *GV) 91 : CallbackVH(const_cast<GlobalVariable*>(GV)) {} 92 93 public: 94 /// \brief Returns the address the GlobalVariable should be written into. The 95 /// GVMemoryBlock object prefixes that. 96 static char *Create(const GlobalVariable *GV, const DataLayout& TD) { 97 Type *ElTy = GV->getType()->getElementType(); 98 size_t GVSize = (size_t)TD.getTypeAllocSize(ElTy); 99 void *RawMemory = ::operator new( 100 RoundUpToAlignment(sizeof(GVMemoryBlock), 101 TD.getPreferredAlignment(GV)) 102 + GVSize); 103 new(RawMemory) GVMemoryBlock(GV); 104 return static_cast<char*>(RawMemory) + sizeof(GVMemoryBlock); 105 } 106 107 void deleted() override { 108 // We allocated with operator new and with some extra memory hanging off the 109 // end, so don't just delete this. I'm not sure if this is actually 110 // required. 111 this->~GVMemoryBlock(); 112 ::operator delete(this); 113 } 114 }; 115 } // anonymous namespace 116 117 char *ExecutionEngine::getMemoryForGV(const GlobalVariable *GV) { 118 return GVMemoryBlock::Create(GV, *getDataLayout()); 119 } 120 121 void ExecutionEngine::addObjectFile(std::unique_ptr<object::ObjectFile> O) { 122 llvm_unreachable("ExecutionEngine subclass doesn't implement addObjectFile."); 123 } 124 125 void 126 ExecutionEngine::addObjectFile(object::OwningBinary<object::ObjectFile> O) { 127 llvm_unreachable("ExecutionEngine subclass doesn't implement addObjectFile."); 128 } 129 130 void ExecutionEngine::addArchive(object::OwningBinary<object::Archive> A) { 131 llvm_unreachable("ExecutionEngine subclass doesn't implement addArchive."); 132 } 133 134 bool ExecutionEngine::removeModule(Module *M) { 135 for (auto I = Modules.begin(), E = Modules.end(); I != E; ++I) { 136 Module *Found = I->get(); 137 if (Found == M) { 138 I->release(); 139 Modules.erase(I); 140 clearGlobalMappingsFromModule(M); 141 return true; 142 } 143 } 144 return false; 145 } 146 147 Function *ExecutionEngine::FindFunctionNamed(const char *FnName) { 148 for (unsigned i = 0, e = Modules.size(); i != e; ++i) { 149 Function *F = Modules[i]->getFunction(FnName); 150 if (F && !F->isDeclaration()) 151 return F; 152 } 153 return nullptr; 154 } 155 156 157 uint64_t ExecutionEngineState::RemoveMapping(StringRef Name) { 158 GlobalAddressMapTy::iterator I = GlobalAddressMap.find(Name); 159 uint64_t OldVal; 160 161 // FIXME: This is silly, we shouldn't end up with a mapping -> 0 in the 162 // GlobalAddressMap. 163 if (I == GlobalAddressMap.end()) 164 OldVal = 0; 165 else { 166 GlobalAddressReverseMap.erase(I->second); 167 OldVal = I->second; 168 GlobalAddressMap.erase(I); 169 } 170 171 return OldVal; 172 } 173 174 std::string ExecutionEngine::getMangledName(const GlobalValue *GV) { 175 MutexGuard locked(lock); 176 Mangler Mang(DL); 177 SmallString<128> FullName; 178 Mang.getNameWithPrefix(FullName, GV->getName()); 179 return FullName.str(); 180 } 181 182 void ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) { 183 MutexGuard locked(lock); 184 addGlobalMapping(getMangledName(GV), (uint64_t) Addr); 185 } 186 187 void ExecutionEngine::addGlobalMapping(StringRef Name, uint64_t Addr) { 188 MutexGuard locked(lock); 189 190 assert(!Name.empty() && "Empty GlobalMapping symbol name!"); 191 192 DEBUG(dbgs() << "JIT: Map \'" << Name << "\' to [" << Addr << "]\n";); 193 uint64_t &CurVal = EEState.getGlobalAddressMap()[Name]; 194 assert((!CurVal || !Addr) && "GlobalMapping already established!"); 195 CurVal = Addr; 196 197 // If we are using the reverse mapping, add it too. 198 if (!EEState.getGlobalAddressReverseMap().empty()) { 199 std::string &V = EEState.getGlobalAddressReverseMap()[CurVal]; 200 assert((!V.empty() || !Name.empty()) && 201 "GlobalMapping already established!"); 202 V = Name; 203 } 204 } 205 206 void ExecutionEngine::clearAllGlobalMappings() { 207 MutexGuard locked(lock); 208 209 EEState.getGlobalAddressMap().clear(); 210 EEState.getGlobalAddressReverseMap().clear(); 211 } 212 213 void ExecutionEngine::clearGlobalMappingsFromModule(Module *M) { 214 MutexGuard locked(lock); 215 216 for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI) 217 EEState.RemoveMapping(getMangledName(FI)); 218 for (Module::global_iterator GI = M->global_begin(), GE = M->global_end(); 219 GI != GE; ++GI) 220 EEState.RemoveMapping(getMangledName(GI)); 221 } 222 223 uint64_t ExecutionEngine::updateGlobalMapping(const GlobalValue *GV, 224 void *Addr) { 225 MutexGuard locked(lock); 226 return updateGlobalMapping(getMangledName(GV), (uint64_t) Addr); 227 } 228 229 uint64_t ExecutionEngine::updateGlobalMapping(StringRef Name, uint64_t Addr) { 230 MutexGuard locked(lock); 231 232 ExecutionEngineState::GlobalAddressMapTy &Map = 233 EEState.getGlobalAddressMap(); 234 235 // Deleting from the mapping? 236 if (!Addr) 237 return EEState.RemoveMapping(Name); 238 239 uint64_t &CurVal = Map[Name]; 240 uint64_t OldVal = CurVal; 241 242 if (CurVal && !EEState.getGlobalAddressReverseMap().empty()) 243 EEState.getGlobalAddressReverseMap().erase(CurVal); 244 CurVal = Addr; 245 246 // If we are using the reverse mapping, add it too. 247 if (!EEState.getGlobalAddressReverseMap().empty()) { 248 std::string &V = EEState.getGlobalAddressReverseMap()[CurVal]; 249 assert((!V.empty() || !Name.empty()) && 250 "GlobalMapping already established!"); 251 V = Name; 252 } 253 return OldVal; 254 } 255 256 uint64_t ExecutionEngine::getAddressToGlobalIfAvailable(StringRef S) { 257 MutexGuard locked(lock); 258 uint64_t Address = 0; 259 ExecutionEngineState::GlobalAddressMapTy::iterator I = 260 EEState.getGlobalAddressMap().find(S); 261 if (I != EEState.getGlobalAddressMap().end()) 262 Address = I->second; 263 return Address; 264 } 265 266 267 void *ExecutionEngine::getPointerToGlobalIfAvailable(StringRef S) { 268 MutexGuard locked(lock); 269 if (void* Address = (void *) getAddressToGlobalIfAvailable(S)) 270 return Address; 271 return nullptr; 272 } 273 274 void *ExecutionEngine::getPointerToGlobalIfAvailable(const GlobalValue *GV) { 275 MutexGuard locked(lock); 276 return getPointerToGlobalIfAvailable(getMangledName(GV)); 277 } 278 279 const GlobalValue *ExecutionEngine::getGlobalValueAtAddress(void *Addr) { 280 MutexGuard locked(lock); 281 282 // If we haven't computed the reverse mapping yet, do so first. 283 if (EEState.getGlobalAddressReverseMap().empty()) { 284 for (ExecutionEngineState::GlobalAddressMapTy::iterator 285 I = EEState.getGlobalAddressMap().begin(), 286 E = EEState.getGlobalAddressMap().end(); I != E; ++I) { 287 StringRef Name = I->first(); 288 uint64_t Addr = I->second; 289 EEState.getGlobalAddressReverseMap().insert(std::make_pair( 290 Addr, Name)); 291 } 292 } 293 294 std::map<uint64_t, std::string>::iterator I = 295 EEState.getGlobalAddressReverseMap().find((uint64_t) Addr); 296 297 if (I != EEState.getGlobalAddressReverseMap().end()) { 298 StringRef Name = I->second; 299 for (unsigned i = 0, e = Modules.size(); i != e; ++i) 300 if (GlobalValue *GV = Modules[i]->getNamedValue(Name)) 301 return GV; 302 } 303 return nullptr; 304 } 305 306 namespace { 307 class ArgvArray { 308 std::unique_ptr<char[]> Array; 309 std::vector<std::unique_ptr<char[]>> Values; 310 public: 311 /// Turn a vector of strings into a nice argv style array of pointers to null 312 /// terminated strings. 313 void *reset(LLVMContext &C, ExecutionEngine *EE, 314 const std::vector<std::string> &InputArgv); 315 }; 316 } // anonymous namespace 317 void *ArgvArray::reset(LLVMContext &C, ExecutionEngine *EE, 318 const std::vector<std::string> &InputArgv) { 319 Values.clear(); // Free the old contents. 320 Values.reserve(InputArgv.size()); 321 unsigned PtrSize = EE->getDataLayout()->getPointerSize(); 322 Array = make_unique<char[]>((InputArgv.size()+1)*PtrSize); 323 324 DEBUG(dbgs() << "JIT: ARGV = " << (void*)Array.get() << "\n"); 325 Type *SBytePtr = Type::getInt8PtrTy(C); 326 327 for (unsigned i = 0; i != InputArgv.size(); ++i) { 328 unsigned Size = InputArgv[i].size()+1; 329 auto Dest = make_unique<char[]>(Size); 330 DEBUG(dbgs() << "JIT: ARGV[" << i << "] = " << (void*)Dest.get() << "\n"); 331 332 std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest.get()); 333 Dest[Size-1] = 0; 334 335 // Endian safe: Array[i] = (PointerTy)Dest; 336 EE->StoreValueToMemory(PTOGV(Dest.get()), 337 (GenericValue*)(&Array[i*PtrSize]), SBytePtr); 338 Values.push_back(std::move(Dest)); 339 } 340 341 // Null terminate it 342 EE->StoreValueToMemory(PTOGV(nullptr), 343 (GenericValue*)(&Array[InputArgv.size()*PtrSize]), 344 SBytePtr); 345 return Array.get(); 346 } 347 348 void ExecutionEngine::runStaticConstructorsDestructors(Module &module, 349 bool isDtors) { 350 const char *Name = isDtors ? "llvm.global_dtors" : "llvm.global_ctors"; 351 GlobalVariable *GV = module.getNamedGlobal(Name); 352 353 // If this global has internal linkage, or if it has a use, then it must be 354 // an old-style (llvmgcc3) static ctor with __main linked in and in use. If 355 // this is the case, don't execute any of the global ctors, __main will do 356 // it. 357 if (!GV || GV->isDeclaration() || GV->hasLocalLinkage()) return; 358 359 // Should be an array of '{ i32, void ()* }' structs. The first value is 360 // the init priority, which we ignore. 361 ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer()); 362 if (!InitList) 363 return; 364 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) { 365 ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i)); 366 if (!CS) continue; 367 368 Constant *FP = CS->getOperand(1); 369 if (FP->isNullValue()) 370 continue; // Found a sentinal value, ignore. 371 372 // Strip off constant expression casts. 373 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP)) 374 if (CE->isCast()) 375 FP = CE->getOperand(0); 376 377 // Execute the ctor/dtor function! 378 if (Function *F = dyn_cast<Function>(FP)) 379 runFunction(F, std::vector<GenericValue>()); 380 381 // FIXME: It is marginally lame that we just do nothing here if we see an 382 // entry we don't recognize. It might not be unreasonable for the verifier 383 // to not even allow this and just assert here. 384 } 385 } 386 387 void ExecutionEngine::runStaticConstructorsDestructors(bool isDtors) { 388 // Execute global ctors/dtors for each module in the program. 389 for (std::unique_ptr<Module> &M : Modules) 390 runStaticConstructorsDestructors(*M, isDtors); 391 } 392 393 #ifndef NDEBUG 394 /// isTargetNullPtr - Return whether the target pointer stored at Loc is null. 395 static bool isTargetNullPtr(ExecutionEngine *EE, void *Loc) { 396 unsigned PtrSize = EE->getDataLayout()->getPointerSize(); 397 for (unsigned i = 0; i < PtrSize; ++i) 398 if (*(i + (uint8_t*)Loc)) 399 return false; 400 return true; 401 } 402 #endif 403 404 int ExecutionEngine::runFunctionAsMain(Function *Fn, 405 const std::vector<std::string> &argv, 406 const char * const * envp) { 407 std::vector<GenericValue> GVArgs; 408 GenericValue GVArgc; 409 GVArgc.IntVal = APInt(32, argv.size()); 410 411 // Check main() type 412 unsigned NumArgs = Fn->getFunctionType()->getNumParams(); 413 FunctionType *FTy = Fn->getFunctionType(); 414 Type* PPInt8Ty = Type::getInt8PtrTy(Fn->getContext())->getPointerTo(); 415 416 // Check the argument types. 417 if (NumArgs > 3) 418 report_fatal_error("Invalid number of arguments of main() supplied"); 419 if (NumArgs >= 3 && FTy->getParamType(2) != PPInt8Ty) 420 report_fatal_error("Invalid type for third argument of main() supplied"); 421 if (NumArgs >= 2 && FTy->getParamType(1) != PPInt8Ty) 422 report_fatal_error("Invalid type for second argument of main() supplied"); 423 if (NumArgs >= 1 && !FTy->getParamType(0)->isIntegerTy(32)) 424 report_fatal_error("Invalid type for first argument of main() supplied"); 425 if (!FTy->getReturnType()->isIntegerTy() && 426 !FTy->getReturnType()->isVoidTy()) 427 report_fatal_error("Invalid return type of main() supplied"); 428 429 ArgvArray CArgv; 430 ArgvArray CEnv; 431 if (NumArgs) { 432 GVArgs.push_back(GVArgc); // Arg #0 = argc. 433 if (NumArgs > 1) { 434 // Arg #1 = argv. 435 GVArgs.push_back(PTOGV(CArgv.reset(Fn->getContext(), this, argv))); 436 assert(!isTargetNullPtr(this, GVTOP(GVArgs[1])) && 437 "argv[0] was null after CreateArgv"); 438 if (NumArgs > 2) { 439 std::vector<std::string> EnvVars; 440 for (unsigned i = 0; envp[i]; ++i) 441 EnvVars.push_back(envp[i]); 442 // Arg #2 = envp. 443 GVArgs.push_back(PTOGV(CEnv.reset(Fn->getContext(), this, EnvVars))); 444 } 445 } 446 } 447 448 return runFunction(Fn, GVArgs).IntVal.getZExtValue(); 449 } 450 451 EngineBuilder::EngineBuilder() : EngineBuilder(nullptr) {} 452 453 EngineBuilder::EngineBuilder(std::unique_ptr<Module> M) 454 : M(std::move(M)), WhichEngine(EngineKind::Either), ErrorStr(nullptr), 455 OptLevel(CodeGenOpt::Default), MemMgr(nullptr), Resolver(nullptr), 456 RelocModel(Reloc::Default), CMModel(CodeModel::JITDefault), 457 UseOrcMCJITReplacement(false) { 458 // IR module verification is enabled by default in debug builds, and disabled 459 // by default in release builds. 460 #ifndef NDEBUG 461 VerifyModules = true; 462 #else 463 VerifyModules = false; 464 #endif 465 } 466 467 EngineBuilder::~EngineBuilder() = default; 468 469 EngineBuilder &EngineBuilder::setMCJITMemoryManager( 470 std::unique_ptr<RTDyldMemoryManager> mcjmm) { 471 auto SharedMM = std::shared_ptr<RTDyldMemoryManager>(std::move(mcjmm)); 472 MemMgr = SharedMM; 473 Resolver = SharedMM; 474 return *this; 475 } 476 477 EngineBuilder& 478 EngineBuilder::setMemoryManager(std::unique_ptr<MCJITMemoryManager> MM) { 479 MemMgr = std::shared_ptr<MCJITMemoryManager>(std::move(MM)); 480 return *this; 481 } 482 483 EngineBuilder& 484 EngineBuilder::setSymbolResolver(std::unique_ptr<RuntimeDyld::SymbolResolver> SR) { 485 Resolver = std::shared_ptr<RuntimeDyld::SymbolResolver>(std::move(SR)); 486 return *this; 487 } 488 489 ExecutionEngine *EngineBuilder::create(TargetMachine *TM) { 490 std::unique_ptr<TargetMachine> TheTM(TM); // Take ownership. 491 492 // Make sure we can resolve symbols in the program as well. The zero arg 493 // to the function tells DynamicLibrary to load the program, not a library. 494 if (sys::DynamicLibrary::LoadLibraryPermanently(nullptr, ErrorStr)) 495 return nullptr; 496 497 // If the user specified a memory manager but didn't specify which engine to 498 // create, we assume they only want the JIT, and we fail if they only want 499 // the interpreter. 500 if (MemMgr) { 501 if (WhichEngine & EngineKind::JIT) 502 WhichEngine = EngineKind::JIT; 503 else { 504 if (ErrorStr) 505 *ErrorStr = "Cannot create an interpreter with a memory manager."; 506 return nullptr; 507 } 508 } 509 510 // Unless the interpreter was explicitly selected or the JIT is not linked, 511 // try making a JIT. 512 if ((WhichEngine & EngineKind::JIT) && TheTM) { 513 Triple TT(M->getTargetTriple()); 514 if (!TM->getTarget().hasJIT()) { 515 errs() << "WARNING: This target JIT is not designed for the host" 516 << " you are running. If bad things happen, please choose" 517 << " a different -march switch.\n"; 518 } 519 520 ExecutionEngine *EE = nullptr; 521 if (ExecutionEngine::OrcMCJITReplacementCtor && UseOrcMCJITReplacement) { 522 EE = ExecutionEngine::OrcMCJITReplacementCtor(ErrorStr, std::move(MemMgr), 523 std::move(Resolver), 524 std::move(TheTM)); 525 EE->addModule(std::move(M)); 526 } else if (ExecutionEngine::MCJITCtor) 527 EE = ExecutionEngine::MCJITCtor(std::move(M), ErrorStr, std::move(MemMgr), 528 std::move(Resolver), std::move(TheTM)); 529 530 if (EE) { 531 EE->setVerifyModules(VerifyModules); 532 return EE; 533 } 534 } 535 536 // If we can't make a JIT and we didn't request one specifically, try making 537 // an interpreter instead. 538 if (WhichEngine & EngineKind::Interpreter) { 539 if (ExecutionEngine::InterpCtor) 540 return ExecutionEngine::InterpCtor(std::move(M), ErrorStr); 541 if (ErrorStr) 542 *ErrorStr = "Interpreter has not been linked in."; 543 return nullptr; 544 } 545 546 if ((WhichEngine & EngineKind::JIT) && !ExecutionEngine::MCJITCtor) { 547 if (ErrorStr) 548 *ErrorStr = "JIT has not been linked in."; 549 } 550 551 return nullptr; 552 } 553 554 void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) { 555 if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV))) 556 return getPointerToFunction(F); 557 558 MutexGuard locked(lock); 559 if (void* P = getPointerToGlobalIfAvailable(GV)) 560 return P; 561 562 // Global variable might have been added since interpreter started. 563 if (GlobalVariable *GVar = 564 const_cast<GlobalVariable *>(dyn_cast<GlobalVariable>(GV))) 565 EmitGlobalVariable(GVar); 566 else 567 llvm_unreachable("Global hasn't had an address allocated yet!"); 568 569 return getPointerToGlobalIfAvailable(GV); 570 } 571 572 /// \brief Converts a Constant* into a GenericValue, including handling of 573 /// ConstantExpr values. 574 GenericValue ExecutionEngine::getConstantValue(const Constant *C) { 575 // If its undefined, return the garbage. 576 if (isa<UndefValue>(C)) { 577 GenericValue Result; 578 switch (C->getType()->getTypeID()) { 579 default: 580 break; 581 case Type::IntegerTyID: 582 case Type::X86_FP80TyID: 583 case Type::FP128TyID: 584 case Type::PPC_FP128TyID: 585 // Although the value is undefined, we still have to construct an APInt 586 // with the correct bit width. 587 Result.IntVal = APInt(C->getType()->getPrimitiveSizeInBits(), 0); 588 break; 589 case Type::StructTyID: { 590 // if the whole struct is 'undef' just reserve memory for the value. 591 if(StructType *STy = dyn_cast<StructType>(C->getType())) { 592 unsigned int elemNum = STy->getNumElements(); 593 Result.AggregateVal.resize(elemNum); 594 for (unsigned int i = 0; i < elemNum; ++i) { 595 Type *ElemTy = STy->getElementType(i); 596 if (ElemTy->isIntegerTy()) 597 Result.AggregateVal[i].IntVal = 598 APInt(ElemTy->getPrimitiveSizeInBits(), 0); 599 else if (ElemTy->isAggregateType()) { 600 const Constant *ElemUndef = UndefValue::get(ElemTy); 601 Result.AggregateVal[i] = getConstantValue(ElemUndef); 602 } 603 } 604 } 605 } 606 break; 607 case Type::VectorTyID: 608 // if the whole vector is 'undef' just reserve memory for the value. 609 const VectorType* VTy = dyn_cast<VectorType>(C->getType()); 610 const Type *ElemTy = VTy->getElementType(); 611 unsigned int elemNum = VTy->getNumElements(); 612 Result.AggregateVal.resize(elemNum); 613 if (ElemTy->isIntegerTy()) 614 for (unsigned int i = 0; i < elemNum; ++i) 615 Result.AggregateVal[i].IntVal = 616 APInt(ElemTy->getPrimitiveSizeInBits(), 0); 617 break; 618 } 619 return Result; 620 } 621 622 // Otherwise, if the value is a ConstantExpr... 623 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 624 Constant *Op0 = CE->getOperand(0); 625 switch (CE->getOpcode()) { 626 case Instruction::GetElementPtr: { 627 // Compute the index 628 GenericValue Result = getConstantValue(Op0); 629 APInt Offset(DL->getPointerSizeInBits(), 0); 630 cast<GEPOperator>(CE)->accumulateConstantOffset(*DL, Offset); 631 632 char* tmp = (char*) Result.PointerVal; 633 Result = PTOGV(tmp + Offset.getSExtValue()); 634 return Result; 635 } 636 case Instruction::Trunc: { 637 GenericValue GV = getConstantValue(Op0); 638 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); 639 GV.IntVal = GV.IntVal.trunc(BitWidth); 640 return GV; 641 } 642 case Instruction::ZExt: { 643 GenericValue GV = getConstantValue(Op0); 644 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); 645 GV.IntVal = GV.IntVal.zext(BitWidth); 646 return GV; 647 } 648 case Instruction::SExt: { 649 GenericValue GV = getConstantValue(Op0); 650 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); 651 GV.IntVal = GV.IntVal.sext(BitWidth); 652 return GV; 653 } 654 case Instruction::FPTrunc: { 655 // FIXME long double 656 GenericValue GV = getConstantValue(Op0); 657 GV.FloatVal = float(GV.DoubleVal); 658 return GV; 659 } 660 case Instruction::FPExt:{ 661 // FIXME long double 662 GenericValue GV = getConstantValue(Op0); 663 GV.DoubleVal = double(GV.FloatVal); 664 return GV; 665 } 666 case Instruction::UIToFP: { 667 GenericValue GV = getConstantValue(Op0); 668 if (CE->getType()->isFloatTy()) 669 GV.FloatVal = float(GV.IntVal.roundToDouble()); 670 else if (CE->getType()->isDoubleTy()) 671 GV.DoubleVal = GV.IntVal.roundToDouble(); 672 else if (CE->getType()->isX86_FP80Ty()) { 673 APFloat apf = APFloat::getZero(APFloat::x87DoubleExtended); 674 (void)apf.convertFromAPInt(GV.IntVal, 675 false, 676 APFloat::rmNearestTiesToEven); 677 GV.IntVal = apf.bitcastToAPInt(); 678 } 679 return GV; 680 } 681 case Instruction::SIToFP: { 682 GenericValue GV = getConstantValue(Op0); 683 if (CE->getType()->isFloatTy()) 684 GV.FloatVal = float(GV.IntVal.signedRoundToDouble()); 685 else if (CE->getType()->isDoubleTy()) 686 GV.DoubleVal = GV.IntVal.signedRoundToDouble(); 687 else if (CE->getType()->isX86_FP80Ty()) { 688 APFloat apf = APFloat::getZero(APFloat::x87DoubleExtended); 689 (void)apf.convertFromAPInt(GV.IntVal, 690 true, 691 APFloat::rmNearestTiesToEven); 692 GV.IntVal = apf.bitcastToAPInt(); 693 } 694 return GV; 695 } 696 case Instruction::FPToUI: // double->APInt conversion handles sign 697 case Instruction::FPToSI: { 698 GenericValue GV = getConstantValue(Op0); 699 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); 700 if (Op0->getType()->isFloatTy()) 701 GV.IntVal = APIntOps::RoundFloatToAPInt(GV.FloatVal, BitWidth); 702 else if (Op0->getType()->isDoubleTy()) 703 GV.IntVal = APIntOps::RoundDoubleToAPInt(GV.DoubleVal, BitWidth); 704 else if (Op0->getType()->isX86_FP80Ty()) { 705 APFloat apf = APFloat(APFloat::x87DoubleExtended, GV.IntVal); 706 uint64_t v; 707 bool ignored; 708 (void)apf.convertToInteger(&v, BitWidth, 709 CE->getOpcode()==Instruction::FPToSI, 710 APFloat::rmTowardZero, &ignored); 711 GV.IntVal = v; // endian? 712 } 713 return GV; 714 } 715 case Instruction::PtrToInt: { 716 GenericValue GV = getConstantValue(Op0); 717 uint32_t PtrWidth = DL->getTypeSizeInBits(Op0->getType()); 718 assert(PtrWidth <= 64 && "Bad pointer width"); 719 GV.IntVal = APInt(PtrWidth, uintptr_t(GV.PointerVal)); 720 uint32_t IntWidth = DL->getTypeSizeInBits(CE->getType()); 721 GV.IntVal = GV.IntVal.zextOrTrunc(IntWidth); 722 return GV; 723 } 724 case Instruction::IntToPtr: { 725 GenericValue GV = getConstantValue(Op0); 726 uint32_t PtrWidth = DL->getTypeSizeInBits(CE->getType()); 727 GV.IntVal = GV.IntVal.zextOrTrunc(PtrWidth); 728 assert(GV.IntVal.getBitWidth() <= 64 && "Bad pointer width"); 729 GV.PointerVal = PointerTy(uintptr_t(GV.IntVal.getZExtValue())); 730 return GV; 731 } 732 case Instruction::BitCast: { 733 GenericValue GV = getConstantValue(Op0); 734 Type* DestTy = CE->getType(); 735 switch (Op0->getType()->getTypeID()) { 736 default: llvm_unreachable("Invalid bitcast operand"); 737 case Type::IntegerTyID: 738 assert(DestTy->isFloatingPointTy() && "invalid bitcast"); 739 if (DestTy->isFloatTy()) 740 GV.FloatVal = GV.IntVal.bitsToFloat(); 741 else if (DestTy->isDoubleTy()) 742 GV.DoubleVal = GV.IntVal.bitsToDouble(); 743 break; 744 case Type::FloatTyID: 745 assert(DestTy->isIntegerTy(32) && "Invalid bitcast"); 746 GV.IntVal = APInt::floatToBits(GV.FloatVal); 747 break; 748 case Type::DoubleTyID: 749 assert(DestTy->isIntegerTy(64) && "Invalid bitcast"); 750 GV.IntVal = APInt::doubleToBits(GV.DoubleVal); 751 break; 752 case Type::PointerTyID: 753 assert(DestTy->isPointerTy() && "Invalid bitcast"); 754 break; // getConstantValue(Op0) above already converted it 755 } 756 return GV; 757 } 758 case Instruction::Add: 759 case Instruction::FAdd: 760 case Instruction::Sub: 761 case Instruction::FSub: 762 case Instruction::Mul: 763 case Instruction::FMul: 764 case Instruction::UDiv: 765 case Instruction::SDiv: 766 case Instruction::URem: 767 case Instruction::SRem: 768 case Instruction::And: 769 case Instruction::Or: 770 case Instruction::Xor: { 771 GenericValue LHS = getConstantValue(Op0); 772 GenericValue RHS = getConstantValue(CE->getOperand(1)); 773 GenericValue GV; 774 switch (CE->getOperand(0)->getType()->getTypeID()) { 775 default: llvm_unreachable("Bad add type!"); 776 case Type::IntegerTyID: 777 switch (CE->getOpcode()) { 778 default: llvm_unreachable("Invalid integer opcode"); 779 case Instruction::Add: GV.IntVal = LHS.IntVal + RHS.IntVal; break; 780 case Instruction::Sub: GV.IntVal = LHS.IntVal - RHS.IntVal; break; 781 case Instruction::Mul: GV.IntVal = LHS.IntVal * RHS.IntVal; break; 782 case Instruction::UDiv:GV.IntVal = LHS.IntVal.udiv(RHS.IntVal); break; 783 case Instruction::SDiv:GV.IntVal = LHS.IntVal.sdiv(RHS.IntVal); break; 784 case Instruction::URem:GV.IntVal = LHS.IntVal.urem(RHS.IntVal); break; 785 case Instruction::SRem:GV.IntVal = LHS.IntVal.srem(RHS.IntVal); break; 786 case Instruction::And: GV.IntVal = LHS.IntVal & RHS.IntVal; break; 787 case Instruction::Or: GV.IntVal = LHS.IntVal | RHS.IntVal; break; 788 case Instruction::Xor: GV.IntVal = LHS.IntVal ^ RHS.IntVal; break; 789 } 790 break; 791 case Type::FloatTyID: 792 switch (CE->getOpcode()) { 793 default: llvm_unreachable("Invalid float opcode"); 794 case Instruction::FAdd: 795 GV.FloatVal = LHS.FloatVal + RHS.FloatVal; break; 796 case Instruction::FSub: 797 GV.FloatVal = LHS.FloatVal - RHS.FloatVal; break; 798 case Instruction::FMul: 799 GV.FloatVal = LHS.FloatVal * RHS.FloatVal; break; 800 case Instruction::FDiv: 801 GV.FloatVal = LHS.FloatVal / RHS.FloatVal; break; 802 case Instruction::FRem: 803 GV.FloatVal = std::fmod(LHS.FloatVal,RHS.FloatVal); break; 804 } 805 break; 806 case Type::DoubleTyID: 807 switch (CE->getOpcode()) { 808 default: llvm_unreachable("Invalid double opcode"); 809 case Instruction::FAdd: 810 GV.DoubleVal = LHS.DoubleVal + RHS.DoubleVal; break; 811 case Instruction::FSub: 812 GV.DoubleVal = LHS.DoubleVal - RHS.DoubleVal; break; 813 case Instruction::FMul: 814 GV.DoubleVal = LHS.DoubleVal * RHS.DoubleVal; break; 815 case Instruction::FDiv: 816 GV.DoubleVal = LHS.DoubleVal / RHS.DoubleVal; break; 817 case Instruction::FRem: 818 GV.DoubleVal = std::fmod(LHS.DoubleVal,RHS.DoubleVal); break; 819 } 820 break; 821 case Type::X86_FP80TyID: 822 case Type::PPC_FP128TyID: 823 case Type::FP128TyID: { 824 const fltSemantics &Sem = CE->getOperand(0)->getType()->getFltSemantics(); 825 APFloat apfLHS = APFloat(Sem, LHS.IntVal); 826 switch (CE->getOpcode()) { 827 default: llvm_unreachable("Invalid long double opcode"); 828 case Instruction::FAdd: 829 apfLHS.add(APFloat(Sem, RHS.IntVal), APFloat::rmNearestTiesToEven); 830 GV.IntVal = apfLHS.bitcastToAPInt(); 831 break; 832 case Instruction::FSub: 833 apfLHS.subtract(APFloat(Sem, RHS.IntVal), 834 APFloat::rmNearestTiesToEven); 835 GV.IntVal = apfLHS.bitcastToAPInt(); 836 break; 837 case Instruction::FMul: 838 apfLHS.multiply(APFloat(Sem, RHS.IntVal), 839 APFloat::rmNearestTiesToEven); 840 GV.IntVal = apfLHS.bitcastToAPInt(); 841 break; 842 case Instruction::FDiv: 843 apfLHS.divide(APFloat(Sem, RHS.IntVal), 844 APFloat::rmNearestTiesToEven); 845 GV.IntVal = apfLHS.bitcastToAPInt(); 846 break; 847 case Instruction::FRem: 848 apfLHS.mod(APFloat(Sem, RHS.IntVal), 849 APFloat::rmNearestTiesToEven); 850 GV.IntVal = apfLHS.bitcastToAPInt(); 851 break; 852 } 853 } 854 break; 855 } 856 return GV; 857 } 858 default: 859 break; 860 } 861 862 SmallString<256> Msg; 863 raw_svector_ostream OS(Msg); 864 OS << "ConstantExpr not handled: " << *CE; 865 report_fatal_error(OS.str()); 866 } 867 868 // Otherwise, we have a simple constant. 869 GenericValue Result; 870 switch (C->getType()->getTypeID()) { 871 case Type::FloatTyID: 872 Result.FloatVal = cast<ConstantFP>(C)->getValueAPF().convertToFloat(); 873 break; 874 case Type::DoubleTyID: 875 Result.DoubleVal = cast<ConstantFP>(C)->getValueAPF().convertToDouble(); 876 break; 877 case Type::X86_FP80TyID: 878 case Type::FP128TyID: 879 case Type::PPC_FP128TyID: 880 Result.IntVal = cast <ConstantFP>(C)->getValueAPF().bitcastToAPInt(); 881 break; 882 case Type::IntegerTyID: 883 Result.IntVal = cast<ConstantInt>(C)->getValue(); 884 break; 885 case Type::PointerTyID: 886 if (isa<ConstantPointerNull>(C)) 887 Result.PointerVal = nullptr; 888 else if (const Function *F = dyn_cast<Function>(C)) 889 Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F))); 890 else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) 891 Result = PTOGV(getOrEmitGlobalVariable(const_cast<GlobalVariable*>(GV))); 892 else 893 llvm_unreachable("Unknown constant pointer type!"); 894 break; 895 case Type::VectorTyID: { 896 unsigned elemNum; 897 Type* ElemTy; 898 const ConstantDataVector *CDV = dyn_cast<ConstantDataVector>(C); 899 const ConstantVector *CV = dyn_cast<ConstantVector>(C); 900 const ConstantAggregateZero *CAZ = dyn_cast<ConstantAggregateZero>(C); 901 902 if (CDV) { 903 elemNum = CDV->getNumElements(); 904 ElemTy = CDV->getElementType(); 905 } else if (CV || CAZ) { 906 VectorType* VTy = dyn_cast<VectorType>(C->getType()); 907 elemNum = VTy->getNumElements(); 908 ElemTy = VTy->getElementType(); 909 } else { 910 llvm_unreachable("Unknown constant vector type!"); 911 } 912 913 Result.AggregateVal.resize(elemNum); 914 // Check if vector holds floats. 915 if(ElemTy->isFloatTy()) { 916 if (CAZ) { 917 GenericValue floatZero; 918 floatZero.FloatVal = 0.f; 919 std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(), 920 floatZero); 921 break; 922 } 923 if(CV) { 924 for (unsigned i = 0; i < elemNum; ++i) 925 if (!isa<UndefValue>(CV->getOperand(i))) 926 Result.AggregateVal[i].FloatVal = cast<ConstantFP>( 927 CV->getOperand(i))->getValueAPF().convertToFloat(); 928 break; 929 } 930 if(CDV) 931 for (unsigned i = 0; i < elemNum; ++i) 932 Result.AggregateVal[i].FloatVal = CDV->getElementAsFloat(i); 933 934 break; 935 } 936 // Check if vector holds doubles. 937 if (ElemTy->isDoubleTy()) { 938 if (CAZ) { 939 GenericValue doubleZero; 940 doubleZero.DoubleVal = 0.0; 941 std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(), 942 doubleZero); 943 break; 944 } 945 if(CV) { 946 for (unsigned i = 0; i < elemNum; ++i) 947 if (!isa<UndefValue>(CV->getOperand(i))) 948 Result.AggregateVal[i].DoubleVal = cast<ConstantFP>( 949 CV->getOperand(i))->getValueAPF().convertToDouble(); 950 break; 951 } 952 if(CDV) 953 for (unsigned i = 0; i < elemNum; ++i) 954 Result.AggregateVal[i].DoubleVal = CDV->getElementAsDouble(i); 955 956 break; 957 } 958 // Check if vector holds integers. 959 if (ElemTy->isIntegerTy()) { 960 if (CAZ) { 961 GenericValue intZero; 962 intZero.IntVal = APInt(ElemTy->getScalarSizeInBits(), 0ull); 963 std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(), 964 intZero); 965 break; 966 } 967 if(CV) { 968 for (unsigned i = 0; i < elemNum; ++i) 969 if (!isa<UndefValue>(CV->getOperand(i))) 970 Result.AggregateVal[i].IntVal = cast<ConstantInt>( 971 CV->getOperand(i))->getValue(); 972 else { 973 Result.AggregateVal[i].IntVal = 974 APInt(CV->getOperand(i)->getType()->getPrimitiveSizeInBits(), 0); 975 } 976 break; 977 } 978 if(CDV) 979 for (unsigned i = 0; i < elemNum; ++i) 980 Result.AggregateVal[i].IntVal = APInt( 981 CDV->getElementType()->getPrimitiveSizeInBits(), 982 CDV->getElementAsInteger(i)); 983 984 break; 985 } 986 llvm_unreachable("Unknown constant pointer type!"); 987 } 988 break; 989 990 default: 991 SmallString<256> Msg; 992 raw_svector_ostream OS(Msg); 993 OS << "ERROR: Constant unimplemented for type: " << *C->getType(); 994 report_fatal_error(OS.str()); 995 } 996 997 return Result; 998 } 999 1000 /// StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst 1001 /// with the integer held in IntVal. 1002 static void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst, 1003 unsigned StoreBytes) { 1004 assert((IntVal.getBitWidth()+7)/8 >= StoreBytes && "Integer too small!"); 1005 const uint8_t *Src = (const uint8_t *)IntVal.getRawData(); 1006 1007 if (sys::IsLittleEndianHost) { 1008 // Little-endian host - the source is ordered from LSB to MSB. Order the 1009 // destination from LSB to MSB: Do a straight copy. 1010 memcpy(Dst, Src, StoreBytes); 1011 } else { 1012 // Big-endian host - the source is an array of 64 bit words ordered from 1013 // LSW to MSW. Each word is ordered from MSB to LSB. Order the destination 1014 // from MSB to LSB: Reverse the word order, but not the bytes in a word. 1015 while (StoreBytes > sizeof(uint64_t)) { 1016 StoreBytes -= sizeof(uint64_t); 1017 // May not be aligned so use memcpy. 1018 memcpy(Dst + StoreBytes, Src, sizeof(uint64_t)); 1019 Src += sizeof(uint64_t); 1020 } 1021 1022 memcpy(Dst, Src + sizeof(uint64_t) - StoreBytes, StoreBytes); 1023 } 1024 } 1025 1026 void ExecutionEngine::StoreValueToMemory(const GenericValue &Val, 1027 GenericValue *Ptr, Type *Ty) { 1028 const unsigned StoreBytes = getDataLayout()->getTypeStoreSize(Ty); 1029 1030 switch (Ty->getTypeID()) { 1031 default: 1032 dbgs() << "Cannot store value of type " << *Ty << "!\n"; 1033 break; 1034 case Type::IntegerTyID: 1035 StoreIntToMemory(Val.IntVal, (uint8_t*)Ptr, StoreBytes); 1036 break; 1037 case Type::FloatTyID: 1038 *((float*)Ptr) = Val.FloatVal; 1039 break; 1040 case Type::DoubleTyID: 1041 *((double*)Ptr) = Val.DoubleVal; 1042 break; 1043 case Type::X86_FP80TyID: 1044 memcpy(Ptr, Val.IntVal.getRawData(), 10); 1045 break; 1046 case Type::PointerTyID: 1047 // Ensure 64 bit target pointers are fully initialized on 32 bit hosts. 1048 if (StoreBytes != sizeof(PointerTy)) 1049 memset(&(Ptr->PointerVal), 0, StoreBytes); 1050 1051 *((PointerTy*)Ptr) = Val.PointerVal; 1052 break; 1053 case Type::VectorTyID: 1054 for (unsigned i = 0; i < Val.AggregateVal.size(); ++i) { 1055 if (cast<VectorType>(Ty)->getElementType()->isDoubleTy()) 1056 *(((double*)Ptr)+i) = Val.AggregateVal[i].DoubleVal; 1057 if (cast<VectorType>(Ty)->getElementType()->isFloatTy()) 1058 *(((float*)Ptr)+i) = Val.AggregateVal[i].FloatVal; 1059 if (cast<VectorType>(Ty)->getElementType()->isIntegerTy()) { 1060 unsigned numOfBytes =(Val.AggregateVal[i].IntVal.getBitWidth()+7)/8; 1061 StoreIntToMemory(Val.AggregateVal[i].IntVal, 1062 (uint8_t*)Ptr + numOfBytes*i, numOfBytes); 1063 } 1064 } 1065 break; 1066 } 1067 1068 if (sys::IsLittleEndianHost != getDataLayout()->isLittleEndian()) 1069 // Host and target are different endian - reverse the stored bytes. 1070 std::reverse((uint8_t*)Ptr, StoreBytes + (uint8_t*)Ptr); 1071 } 1072 1073 /// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting 1074 /// from Src into IntVal, which is assumed to be wide enough and to hold zero. 1075 static void LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes) { 1076 assert((IntVal.getBitWidth()+7)/8 >= LoadBytes && "Integer too small!"); 1077 uint8_t *Dst = reinterpret_cast<uint8_t *>( 1078 const_cast<uint64_t *>(IntVal.getRawData())); 1079 1080 if (sys::IsLittleEndianHost) 1081 // Little-endian host - the destination must be ordered from LSB to MSB. 1082 // The source is ordered from LSB to MSB: Do a straight copy. 1083 memcpy(Dst, Src, LoadBytes); 1084 else { 1085 // Big-endian - the destination is an array of 64 bit words ordered from 1086 // LSW to MSW. Each word must be ordered from MSB to LSB. The source is 1087 // ordered from MSB to LSB: Reverse the word order, but not the bytes in 1088 // a word. 1089 while (LoadBytes > sizeof(uint64_t)) { 1090 LoadBytes -= sizeof(uint64_t); 1091 // May not be aligned so use memcpy. 1092 memcpy(Dst, Src + LoadBytes, sizeof(uint64_t)); 1093 Dst += sizeof(uint64_t); 1094 } 1095 1096 memcpy(Dst + sizeof(uint64_t) - LoadBytes, Src, LoadBytes); 1097 } 1098 } 1099 1100 /// FIXME: document 1101 /// 1102 void ExecutionEngine::LoadValueFromMemory(GenericValue &Result, 1103 GenericValue *Ptr, 1104 Type *Ty) { 1105 const unsigned LoadBytes = getDataLayout()->getTypeStoreSize(Ty); 1106 1107 switch (Ty->getTypeID()) { 1108 case Type::IntegerTyID: 1109 // An APInt with all words initially zero. 1110 Result.IntVal = APInt(cast<IntegerType>(Ty)->getBitWidth(), 0); 1111 LoadIntFromMemory(Result.IntVal, (uint8_t*)Ptr, LoadBytes); 1112 break; 1113 case Type::FloatTyID: 1114 Result.FloatVal = *((float*)Ptr); 1115 break; 1116 case Type::DoubleTyID: 1117 Result.DoubleVal = *((double*)Ptr); 1118 break; 1119 case Type::PointerTyID: 1120 Result.PointerVal = *((PointerTy*)Ptr); 1121 break; 1122 case Type::X86_FP80TyID: { 1123 // This is endian dependent, but it will only work on x86 anyway. 1124 // FIXME: Will not trap if loading a signaling NaN. 1125 uint64_t y[2]; 1126 memcpy(y, Ptr, 10); 1127 Result.IntVal = APInt(80, y); 1128 break; 1129 } 1130 case Type::VectorTyID: { 1131 const VectorType *VT = cast<VectorType>(Ty); 1132 const Type *ElemT = VT->getElementType(); 1133 const unsigned numElems = VT->getNumElements(); 1134 if (ElemT->isFloatTy()) { 1135 Result.AggregateVal.resize(numElems); 1136 for (unsigned i = 0; i < numElems; ++i) 1137 Result.AggregateVal[i].FloatVal = *((float*)Ptr+i); 1138 } 1139 if (ElemT->isDoubleTy()) { 1140 Result.AggregateVal.resize(numElems); 1141 for (unsigned i = 0; i < numElems; ++i) 1142 Result.AggregateVal[i].DoubleVal = *((double*)Ptr+i); 1143 } 1144 if (ElemT->isIntegerTy()) { 1145 GenericValue intZero; 1146 const unsigned elemBitWidth = cast<IntegerType>(ElemT)->getBitWidth(); 1147 intZero.IntVal = APInt(elemBitWidth, 0); 1148 Result.AggregateVal.resize(numElems, intZero); 1149 for (unsigned i = 0; i < numElems; ++i) 1150 LoadIntFromMemory(Result.AggregateVal[i].IntVal, 1151 (uint8_t*)Ptr+((elemBitWidth+7)/8)*i, (elemBitWidth+7)/8); 1152 } 1153 break; 1154 } 1155 default: 1156 SmallString<256> Msg; 1157 raw_svector_ostream OS(Msg); 1158 OS << "Cannot load value of type " << *Ty << "!"; 1159 report_fatal_error(OS.str()); 1160 } 1161 } 1162 1163 void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) { 1164 DEBUG(dbgs() << "JIT: Initializing " << Addr << " "); 1165 DEBUG(Init->dump()); 1166 if (isa<UndefValue>(Init)) 1167 return; 1168 1169 if (const ConstantVector *CP = dyn_cast<ConstantVector>(Init)) { 1170 unsigned ElementSize = 1171 getDataLayout()->getTypeAllocSize(CP->getType()->getElementType()); 1172 for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i) 1173 InitializeMemory(CP->getOperand(i), (char*)Addr+i*ElementSize); 1174 return; 1175 } 1176 1177 if (isa<ConstantAggregateZero>(Init)) { 1178 memset(Addr, 0, (size_t)getDataLayout()->getTypeAllocSize(Init->getType())); 1179 return; 1180 } 1181 1182 if (const ConstantArray *CPA = dyn_cast<ConstantArray>(Init)) { 1183 unsigned ElementSize = 1184 getDataLayout()->getTypeAllocSize(CPA->getType()->getElementType()); 1185 for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i) 1186 InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize); 1187 return; 1188 } 1189 1190 if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(Init)) { 1191 const StructLayout *SL = 1192 getDataLayout()->getStructLayout(cast<StructType>(CPS->getType())); 1193 for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i) 1194 InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->getElementOffset(i)); 1195 return; 1196 } 1197 1198 if (const ConstantDataSequential *CDS = 1199 dyn_cast<ConstantDataSequential>(Init)) { 1200 // CDS is already laid out in host memory order. 1201 StringRef Data = CDS->getRawDataValues(); 1202 memcpy(Addr, Data.data(), Data.size()); 1203 return; 1204 } 1205 1206 if (Init->getType()->isFirstClassType()) { 1207 GenericValue Val = getConstantValue(Init); 1208 StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType()); 1209 return; 1210 } 1211 1212 DEBUG(dbgs() << "Bad Type: " << *Init->getType() << "\n"); 1213 llvm_unreachable("Unknown constant type to initialize memory with!"); 1214 } 1215 1216 /// EmitGlobals - Emit all of the global variables to memory, storing their 1217 /// addresses into GlobalAddress. This must make sure to copy the contents of 1218 /// their initializers into the memory. 1219 void ExecutionEngine::emitGlobals() { 1220 // Loop over all of the global variables in the program, allocating the memory 1221 // to hold them. If there is more than one module, do a prepass over globals 1222 // to figure out how the different modules should link together. 1223 std::map<std::pair<std::string, Type*>, 1224 const GlobalValue*> LinkedGlobalsMap; 1225 1226 if (Modules.size() != 1) { 1227 for (unsigned m = 0, e = Modules.size(); m != e; ++m) { 1228 Module &M = *Modules[m]; 1229 for (const auto &GV : M.globals()) { 1230 if (GV.hasLocalLinkage() || GV.isDeclaration() || 1231 GV.hasAppendingLinkage() || !GV.hasName()) 1232 continue;// Ignore external globals and globals with internal linkage. 1233 1234 const GlobalValue *&GVEntry = 1235 LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())]; 1236 1237 // If this is the first time we've seen this global, it is the canonical 1238 // version. 1239 if (!GVEntry) { 1240 GVEntry = &GV; 1241 continue; 1242 } 1243 1244 // If the existing global is strong, never replace it. 1245 if (GVEntry->hasExternalLinkage()) 1246 continue; 1247 1248 // Otherwise, we know it's linkonce/weak, replace it if this is a strong 1249 // symbol. FIXME is this right for common? 1250 if (GV.hasExternalLinkage() || GVEntry->hasExternalWeakLinkage()) 1251 GVEntry = &GV; 1252 } 1253 } 1254 } 1255 1256 std::vector<const GlobalValue*> NonCanonicalGlobals; 1257 for (unsigned m = 0, e = Modules.size(); m != e; ++m) { 1258 Module &M = *Modules[m]; 1259 for (const auto &GV : M.globals()) { 1260 // In the multi-module case, see what this global maps to. 1261 if (!LinkedGlobalsMap.empty()) { 1262 if (const GlobalValue *GVEntry = 1263 LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())]) { 1264 // If something else is the canonical global, ignore this one. 1265 if (GVEntry != &GV) { 1266 NonCanonicalGlobals.push_back(&GV); 1267 continue; 1268 } 1269 } 1270 } 1271 1272 if (!GV.isDeclaration()) { 1273 addGlobalMapping(&GV, getMemoryForGV(&GV)); 1274 } else { 1275 // External variable reference. Try to use the dynamic loader to 1276 // get a pointer to it. 1277 if (void *SymAddr = 1278 sys::DynamicLibrary::SearchForAddressOfSymbol(GV.getName())) 1279 addGlobalMapping(&GV, SymAddr); 1280 else { 1281 report_fatal_error("Could not resolve external global address: " 1282 +GV.getName()); 1283 } 1284 } 1285 } 1286 1287 // If there are multiple modules, map the non-canonical globals to their 1288 // canonical location. 1289 if (!NonCanonicalGlobals.empty()) { 1290 for (unsigned i = 0, e = NonCanonicalGlobals.size(); i != e; ++i) { 1291 const GlobalValue *GV = NonCanonicalGlobals[i]; 1292 const GlobalValue *CGV = 1293 LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())]; 1294 void *Ptr = getPointerToGlobalIfAvailable(CGV); 1295 assert(Ptr && "Canonical global wasn't codegen'd!"); 1296 addGlobalMapping(GV, Ptr); 1297 } 1298 } 1299 1300 // Now that all of the globals are set up in memory, loop through them all 1301 // and initialize their contents. 1302 for (const auto &GV : M.globals()) { 1303 if (!GV.isDeclaration()) { 1304 if (!LinkedGlobalsMap.empty()) { 1305 if (const GlobalValue *GVEntry = 1306 LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())]) 1307 if (GVEntry != &GV) // Not the canonical variable. 1308 continue; 1309 } 1310 EmitGlobalVariable(&GV); 1311 } 1312 } 1313 } 1314 } 1315 1316 // EmitGlobalVariable - This method emits the specified global variable to the 1317 // address specified in GlobalAddresses, or allocates new memory if it's not 1318 // already in the map. 1319 void ExecutionEngine::EmitGlobalVariable(const GlobalVariable *GV) { 1320 void *GA = getPointerToGlobalIfAvailable(GV); 1321 1322 if (!GA) { 1323 // If it's not already specified, allocate memory for the global. 1324 GA = getMemoryForGV(GV); 1325 1326 // If we failed to allocate memory for this global, return. 1327 if (!GA) return; 1328 1329 addGlobalMapping(GV, GA); 1330 } 1331 1332 // Don't initialize if it's thread local, let the client do it. 1333 if (!GV->isThreadLocal()) 1334 InitializeMemory(GV->getInitializer(), GA); 1335 1336 Type *ElTy = GV->getType()->getElementType(); 1337 size_t GVSize = (size_t)getDataLayout()->getTypeAllocSize(ElTy); 1338 NumInitBytes += (unsigned)GVSize; 1339 ++NumGlobals; 1340 } 1341