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