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