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