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