ExecutionEngine.cpp revision b1919e2f08ecb37140af676fd2916f8d5ed7df3d
1//===-- ExecutionEngine.cpp - Common Implementation shared by EEs ---------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source 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/ExecutionEngine/ExecutionEngine.h" 22#include "llvm/ExecutionEngine/GenericValue.h" 23#include "llvm/Support/Debug.h" 24#include "llvm/Support/MutexGuard.h" 25#include "llvm/System/DynamicLibrary.h" 26#include "llvm/Target/TargetData.h" 27using namespace llvm; 28 29STATISTIC(NumInitBytes, "Number of bytes of global vars initialized"); 30STATISTIC(NumGlobals , "Number of global vars initialized"); 31 32ExecutionEngine::EECtorFn ExecutionEngine::JITCtor = 0; 33ExecutionEngine::EECtorFn ExecutionEngine::InterpCtor = 0; 34 35ExecutionEngine::ExecutionEngine(ModuleProvider *P) { 36 LazyCompilationDisabled = false; 37 Modules.push_back(P); 38 assert(P && "ModuleProvider is null?"); 39} 40 41ExecutionEngine::ExecutionEngine(Module *M) { 42 LazyCompilationDisabled = false; 43 assert(M && "Module is null?"); 44 Modules.push_back(new ExistingModuleProvider(M)); 45} 46 47ExecutionEngine::~ExecutionEngine() { 48 for (unsigned i = 0, e = Modules.size(); i != e; ++i) 49 delete Modules[i]; 50} 51 52/// FindFunctionNamed - Search all of the active modules to find the one that 53/// defines FnName. This is very slow operation and shouldn't be used for 54/// general code. 55Function *ExecutionEngine::FindFunctionNamed(const char *FnName) { 56 for (unsigned i = 0, e = Modules.size(); i != e; ++i) { 57 if (Function *F = Modules[i]->getModule()->getFunction(FnName)) 58 return F; 59 } 60 return 0; 61} 62 63 64/// addGlobalMapping - Tell the execution engine that the specified global is 65/// at the specified location. This is used internally as functions are JIT'd 66/// and as global variables are laid out in memory. It can and should also be 67/// used by clients of the EE that want to have an LLVM global overlay 68/// existing data in memory. 69void ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) { 70 MutexGuard locked(lock); 71 72 void *&CurVal = state.getGlobalAddressMap(locked)[GV]; 73 assert((CurVal == 0 || Addr == 0) && "GlobalMapping already established!"); 74 CurVal = Addr; 75 76 // If we are using the reverse mapping, add it too 77 if (!state.getGlobalAddressReverseMap(locked).empty()) { 78 const GlobalValue *&V = state.getGlobalAddressReverseMap(locked)[Addr]; 79 assert((V == 0 || GV == 0) && "GlobalMapping already established!"); 80 V = GV; 81 } 82} 83 84/// clearAllGlobalMappings - Clear all global mappings and start over again 85/// use in dynamic compilation scenarios when you want to move globals 86void ExecutionEngine::clearAllGlobalMappings() { 87 MutexGuard locked(lock); 88 89 state.getGlobalAddressMap(locked).clear(); 90 state.getGlobalAddressReverseMap(locked).clear(); 91} 92 93/// updateGlobalMapping - Replace an existing mapping for GV with a new 94/// address. This updates both maps as required. If "Addr" is null, the 95/// entry for the global is removed from the mappings. 96void ExecutionEngine::updateGlobalMapping(const GlobalValue *GV, void *Addr) { 97 MutexGuard locked(lock); 98 99 // Deleting from the mapping? 100 if (Addr == 0) { 101 state.getGlobalAddressMap(locked).erase(GV); 102 if (!state.getGlobalAddressReverseMap(locked).empty()) 103 state.getGlobalAddressReverseMap(locked).erase(Addr); 104 return; 105 } 106 107 void *&CurVal = state.getGlobalAddressMap(locked)[GV]; 108 if (CurVal && !state.getGlobalAddressReverseMap(locked).empty()) 109 state.getGlobalAddressReverseMap(locked).erase(CurVal); 110 CurVal = Addr; 111 112 // If we are using the reverse mapping, add it too 113 if (!state.getGlobalAddressReverseMap(locked).empty()) { 114 const GlobalValue *&V = state.getGlobalAddressReverseMap(locked)[Addr]; 115 assert((V == 0 || GV == 0) && "GlobalMapping already established!"); 116 V = GV; 117 } 118} 119 120/// getPointerToGlobalIfAvailable - This returns the address of the specified 121/// global value if it is has already been codegen'd, otherwise it returns null. 122/// 123void *ExecutionEngine::getPointerToGlobalIfAvailable(const GlobalValue *GV) { 124 MutexGuard locked(lock); 125 126 std::map<const GlobalValue*, void*>::iterator I = 127 state.getGlobalAddressMap(locked).find(GV); 128 return I != state.getGlobalAddressMap(locked).end() ? I->second : 0; 129} 130 131/// getGlobalValueAtAddress - Return the LLVM global value object that starts 132/// at the specified address. 133/// 134const GlobalValue *ExecutionEngine::getGlobalValueAtAddress(void *Addr) { 135 MutexGuard locked(lock); 136 137 // If we haven't computed the reverse mapping yet, do so first. 138 if (state.getGlobalAddressReverseMap(locked).empty()) { 139 for (std::map<const GlobalValue*, void *>::iterator 140 I = state.getGlobalAddressMap(locked).begin(), 141 E = state.getGlobalAddressMap(locked).end(); I != E; ++I) 142 state.getGlobalAddressReverseMap(locked).insert(std::make_pair(I->second, 143 I->first)); 144 } 145 146 std::map<void *, const GlobalValue*>::iterator I = 147 state.getGlobalAddressReverseMap(locked).find(Addr); 148 return I != state.getGlobalAddressReverseMap(locked).end() ? I->second : 0; 149} 150 151// CreateArgv - Turn a vector of strings into a nice argv style array of 152// pointers to null terminated strings. 153// 154static void *CreateArgv(ExecutionEngine *EE, 155 const std::vector<std::string> &InputArgv) { 156 unsigned PtrSize = EE->getTargetData()->getPointerSize(); 157 char *Result = new char[(InputArgv.size()+1)*PtrSize]; 158 159 DOUT << "ARGV = " << (void*)Result << "\n"; 160 const Type *SBytePtr = PointerType::get(Type::Int8Ty); 161 162 for (unsigned i = 0; i != InputArgv.size(); ++i) { 163 unsigned Size = InputArgv[i].size()+1; 164 char *Dest = new char[Size]; 165 DOUT << "ARGV[" << i << "] = " << (void*)Dest << "\n"; 166 167 std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest); 168 Dest[Size-1] = 0; 169 170 // Endian safe: Result[i] = (PointerTy)Dest; 171 EE->StoreValueToMemory(PTOGV(Dest), (GenericValue*)(Result+i*PtrSize), 172 SBytePtr); 173 } 174 175 // Null terminate it 176 EE->StoreValueToMemory(PTOGV(0), 177 (GenericValue*)(Result+InputArgv.size()*PtrSize), 178 SBytePtr); 179 return Result; 180} 181 182 183/// runStaticConstructorsDestructors - This method is used to execute all of 184/// the static constructors or destructors for a program, depending on the 185/// value of isDtors. 186void ExecutionEngine::runStaticConstructorsDestructors(bool isDtors) { 187 const char *Name = isDtors ? "llvm.global_dtors" : "llvm.global_ctors"; 188 189 // Execute global ctors/dtors for each module in the program. 190 for (unsigned m = 0, e = Modules.size(); m != e; ++m) { 191 GlobalVariable *GV = Modules[m]->getModule()->getNamedGlobal(Name); 192 193 // If this global has internal linkage, or if it has a use, then it must be 194 // an old-style (llvmgcc3) static ctor with __main linked in and in use. If 195 // this is the case, don't execute any of the global ctors, __main will do 196 // it. 197 if (!GV || GV->isDeclaration() || GV->hasInternalLinkage()) continue; 198 199 // Should be an array of '{ int, void ()* }' structs. The first value is 200 // the init priority, which we ignore. 201 ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer()); 202 if (!InitList) continue; 203 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) 204 if (ConstantStruct *CS = 205 dyn_cast<ConstantStruct>(InitList->getOperand(i))) { 206 if (CS->getNumOperands() != 2) break; // Not array of 2-element structs. 207 208 Constant *FP = CS->getOperand(1); 209 if (FP->isNullValue()) 210 break; // Found a null terminator, exit. 211 212 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP)) 213 if (CE->isCast()) 214 FP = CE->getOperand(0); 215 if (Function *F = dyn_cast<Function>(FP)) { 216 // Execute the ctor/dtor function! 217 runFunction(F, std::vector<GenericValue>()); 218 } 219 } 220 } 221} 222 223/// runFunctionAsMain - This is a helper function which wraps runFunction to 224/// handle the common task of starting up main with the specified argc, argv, 225/// and envp parameters. 226int ExecutionEngine::runFunctionAsMain(Function *Fn, 227 const std::vector<std::string> &argv, 228 const char * const * envp) { 229 std::vector<GenericValue> GVArgs; 230 GenericValue GVArgc; 231 GVArgc.Int32Val = argv.size(); 232 unsigned NumArgs = Fn->getFunctionType()->getNumParams(); 233 if (NumArgs) { 234 GVArgs.push_back(GVArgc); // Arg #0 = argc. 235 if (NumArgs > 1) { 236 GVArgs.push_back(PTOGV(CreateArgv(this, argv))); // Arg #1 = argv. 237 assert(((char **)GVTOP(GVArgs[1]))[0] && 238 "argv[0] was null after CreateArgv"); 239 if (NumArgs > 2) { 240 std::vector<std::string> EnvVars; 241 for (unsigned i = 0; envp[i]; ++i) 242 EnvVars.push_back(envp[i]); 243 GVArgs.push_back(PTOGV(CreateArgv(this, EnvVars))); // Arg #2 = envp. 244 } 245 } 246 } 247 return runFunction(Fn, GVArgs).Int32Val; 248} 249 250/// If possible, create a JIT, unless the caller specifically requests an 251/// Interpreter or there's an error. If even an Interpreter cannot be created, 252/// NULL is returned. 253/// 254ExecutionEngine *ExecutionEngine::create(ModuleProvider *MP, 255 bool ForceInterpreter) { 256 ExecutionEngine *EE = 0; 257 258 // Unless the interpreter was explicitly selected, try making a JIT. 259 if (!ForceInterpreter && JITCtor) 260 EE = JITCtor(MP); 261 262 // If we can't make a JIT, make an interpreter instead. 263 if (EE == 0 && InterpCtor) 264 EE = InterpCtor(MP); 265 266 if (EE) { 267 // Make sure we can resolve symbols in the program as well. The zero arg 268 // to the function tells DynamicLibrary to load the program, not a library. 269 try { 270 sys::DynamicLibrary::LoadLibraryPermanently(0); 271 } catch (...) { 272 } 273 } 274 275 return EE; 276} 277 278/// getPointerToGlobal - This returns the address of the specified global 279/// value. This may involve code generation if it's a function. 280/// 281void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) { 282 if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV))) 283 return getPointerToFunction(F); 284 285 MutexGuard locked(lock); 286 void *p = state.getGlobalAddressMap(locked)[GV]; 287 if (p) 288 return p; 289 290 // Global variable might have been added since interpreter started. 291 if (GlobalVariable *GVar = 292 const_cast<GlobalVariable *>(dyn_cast<GlobalVariable>(GV))) 293 EmitGlobalVariable(GVar); 294 else 295 assert("Global hasn't had an address allocated yet!"); 296 return state.getGlobalAddressMap(locked)[GV]; 297} 298 299/// This macro is used to handle a variety of situations involing integer 300/// values where the action should be done to one of the GenericValue members. 301/// THEINTTY is a const Type * for the integer type. ACTION1 comes before 302/// the GenericValue, ACTION2 comes after. 303#define DO_FOR_INTEGER(THEINTTY, ACTION) \ 304 { \ 305 unsigned BitWidth = cast<IntegerType>(THEINTTY)->getBitWidth(); \ 306 if (BitWidth == 1) {\ 307 ACTION(Int1Val); \ 308 } else if (BitWidth <= 8) {\ 309 ACTION(Int8Val); \ 310 } else if (BitWidth <= 16) {\ 311 ACTION(Int16Val); \ 312 } else if (BitWidth <= 32) { \ 313 ACTION(Int32Val); \ 314 } else if (BitWidth <= 64) { \ 315 ACTION(Int64Val); \ 316 } else {\ 317 assert(0 && "Not implemented: integer types > 64 bits"); \ 318 } \ 319 } 320 321/// This function converts a Constant* into a GenericValue. The interesting 322/// part is if C is a ConstantExpr. 323/// @brief Get a GenericValue for a Constnat* 324GenericValue ExecutionEngine::getConstantValue(const Constant *C) { 325 // Declare the result as garbage. 326 GenericValue Result; 327 328 // If its undefined, return the garbage. 329 if (isa<UndefValue>(C)) return Result; 330 331 // If the value is a ConstantExpr 332 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 333 switch (CE->getOpcode()) { 334 case Instruction::GetElementPtr: { 335 // Compute the index 336 Result = getConstantValue(CE->getOperand(0)); 337 std::vector<Value*> Indexes(CE->op_begin()+1, CE->op_end()); 338 uint64_t Offset = 339 TD->getIndexedOffset(CE->getOperand(0)->getType(), Indexes); 340 341 if (getTargetData()->getPointerSize() == 4) 342 Result.Int32Val += Offset; 343 else 344 Result.Int64Val += Offset; 345 return Result; 346 } 347 case Instruction::Trunc: 348 case Instruction::ZExt: 349 case Instruction::SExt: 350 case Instruction::FPTrunc: 351 case Instruction::FPExt: 352 case Instruction::UIToFP: 353 case Instruction::SIToFP: 354 case Instruction::FPToUI: 355 case Instruction::FPToSI: 356 break; 357 case Instruction::PtrToInt: { 358 Constant *Op = CE->getOperand(0); 359 GenericValue GV = getConstantValue(Op); 360 return GV; 361 } 362 case Instruction::BitCast: { 363 // Bit casts are no-ops but we can only return the GV of the operand if 364 // they are the same basic type (pointer->pointer, packed->packed, etc.) 365 Constant *Op = CE->getOperand(0); 366 GenericValue GV = getConstantValue(Op); 367 if (Op->getType()->getTypeID() == C->getType()->getTypeID()) 368 return GV; 369 break; 370 } 371 case Instruction::IntToPtr: { 372 // IntToPtr casts are just so special. Cast to intptr_t first. 373 Constant *Op = CE->getOperand(0); 374 GenericValue GV = getConstantValue(Op); 375#define INT_TO_PTR_ACTION(FIELD) \ 376 return PTOGV((void*)(uintptr_t)GV.FIELD) 377 DO_FOR_INTEGER(Op->getType(), INT_TO_PTR_ACTION) 378#undef INT_TO_PTR_ACTION 379 break; 380 } 381 case Instruction::Add: 382 switch (CE->getOperand(0)->getType()->getTypeID()) { 383 default: assert(0 && "Bad add type!"); abort(); 384 case Type::IntegerTyID: 385#define ADD_ACTION(FIELD) \ 386 Result.FIELD = getConstantValue(CE->getOperand(0)).FIELD + \ 387 getConstantValue(CE->getOperand(1)).FIELD; 388 DO_FOR_INTEGER(CE->getOperand(0)->getType(),ADD_ACTION); 389#undef ADD_ACTION 390 break; 391 case Type::FloatTyID: 392 Result.FloatVal = getConstantValue(CE->getOperand(0)).FloatVal + 393 getConstantValue(CE->getOperand(1)).FloatVal; 394 break; 395 case Type::DoubleTyID: 396 Result.DoubleVal = getConstantValue(CE->getOperand(0)).DoubleVal + 397 getConstantValue(CE->getOperand(1)).DoubleVal; 398 break; 399 } 400 return Result; 401 default: 402 break; 403 } 404 cerr << "ConstantExpr not handled as global var init: " << *CE << "\n"; 405 abort(); 406 } 407 408 switch (C->getType()->getTypeID()) { 409#define GET_CONST_VAL(TY, CTY, CLASS, GETMETH) \ 410 case Type::TY##TyID: Result.TY##Val = (CTY)cast<CLASS>(C)->GETMETH(); break 411 GET_CONST_VAL(Float , float , ConstantFP, getValue); 412 GET_CONST_VAL(Double, double , ConstantFP, getValue); 413#undef GET_CONST_VAL 414 case Type::IntegerTyID: { 415 unsigned BitWidth = cast<IntegerType>(C->getType())->getBitWidth(); 416 if (BitWidth == 1) 417 Result.Int1Val = (bool)cast<ConstantInt>(C)->getZExtValue(); 418 else if (BitWidth <= 8) 419 Result.Int8Val = (uint8_t )cast<ConstantInt>(C)->getZExtValue(); 420 else if (BitWidth <= 16) 421 Result.Int16Val = (uint16_t )cast<ConstantInt>(C)->getZExtValue(); 422 else if (BitWidth <= 32) 423 Result.Int32Val = (uint32_t )cast<ConstantInt>(C)->getZExtValue(); 424 else if (BitWidth <= 64) 425 Result.Int64Val = (uint64_t )cast<ConstantInt>(C)->getZExtValue(); 426 else 427 assert("Integers with > 64-bits not implemented"); 428 break; 429 } 430 431 case Type::PointerTyID: 432 if (isa<ConstantPointerNull>(C)) 433 Result.PointerVal = 0; 434 else if (const Function *F = dyn_cast<Function>(C)) 435 Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F))); 436 else if (const GlobalVariable* GV = dyn_cast<GlobalVariable>(C)) 437 Result = PTOGV(getOrEmitGlobalVariable(const_cast<GlobalVariable*>(GV))); 438 else 439 assert(0 && "Unknown constant pointer type!"); 440 break; 441 default: 442 cerr << "ERROR: Constant unimp for type: " << *C->getType() << "\n"; 443 abort(); 444 } 445 return Result; 446} 447 448/// StoreValueToMemory - Stores the data in Val of type Ty at address Ptr. Ptr 449/// is the address of the memory at which to store Val, cast to GenericValue *. 450/// It is not a pointer to a GenericValue containing the address at which to 451/// store Val. 452/// 453void ExecutionEngine::StoreValueToMemory(GenericValue Val, GenericValue *Ptr, 454 const Type *Ty) { 455 if (getTargetData()->isLittleEndian()) { 456 switch (Ty->getTypeID()) { 457 case Type::IntegerTyID: { 458 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth(); 459 uint64_t BitMask = cast<IntegerType>(Ty)->getBitMask(); 460 GenericValue TmpVal = Val; 461 if (BitWidth <= 8) 462 Ptr->Untyped[0] = Val.Int8Val & BitMask; 463 else if (BitWidth <= 16) { 464 TmpVal.Int16Val &= BitMask; 465 Ptr->Untyped[0] = TmpVal.Int16Val & 255; 466 Ptr->Untyped[1] = (TmpVal.Int16Val >> 8) & 255; 467 } else if (BitWidth <= 32) { 468 TmpVal.Int32Val &= BitMask; 469 Ptr->Untyped[0] = TmpVal.Int32Val & 255; 470 Ptr->Untyped[1] = (TmpVal.Int32Val >> 8) & 255; 471 Ptr->Untyped[2] = (TmpVal.Int32Val >> 16) & 255; 472 Ptr->Untyped[3] = (TmpVal.Int32Val >> 24) & 255; 473 } else if (BitWidth <= 64) { 474 TmpVal.Int64Val &= BitMask; 475 Ptr->Untyped[0] = (unsigned char)(TmpVal.Int64Val ); 476 Ptr->Untyped[1] = (unsigned char)(TmpVal.Int64Val >> 8); 477 Ptr->Untyped[2] = (unsigned char)(TmpVal.Int64Val >> 16); 478 Ptr->Untyped[3] = (unsigned char)(TmpVal.Int64Val >> 24); 479 Ptr->Untyped[4] = (unsigned char)(TmpVal.Int64Val >> 32); 480 Ptr->Untyped[5] = (unsigned char)(TmpVal.Int64Val >> 40); 481 Ptr->Untyped[6] = (unsigned char)(TmpVal.Int64Val >> 48); 482 Ptr->Untyped[7] = (unsigned char)(TmpVal.Int64Val >> 56); 483 } else 484 assert(0 && "Integer types > 64 bits not supported"); 485 break; 486 } 487Store4BytesLittleEndian: 488 case Type::FloatTyID: 489 Ptr->Untyped[0] = Val.Int32Val & 255; 490 Ptr->Untyped[1] = (Val.Int32Val >> 8) & 255; 491 Ptr->Untyped[2] = (Val.Int32Val >> 16) & 255; 492 Ptr->Untyped[3] = (Val.Int32Val >> 24) & 255; 493 break; 494 case Type::PointerTyID: 495 if (getTargetData()->getPointerSize() == 4) 496 goto Store4BytesLittleEndian; 497 /* FALL THROUGH */ 498 case Type::DoubleTyID: 499 Ptr->Untyped[0] = (unsigned char)(Val.Int64Val ); 500 Ptr->Untyped[1] = (unsigned char)(Val.Int64Val >> 8); 501 Ptr->Untyped[2] = (unsigned char)(Val.Int64Val >> 16); 502 Ptr->Untyped[3] = (unsigned char)(Val.Int64Val >> 24); 503 Ptr->Untyped[4] = (unsigned char)(Val.Int64Val >> 32); 504 Ptr->Untyped[5] = (unsigned char)(Val.Int64Val >> 40); 505 Ptr->Untyped[6] = (unsigned char)(Val.Int64Val >> 48); 506 Ptr->Untyped[7] = (unsigned char)(Val.Int64Val >> 56); 507 break; 508 default: 509 cerr << "Cannot store value of type " << *Ty << "!\n"; 510 } 511 } else { 512 switch (Ty->getTypeID()) { 513 case Type::IntegerTyID: { 514 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth(); 515 uint64_t BitMask = cast<IntegerType>(Ty)->getBitMask(); 516 GenericValue TmpVal = Val; 517 if (BitWidth <= 8) 518 Ptr->Untyped[0] = Val.Int8Val & BitMask; 519 else if (BitWidth <= 16) { 520 TmpVal.Int16Val &= BitMask; 521 Ptr->Untyped[1] = TmpVal.Int16Val & 255; 522 Ptr->Untyped[0] = (TmpVal.Int16Val >> 8) & 255; 523 } else if (BitWidth <= 32) { 524 TmpVal.Int32Val &= BitMask; 525 Ptr->Untyped[3] = TmpVal.Int32Val & 255; 526 Ptr->Untyped[2] = (TmpVal.Int32Val >> 8) & 255; 527 Ptr->Untyped[1] = (TmpVal.Int32Val >> 16) & 255; 528 Ptr->Untyped[0] = (TmpVal.Int32Val >> 24) & 255; 529 } else if (BitWidth <= 64) { 530 TmpVal.Int64Val &= BitMask; 531 Ptr->Untyped[7] = (unsigned char)(TmpVal.Int64Val ); 532 Ptr->Untyped[6] = (unsigned char)(TmpVal.Int64Val >> 8); 533 Ptr->Untyped[5] = (unsigned char)(TmpVal.Int64Val >> 16); 534 Ptr->Untyped[4] = (unsigned char)(TmpVal.Int64Val >> 24); 535 Ptr->Untyped[3] = (unsigned char)(TmpVal.Int64Val >> 32); 536 Ptr->Untyped[2] = (unsigned char)(TmpVal.Int64Val >> 40); 537 Ptr->Untyped[1] = (unsigned char)(TmpVal.Int64Val >> 48); 538 Ptr->Untyped[0] = (unsigned char)(TmpVal.Int64Val >> 56); 539 } else 540 assert(0 && "Integer types > 64 bits not supported"); 541 break; 542 } 543 Store4BytesBigEndian: 544 case Type::FloatTyID: 545 Ptr->Untyped[3] = Val.Int32Val & 255; 546 Ptr->Untyped[2] = (Val.Int32Val >> 8) & 255; 547 Ptr->Untyped[1] = (Val.Int32Val >> 16) & 255; 548 Ptr->Untyped[0] = (Val.Int32Val >> 24) & 255; 549 break; 550 case Type::PointerTyID: 551 if (getTargetData()->getPointerSize() == 4) 552 goto Store4BytesBigEndian; 553 /* FALL THROUGH */ 554 case Type::DoubleTyID: 555 Ptr->Untyped[7] = (unsigned char)(Val.Int64Val ); 556 Ptr->Untyped[6] = (unsigned char)(Val.Int64Val >> 8); 557 Ptr->Untyped[5] = (unsigned char)(Val.Int64Val >> 16); 558 Ptr->Untyped[4] = (unsigned char)(Val.Int64Val >> 24); 559 Ptr->Untyped[3] = (unsigned char)(Val.Int64Val >> 32); 560 Ptr->Untyped[2] = (unsigned char)(Val.Int64Val >> 40); 561 Ptr->Untyped[1] = (unsigned char)(Val.Int64Val >> 48); 562 Ptr->Untyped[0] = (unsigned char)(Val.Int64Val >> 56); 563 break; 564 default: 565 cerr << "Cannot store value of type " << *Ty << "!\n"; 566 } 567 } 568} 569 570/// FIXME: document 571/// 572GenericValue ExecutionEngine::LoadValueFromMemory(GenericValue *Ptr, 573 const Type *Ty) { 574 GenericValue Result; 575 if (getTargetData()->isLittleEndian()) { 576 switch (Ty->getTypeID()) { 577 case Type::IntegerTyID: { 578 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth(); 579 if (BitWidth <= 8) 580 Result.Int8Val = Ptr->Untyped[0]; 581 else if (BitWidth <= 16) { 582 Result.Int16Val = (unsigned)Ptr->Untyped[0] | 583 ((unsigned)Ptr->Untyped[1] << 8); 584 } else if (BitWidth <= 32) { 585 Result.Int32Val = (unsigned)Ptr->Untyped[0] | 586 ((unsigned)Ptr->Untyped[1] << 8) | 587 ((unsigned)Ptr->Untyped[2] << 16) | 588 ((unsigned)Ptr->Untyped[3] << 24); 589 } else if (BitWidth <= 64) { 590 Result.Int64Val = (uint64_t)Ptr->Untyped[0] | 591 ((uint64_t)Ptr->Untyped[1] << 8) | 592 ((uint64_t)Ptr->Untyped[2] << 16) | 593 ((uint64_t)Ptr->Untyped[3] << 24) | 594 ((uint64_t)Ptr->Untyped[4] << 32) | 595 ((uint64_t)Ptr->Untyped[5] << 40) | 596 ((uint64_t)Ptr->Untyped[6] << 48) | 597 ((uint64_t)Ptr->Untyped[7] << 56); 598 } else 599 assert(0 && "Integer types > 64 bits not supported"); 600 break; 601 } 602 Load4BytesLittleEndian: 603 case Type::FloatTyID: 604 Result.Int32Val = (unsigned)Ptr->Untyped[0] | 605 ((unsigned)Ptr->Untyped[1] << 8) | 606 ((unsigned)Ptr->Untyped[2] << 16) | 607 ((unsigned)Ptr->Untyped[3] << 24); 608 break; 609 case Type::PointerTyID: 610 if (getTargetData()->getPointerSize() == 4) 611 goto Load4BytesLittleEndian; 612 /* FALL THROUGH */ 613 case Type::DoubleTyID: 614 Result.Int64Val = (uint64_t)Ptr->Untyped[0] | 615 ((uint64_t)Ptr->Untyped[1] << 8) | 616 ((uint64_t)Ptr->Untyped[2] << 16) | 617 ((uint64_t)Ptr->Untyped[3] << 24) | 618 ((uint64_t)Ptr->Untyped[4] << 32) | 619 ((uint64_t)Ptr->Untyped[5] << 40) | 620 ((uint64_t)Ptr->Untyped[6] << 48) | 621 ((uint64_t)Ptr->Untyped[7] << 56); 622 break; 623 default: 624 cerr << "Cannot load value of type " << *Ty << "!\n"; 625 abort(); 626 } 627 } else { 628 switch (Ty->getTypeID()) { 629 case Type::IntegerTyID: { 630 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth(); 631 if (BitWidth <= 8) 632 Result.Int8Val = Ptr->Untyped[0]; 633 else if (BitWidth <= 16) { 634 Result.Int16Val = (unsigned)Ptr->Untyped[1] | 635 ((unsigned)Ptr->Untyped[0] << 8); 636 } else if (BitWidth <= 32) { 637 Result.Int32Val = (unsigned)Ptr->Untyped[3] | 638 ((unsigned)Ptr->Untyped[2] << 8) | 639 ((unsigned)Ptr->Untyped[1] << 16) | 640 ((unsigned)Ptr->Untyped[0] << 24); 641 } else if (BitWidth <= 64) { 642 Result.Int64Val = (uint64_t)Ptr->Untyped[7] | 643 ((uint64_t)Ptr->Untyped[6] << 8) | 644 ((uint64_t)Ptr->Untyped[5] << 16) | 645 ((uint64_t)Ptr->Untyped[4] << 24) | 646 ((uint64_t)Ptr->Untyped[3] << 32) | 647 ((uint64_t)Ptr->Untyped[2] << 40) | 648 ((uint64_t)Ptr->Untyped[1] << 48) | 649 ((uint64_t)Ptr->Untyped[0] << 56); 650 } else 651 assert(0 && "Integer types > 64 bits not supported"); 652 break; 653 } 654 Load4BytesBigEndian: 655 case Type::FloatTyID: 656 Result.Int32Val = (unsigned)Ptr->Untyped[3] | 657 ((unsigned)Ptr->Untyped[2] << 8) | 658 ((unsigned)Ptr->Untyped[1] << 16) | 659 ((unsigned)Ptr->Untyped[0] << 24); 660 break; 661 case Type::PointerTyID: 662 if (getTargetData()->getPointerSize() == 4) 663 goto Load4BytesBigEndian; 664 /* FALL THROUGH */ 665 case Type::DoubleTyID: 666 Result.Int64Val = (uint64_t)Ptr->Untyped[7] | 667 ((uint64_t)Ptr->Untyped[6] << 8) | 668 ((uint64_t)Ptr->Untyped[5] << 16) | 669 ((uint64_t)Ptr->Untyped[4] << 24) | 670 ((uint64_t)Ptr->Untyped[3] << 32) | 671 ((uint64_t)Ptr->Untyped[2] << 40) | 672 ((uint64_t)Ptr->Untyped[1] << 48) | 673 ((uint64_t)Ptr->Untyped[0] << 56); 674 break; 675 default: 676 cerr << "Cannot load value of type " << *Ty << "!\n"; 677 abort(); 678 } 679 } 680 return Result; 681} 682 683// InitializeMemory - Recursive function to apply a Constant value into the 684// specified memory location... 685// 686void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) { 687 if (isa<UndefValue>(Init)) { 688 return; 689 } else if (const ConstantPacked *CP = dyn_cast<ConstantPacked>(Init)) { 690 unsigned ElementSize = 691 getTargetData()->getTypeSize(CP->getType()->getElementType()); 692 for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i) 693 InitializeMemory(CP->getOperand(i), (char*)Addr+i*ElementSize); 694 return; 695 } else if (Init->getType()->isFirstClassType()) { 696 GenericValue Val = getConstantValue(Init); 697 StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType()); 698 return; 699 } else if (isa<ConstantAggregateZero>(Init)) { 700 memset(Addr, 0, (size_t)getTargetData()->getTypeSize(Init->getType())); 701 return; 702 } 703 704 switch (Init->getType()->getTypeID()) { 705 case Type::ArrayTyID: { 706 const ConstantArray *CPA = cast<ConstantArray>(Init); 707 unsigned ElementSize = 708 getTargetData()->getTypeSize(CPA->getType()->getElementType()); 709 for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i) 710 InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize); 711 return; 712 } 713 714 case Type::StructTyID: { 715 const ConstantStruct *CPS = cast<ConstantStruct>(Init); 716 const StructLayout *SL = 717 getTargetData()->getStructLayout(cast<StructType>(CPS->getType())); 718 for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i) 719 InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->getElementOffset(i)); 720 return; 721 } 722 723 default: 724 cerr << "Bad Type: " << *Init->getType() << "\n"; 725 assert(0 && "Unknown constant type to initialize memory with!"); 726 } 727} 728 729/// EmitGlobals - Emit all of the global variables to memory, storing their 730/// addresses into GlobalAddress. This must make sure to copy the contents of 731/// their initializers into the memory. 732/// 733void ExecutionEngine::emitGlobals() { 734 const TargetData *TD = getTargetData(); 735 736 // Loop over all of the global variables in the program, allocating the memory 737 // to hold them. If there is more than one module, do a prepass over globals 738 // to figure out how the different modules should link together. 739 // 740 std::map<std::pair<std::string, const Type*>, 741 const GlobalValue*> LinkedGlobalsMap; 742 743 if (Modules.size() != 1) { 744 for (unsigned m = 0, e = Modules.size(); m != e; ++m) { 745 Module &M = *Modules[m]->getModule(); 746 for (Module::const_global_iterator I = M.global_begin(), 747 E = M.global_end(); I != E; ++I) { 748 const GlobalValue *GV = I; 749 if (GV->hasInternalLinkage() || GV->isDeclaration() || 750 GV->hasAppendingLinkage() || !GV->hasName()) 751 continue;// Ignore external globals and globals with internal linkage. 752 753 const GlobalValue *&GVEntry = 754 LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())]; 755 756 // If this is the first time we've seen this global, it is the canonical 757 // version. 758 if (!GVEntry) { 759 GVEntry = GV; 760 continue; 761 } 762 763 // If the existing global is strong, never replace it. 764 if (GVEntry->hasExternalLinkage() || 765 GVEntry->hasDLLImportLinkage() || 766 GVEntry->hasDLLExportLinkage()) 767 continue; 768 769 // Otherwise, we know it's linkonce/weak, replace it if this is a strong 770 // symbol. 771 if (GV->hasExternalLinkage() || GVEntry->hasExternalWeakLinkage()) 772 GVEntry = GV; 773 } 774 } 775 } 776 777 std::vector<const GlobalValue*> NonCanonicalGlobals; 778 for (unsigned m = 0, e = Modules.size(); m != e; ++m) { 779 Module &M = *Modules[m]->getModule(); 780 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 781 I != E; ++I) { 782 // In the multi-module case, see what this global maps to. 783 if (!LinkedGlobalsMap.empty()) { 784 if (const GlobalValue *GVEntry = 785 LinkedGlobalsMap[std::make_pair(I->getName(), I->getType())]) { 786 // If something else is the canonical global, ignore this one. 787 if (GVEntry != &*I) { 788 NonCanonicalGlobals.push_back(I); 789 continue; 790 } 791 } 792 } 793 794 if (!I->isDeclaration()) { 795 // Get the type of the global. 796 const Type *Ty = I->getType()->getElementType(); 797 798 // Allocate some memory for it! 799 unsigned Size = TD->getTypeSize(Ty); 800 addGlobalMapping(I, new char[Size]); 801 } else { 802 // External variable reference. Try to use the dynamic loader to 803 // get a pointer to it. 804 if (void *SymAddr = 805 sys::DynamicLibrary::SearchForAddressOfSymbol(I->getName().c_str())) 806 addGlobalMapping(I, SymAddr); 807 else { 808 cerr << "Could not resolve external global address: " 809 << I->getName() << "\n"; 810 abort(); 811 } 812 } 813 } 814 815 // If there are multiple modules, map the non-canonical globals to their 816 // canonical location. 817 if (!NonCanonicalGlobals.empty()) { 818 for (unsigned i = 0, e = NonCanonicalGlobals.size(); i != e; ++i) { 819 const GlobalValue *GV = NonCanonicalGlobals[i]; 820 const GlobalValue *CGV = 821 LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())]; 822 void *Ptr = getPointerToGlobalIfAvailable(CGV); 823 assert(Ptr && "Canonical global wasn't codegen'd!"); 824 addGlobalMapping(GV, getPointerToGlobalIfAvailable(CGV)); 825 } 826 } 827 828 // Now that all of the globals are set up in memory, loop through them all 829 // and initialize their contents. 830 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 831 I != E; ++I) { 832 if (!I->isDeclaration()) { 833 if (!LinkedGlobalsMap.empty()) { 834 if (const GlobalValue *GVEntry = 835 LinkedGlobalsMap[std::make_pair(I->getName(), I->getType())]) 836 if (GVEntry != &*I) // Not the canonical variable. 837 continue; 838 } 839 EmitGlobalVariable(I); 840 } 841 } 842 } 843} 844 845// EmitGlobalVariable - This method emits the specified global variable to the 846// address specified in GlobalAddresses, or allocates new memory if it's not 847// already in the map. 848void ExecutionEngine::EmitGlobalVariable(const GlobalVariable *GV) { 849 void *GA = getPointerToGlobalIfAvailable(GV); 850 DOUT << "Global '" << GV->getName() << "' -> " << GA << "\n"; 851 852 const Type *ElTy = GV->getType()->getElementType(); 853 size_t GVSize = (size_t)getTargetData()->getTypeSize(ElTy); 854 if (GA == 0) { 855 // If it's not already specified, allocate memory for the global. 856 GA = new char[GVSize]; 857 addGlobalMapping(GV, GA); 858 } 859 860 InitializeMemory(GV->getInitializer(), GA); 861 NumInitBytes += (unsigned)GVSize; 862 ++NumGlobals; 863} 864