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