ExecutionEngine.cpp revision 64f150fa92180c4176d64522158c4c643184b17c
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(0 && "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 SmallVector<Value*, 8> Indices(CE->op_begin()+1, CE->op_end()); 338 uint64_t Offset = 339 TD->getIndexedOffset(CE->getOperand(0)->getType(), 340 &Indices[0], Indices.size()); 341 342 if (getTargetData()->getPointerSize() == 4) 343 Result.Int32Val += Offset; 344 else 345 Result.Int64Val += Offset; 346 return Result; 347 } 348 case Instruction::Trunc: 349 case Instruction::ZExt: 350 case Instruction::SExt: 351 case Instruction::FPTrunc: 352 case Instruction::FPExt: 353 case Instruction::UIToFP: 354 case Instruction::SIToFP: 355 case Instruction::FPToUI: 356 case Instruction::FPToSI: 357 break; 358 case Instruction::PtrToInt: { 359 Constant *Op = CE->getOperand(0); 360 GenericValue GV = getConstantValue(Op); 361 return GV; 362 } 363 case Instruction::BitCast: { 364 // Bit casts are no-ops but we can only return the GV of the operand if 365 // they are the same basic type (pointer->pointer, packed->packed, etc.) 366 Constant *Op = CE->getOperand(0); 367 GenericValue GV = getConstantValue(Op); 368 if (Op->getType()->getTypeID() == C->getType()->getTypeID()) 369 return GV; 370 break; 371 } 372 case Instruction::IntToPtr: { 373 // IntToPtr casts are just so special. Cast to intptr_t first. 374 Constant *Op = CE->getOperand(0); 375 GenericValue GV = getConstantValue(Op); 376#define INT_TO_PTR_ACTION(FIELD) \ 377 return PTOGV((void*)(uintptr_t)GV.FIELD) 378 DO_FOR_INTEGER(Op->getType(), INT_TO_PTR_ACTION) 379#undef INT_TO_PTR_ACTION 380 break; 381 } 382 case Instruction::Add: 383 switch (CE->getOperand(0)->getType()->getTypeID()) { 384 default: assert(0 && "Bad add type!"); abort(); 385 case Type::IntegerTyID: 386#define ADD_ACTION(FIELD) \ 387 Result.FIELD = getConstantValue(CE->getOperand(0)).FIELD + \ 388 getConstantValue(CE->getOperand(1)).FIELD; 389 DO_FOR_INTEGER(CE->getOperand(0)->getType(),ADD_ACTION); 390#undef ADD_ACTION 391 break; 392 case Type::FloatTyID: 393 Result.FloatVal = getConstantValue(CE->getOperand(0)).FloatVal + 394 getConstantValue(CE->getOperand(1)).FloatVal; 395 break; 396 case Type::DoubleTyID: 397 Result.DoubleVal = getConstantValue(CE->getOperand(0)).DoubleVal + 398 getConstantValue(CE->getOperand(1)).DoubleVal; 399 break; 400 } 401 return Result; 402 default: 403 break; 404 } 405 cerr << "ConstantExpr not handled as global var init: " << *CE << "\n"; 406 abort(); 407 } 408 409 switch (C->getType()->getTypeID()) { 410#define GET_CONST_VAL(TY, CTY, CLASS, GETMETH) \ 411 case Type::TY##TyID: Result.TY##Val = (CTY)cast<CLASS>(C)->GETMETH(); break 412 GET_CONST_VAL(Float , float , ConstantFP, getValue); 413 GET_CONST_VAL(Double, double , ConstantFP, getValue); 414#undef GET_CONST_VAL 415 case Type::IntegerTyID: { 416 unsigned BitWidth = cast<IntegerType>(C->getType())->getBitWidth(); 417 if (BitWidth == 1) 418 Result.Int1Val = (bool)cast<ConstantInt>(C)->getZExtValue(); 419 else if (BitWidth <= 8) 420 Result.Int8Val = (uint8_t )cast<ConstantInt>(C)->getZExtValue(); 421 else if (BitWidth <= 16) 422 Result.Int16Val = (uint16_t )cast<ConstantInt>(C)->getZExtValue(); 423 else if (BitWidth <= 32) 424 Result.Int32Val = (uint32_t )cast<ConstantInt>(C)->getZExtValue(); 425 else if (BitWidth <= 64) 426 Result.Int64Val = (uint64_t )cast<ConstantInt>(C)->getZExtValue(); 427 else 428 assert(0 && "Integers with > 64-bits not implemented"); 429 break; 430 } 431 432 case Type::PointerTyID: 433 if (isa<ConstantPointerNull>(C)) 434 Result.PointerVal = 0; 435 else if (const Function *F = dyn_cast<Function>(C)) 436 Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F))); 437 else if (const GlobalVariable* GV = dyn_cast<GlobalVariable>(C)) 438 Result = PTOGV(getOrEmitGlobalVariable(const_cast<GlobalVariable*>(GV))); 439 else 440 assert(0 && "Unknown constant pointer type!"); 441 break; 442 default: 443 cerr << "ERROR: Constant unimp for type: " << *C->getType() << "\n"; 444 abort(); 445 } 446 return Result; 447} 448 449/// StoreValueToMemory - Stores the data in Val of type Ty at address Ptr. Ptr 450/// is the address of the memory at which to store Val, cast to GenericValue *. 451/// It is not a pointer to a GenericValue containing the address at which to 452/// store Val. 453/// 454void ExecutionEngine::StoreValueToMemory(GenericValue Val, GenericValue *Ptr, 455 const Type *Ty) { 456 if (getTargetData()->isLittleEndian()) { 457 switch (Ty->getTypeID()) { 458 case Type::IntegerTyID: { 459 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth(); 460 uint64_t BitMask = cast<IntegerType>(Ty)->getBitMask(); 461 GenericValue TmpVal = Val; 462 if (BitWidth <= 8) 463 Ptr->Untyped[0] = Val.Int8Val & BitMask; 464 else if (BitWidth <= 16) { 465 TmpVal.Int16Val &= BitMask; 466 Ptr->Untyped[0] = TmpVal.Int16Val & 255; 467 Ptr->Untyped[1] = (TmpVal.Int16Val >> 8) & 255; 468 } else if (BitWidth <= 32) { 469 TmpVal.Int32Val &= BitMask; 470 Ptr->Untyped[0] = TmpVal.Int32Val & 255; 471 Ptr->Untyped[1] = (TmpVal.Int32Val >> 8) & 255; 472 Ptr->Untyped[2] = (TmpVal.Int32Val >> 16) & 255; 473 Ptr->Untyped[3] = (TmpVal.Int32Val >> 24) & 255; 474 } else if (BitWidth <= 64) { 475 TmpVal.Int64Val &= BitMask; 476 Ptr->Untyped[0] = (unsigned char)(TmpVal.Int64Val ); 477 Ptr->Untyped[1] = (unsigned char)(TmpVal.Int64Val >> 8); 478 Ptr->Untyped[2] = (unsigned char)(TmpVal.Int64Val >> 16); 479 Ptr->Untyped[3] = (unsigned char)(TmpVal.Int64Val >> 24); 480 Ptr->Untyped[4] = (unsigned char)(TmpVal.Int64Val >> 32); 481 Ptr->Untyped[5] = (unsigned char)(TmpVal.Int64Val >> 40); 482 Ptr->Untyped[6] = (unsigned char)(TmpVal.Int64Val >> 48); 483 Ptr->Untyped[7] = (unsigned char)(TmpVal.Int64Val >> 56); 484 } else 485 assert(0 && "Integer types > 64 bits not supported"); 486 break; 487 } 488Store4BytesLittleEndian: 489 case Type::FloatTyID: 490 Ptr->Untyped[0] = Val.Int32Val & 255; 491 Ptr->Untyped[1] = (Val.Int32Val >> 8) & 255; 492 Ptr->Untyped[2] = (Val.Int32Val >> 16) & 255; 493 Ptr->Untyped[3] = (Val.Int32Val >> 24) & 255; 494 break; 495 case Type::PointerTyID: 496 if (getTargetData()->getPointerSize() == 4) 497 goto Store4BytesLittleEndian; 498 /* FALL THROUGH */ 499 case Type::DoubleTyID: 500 Ptr->Untyped[0] = (unsigned char)(Val.Int64Val ); 501 Ptr->Untyped[1] = (unsigned char)(Val.Int64Val >> 8); 502 Ptr->Untyped[2] = (unsigned char)(Val.Int64Val >> 16); 503 Ptr->Untyped[3] = (unsigned char)(Val.Int64Val >> 24); 504 Ptr->Untyped[4] = (unsigned char)(Val.Int64Val >> 32); 505 Ptr->Untyped[5] = (unsigned char)(Val.Int64Val >> 40); 506 Ptr->Untyped[6] = (unsigned char)(Val.Int64Val >> 48); 507 Ptr->Untyped[7] = (unsigned char)(Val.Int64Val >> 56); 508 break; 509 default: 510 cerr << "Cannot store value of type " << *Ty << "!\n"; 511 } 512 } else { 513 switch (Ty->getTypeID()) { 514 case Type::IntegerTyID: { 515 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth(); 516 uint64_t BitMask = cast<IntegerType>(Ty)->getBitMask(); 517 GenericValue TmpVal = Val; 518 if (BitWidth <= 8) 519 Ptr->Untyped[0] = Val.Int8Val & BitMask; 520 else if (BitWidth <= 16) { 521 TmpVal.Int16Val &= BitMask; 522 Ptr->Untyped[1] = TmpVal.Int16Val & 255; 523 Ptr->Untyped[0] = (TmpVal.Int16Val >> 8) & 255; 524 } else if (BitWidth <= 32) { 525 TmpVal.Int32Val &= BitMask; 526 Ptr->Untyped[3] = TmpVal.Int32Val & 255; 527 Ptr->Untyped[2] = (TmpVal.Int32Val >> 8) & 255; 528 Ptr->Untyped[1] = (TmpVal.Int32Val >> 16) & 255; 529 Ptr->Untyped[0] = (TmpVal.Int32Val >> 24) & 255; 530 } else if (BitWidth <= 64) { 531 TmpVal.Int64Val &= BitMask; 532 Ptr->Untyped[7] = (unsigned char)(TmpVal.Int64Val ); 533 Ptr->Untyped[6] = (unsigned char)(TmpVal.Int64Val >> 8); 534 Ptr->Untyped[5] = (unsigned char)(TmpVal.Int64Val >> 16); 535 Ptr->Untyped[4] = (unsigned char)(TmpVal.Int64Val >> 24); 536 Ptr->Untyped[3] = (unsigned char)(TmpVal.Int64Val >> 32); 537 Ptr->Untyped[2] = (unsigned char)(TmpVal.Int64Val >> 40); 538 Ptr->Untyped[1] = (unsigned char)(TmpVal.Int64Val >> 48); 539 Ptr->Untyped[0] = (unsigned char)(TmpVal.Int64Val >> 56); 540 } else 541 assert(0 && "Integer types > 64 bits not supported"); 542 break; 543 } 544 Store4BytesBigEndian: 545 case Type::FloatTyID: 546 Ptr->Untyped[3] = Val.Int32Val & 255; 547 Ptr->Untyped[2] = (Val.Int32Val >> 8) & 255; 548 Ptr->Untyped[1] = (Val.Int32Val >> 16) & 255; 549 Ptr->Untyped[0] = (Val.Int32Val >> 24) & 255; 550 break; 551 case Type::PointerTyID: 552 if (getTargetData()->getPointerSize() == 4) 553 goto Store4BytesBigEndian; 554 /* FALL THROUGH */ 555 case Type::DoubleTyID: 556 Ptr->Untyped[7] = (unsigned char)(Val.Int64Val ); 557 Ptr->Untyped[6] = (unsigned char)(Val.Int64Val >> 8); 558 Ptr->Untyped[5] = (unsigned char)(Val.Int64Val >> 16); 559 Ptr->Untyped[4] = (unsigned char)(Val.Int64Val >> 24); 560 Ptr->Untyped[3] = (unsigned char)(Val.Int64Val >> 32); 561 Ptr->Untyped[2] = (unsigned char)(Val.Int64Val >> 40); 562 Ptr->Untyped[1] = (unsigned char)(Val.Int64Val >> 48); 563 Ptr->Untyped[0] = (unsigned char)(Val.Int64Val >> 56); 564 break; 565 default: 566 cerr << "Cannot store value of type " << *Ty << "!\n"; 567 } 568 } 569} 570 571/// FIXME: document 572/// 573GenericValue ExecutionEngine::LoadValueFromMemory(GenericValue *Ptr, 574 const Type *Ty) { 575 GenericValue Result; 576 if (getTargetData()->isLittleEndian()) { 577 switch (Ty->getTypeID()) { 578 case Type::IntegerTyID: { 579 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth(); 580 if (BitWidth <= 8) 581 Result.Int8Val = Ptr->Untyped[0]; 582 else if (BitWidth <= 16) { 583 Result.Int16Val = (unsigned)Ptr->Untyped[0] | 584 ((unsigned)Ptr->Untyped[1] << 8); 585 } else if (BitWidth <= 32) { 586 Result.Int32Val = (unsigned)Ptr->Untyped[0] | 587 ((unsigned)Ptr->Untyped[1] << 8) | 588 ((unsigned)Ptr->Untyped[2] << 16) | 589 ((unsigned)Ptr->Untyped[3] << 24); 590 } else if (BitWidth <= 64) { 591 Result.Int64Val = (uint64_t)Ptr->Untyped[0] | 592 ((uint64_t)Ptr->Untyped[1] << 8) | 593 ((uint64_t)Ptr->Untyped[2] << 16) | 594 ((uint64_t)Ptr->Untyped[3] << 24) | 595 ((uint64_t)Ptr->Untyped[4] << 32) | 596 ((uint64_t)Ptr->Untyped[5] << 40) | 597 ((uint64_t)Ptr->Untyped[6] << 48) | 598 ((uint64_t)Ptr->Untyped[7] << 56); 599 } else 600 assert(0 && "Integer types > 64 bits not supported"); 601 break; 602 } 603 Load4BytesLittleEndian: 604 case Type::FloatTyID: 605 Result.Int32Val = (unsigned)Ptr->Untyped[0] | 606 ((unsigned)Ptr->Untyped[1] << 8) | 607 ((unsigned)Ptr->Untyped[2] << 16) | 608 ((unsigned)Ptr->Untyped[3] << 24); 609 break; 610 case Type::PointerTyID: 611 if (getTargetData()->getPointerSize() == 4) 612 goto Load4BytesLittleEndian; 613 /* FALL THROUGH */ 614 case Type::DoubleTyID: 615 Result.Int64Val = (uint64_t)Ptr->Untyped[0] | 616 ((uint64_t)Ptr->Untyped[1] << 8) | 617 ((uint64_t)Ptr->Untyped[2] << 16) | 618 ((uint64_t)Ptr->Untyped[3] << 24) | 619 ((uint64_t)Ptr->Untyped[4] << 32) | 620 ((uint64_t)Ptr->Untyped[5] << 40) | 621 ((uint64_t)Ptr->Untyped[6] << 48) | 622 ((uint64_t)Ptr->Untyped[7] << 56); 623 break; 624 default: 625 cerr << "Cannot load value of type " << *Ty << "!\n"; 626 abort(); 627 } 628 } else { 629 switch (Ty->getTypeID()) { 630 case Type::IntegerTyID: { 631 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth(); 632 if (BitWidth <= 8) 633 Result.Int8Val = Ptr->Untyped[0]; 634 else if (BitWidth <= 16) { 635 Result.Int16Val = (unsigned)Ptr->Untyped[1] | 636 ((unsigned)Ptr->Untyped[0] << 8); 637 } else if (BitWidth <= 32) { 638 Result.Int32Val = (unsigned)Ptr->Untyped[3] | 639 ((unsigned)Ptr->Untyped[2] << 8) | 640 ((unsigned)Ptr->Untyped[1] << 16) | 641 ((unsigned)Ptr->Untyped[0] << 24); 642 } else if (BitWidth <= 64) { 643 Result.Int64Val = (uint64_t)Ptr->Untyped[7] | 644 ((uint64_t)Ptr->Untyped[6] << 8) | 645 ((uint64_t)Ptr->Untyped[5] << 16) | 646 ((uint64_t)Ptr->Untyped[4] << 24) | 647 ((uint64_t)Ptr->Untyped[3] << 32) | 648 ((uint64_t)Ptr->Untyped[2] << 40) | 649 ((uint64_t)Ptr->Untyped[1] << 48) | 650 ((uint64_t)Ptr->Untyped[0] << 56); 651 } else 652 assert(0 && "Integer types > 64 bits not supported"); 653 break; 654 } 655 Load4BytesBigEndian: 656 case Type::FloatTyID: 657 Result.Int32Val = (unsigned)Ptr->Untyped[3] | 658 ((unsigned)Ptr->Untyped[2] << 8) | 659 ((unsigned)Ptr->Untyped[1] << 16) | 660 ((unsigned)Ptr->Untyped[0] << 24); 661 break; 662 case Type::PointerTyID: 663 if (getTargetData()->getPointerSize() == 4) 664 goto Load4BytesBigEndian; 665 /* FALL THROUGH */ 666 case Type::DoubleTyID: 667 Result.Int64Val = (uint64_t)Ptr->Untyped[7] | 668 ((uint64_t)Ptr->Untyped[6] << 8) | 669 ((uint64_t)Ptr->Untyped[5] << 16) | 670 ((uint64_t)Ptr->Untyped[4] << 24) | 671 ((uint64_t)Ptr->Untyped[3] << 32) | 672 ((uint64_t)Ptr->Untyped[2] << 40) | 673 ((uint64_t)Ptr->Untyped[1] << 48) | 674 ((uint64_t)Ptr->Untyped[0] << 56); 675 break; 676 default: 677 cerr << "Cannot load value of type " << *Ty << "!\n"; 678 abort(); 679 } 680 } 681 return Result; 682} 683 684// InitializeMemory - Recursive function to apply a Constant value into the 685// specified memory location... 686// 687void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) { 688 if (isa<UndefValue>(Init)) { 689 return; 690 } else if (const ConstantPacked *CP = dyn_cast<ConstantPacked>(Init)) { 691 unsigned ElementSize = 692 getTargetData()->getTypeSize(CP->getType()->getElementType()); 693 for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i) 694 InitializeMemory(CP->getOperand(i), (char*)Addr+i*ElementSize); 695 return; 696 } else if (Init->getType()->isFirstClassType()) { 697 GenericValue Val = getConstantValue(Init); 698 StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType()); 699 return; 700 } else if (isa<ConstantAggregateZero>(Init)) { 701 memset(Addr, 0, (size_t)getTargetData()->getTypeSize(Init->getType())); 702 return; 703 } 704 705 switch (Init->getType()->getTypeID()) { 706 case Type::ArrayTyID: { 707 const ConstantArray *CPA = cast<ConstantArray>(Init); 708 unsigned ElementSize = 709 getTargetData()->getTypeSize(CPA->getType()->getElementType()); 710 for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i) 711 InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize); 712 return; 713 } 714 715 case Type::StructTyID: { 716 const ConstantStruct *CPS = cast<ConstantStruct>(Init); 717 const StructLayout *SL = 718 getTargetData()->getStructLayout(cast<StructType>(CPS->getType())); 719 for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i) 720 InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->getElementOffset(i)); 721 return; 722 } 723 724 default: 725 cerr << "Bad Type: " << *Init->getType() << "\n"; 726 assert(0 && "Unknown constant type to initialize memory with!"); 727 } 728} 729 730/// EmitGlobals - Emit all of the global variables to memory, storing their 731/// addresses into GlobalAddress. This must make sure to copy the contents of 732/// their initializers into the memory. 733/// 734void ExecutionEngine::emitGlobals() { 735 const TargetData *TD = getTargetData(); 736 737 // Loop over all of the global variables in the program, allocating the memory 738 // to hold them. If there is more than one module, do a prepass over globals 739 // to figure out how the different modules should link together. 740 // 741 std::map<std::pair<std::string, const Type*>, 742 const GlobalValue*> LinkedGlobalsMap; 743 744 if (Modules.size() != 1) { 745 for (unsigned m = 0, e = Modules.size(); m != e; ++m) { 746 Module &M = *Modules[m]->getModule(); 747 for (Module::const_global_iterator I = M.global_begin(), 748 E = M.global_end(); I != E; ++I) { 749 const GlobalValue *GV = I; 750 if (GV->hasInternalLinkage() || GV->isDeclaration() || 751 GV->hasAppendingLinkage() || !GV->hasName()) 752 continue;// Ignore external globals and globals with internal linkage. 753 754 const GlobalValue *&GVEntry = 755 LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())]; 756 757 // If this is the first time we've seen this global, it is the canonical 758 // version. 759 if (!GVEntry) { 760 GVEntry = GV; 761 continue; 762 } 763 764 // If the existing global is strong, never replace it. 765 if (GVEntry->hasExternalLinkage() || 766 GVEntry->hasDLLImportLinkage() || 767 GVEntry->hasDLLExportLinkage()) 768 continue; 769 770 // Otherwise, we know it's linkonce/weak, replace it if this is a strong 771 // symbol. 772 if (GV->hasExternalLinkage() || GVEntry->hasExternalWeakLinkage()) 773 GVEntry = GV; 774 } 775 } 776 } 777 778 std::vector<const GlobalValue*> NonCanonicalGlobals; 779 for (unsigned m = 0, e = Modules.size(); m != e; ++m) { 780 Module &M = *Modules[m]->getModule(); 781 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 782 I != E; ++I) { 783 // In the multi-module case, see what this global maps to. 784 if (!LinkedGlobalsMap.empty()) { 785 if (const GlobalValue *GVEntry = 786 LinkedGlobalsMap[std::make_pair(I->getName(), I->getType())]) { 787 // If something else is the canonical global, ignore this one. 788 if (GVEntry != &*I) { 789 NonCanonicalGlobals.push_back(I); 790 continue; 791 } 792 } 793 } 794 795 if (!I->isDeclaration()) { 796 // Get the type of the global. 797 const Type *Ty = I->getType()->getElementType(); 798 799 // Allocate some memory for it! 800 unsigned Size = TD->getTypeSize(Ty); 801 addGlobalMapping(I, new char[Size]); 802 } else { 803 // External variable reference. Try to use the dynamic loader to 804 // get a pointer to it. 805 if (void *SymAddr = 806 sys::DynamicLibrary::SearchForAddressOfSymbol(I->getName().c_str())) 807 addGlobalMapping(I, SymAddr); 808 else { 809 cerr << "Could not resolve external global address: " 810 << I->getName() << "\n"; 811 abort(); 812 } 813 } 814 } 815 816 // If there are multiple modules, map the non-canonical globals to their 817 // canonical location. 818 if (!NonCanonicalGlobals.empty()) { 819 for (unsigned i = 0, e = NonCanonicalGlobals.size(); i != e; ++i) { 820 const GlobalValue *GV = NonCanonicalGlobals[i]; 821 const GlobalValue *CGV = 822 LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())]; 823 void *Ptr = getPointerToGlobalIfAvailable(CGV); 824 assert(Ptr && "Canonical global wasn't codegen'd!"); 825 addGlobalMapping(GV, getPointerToGlobalIfAvailable(CGV)); 826 } 827 } 828 829 // Now that all of the globals are set up in memory, loop through them all 830 // and initialize their contents. 831 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 832 I != E; ++I) { 833 if (!I->isDeclaration()) { 834 if (!LinkedGlobalsMap.empty()) { 835 if (const GlobalValue *GVEntry = 836 LinkedGlobalsMap[std::make_pair(I->getName(), I->getType())]) 837 if (GVEntry != &*I) // Not the canonical variable. 838 continue; 839 } 840 EmitGlobalVariable(I); 841 } 842 } 843 } 844} 845 846// EmitGlobalVariable - This method emits the specified global variable to the 847// address specified in GlobalAddresses, or allocates new memory if it's not 848// already in the map. 849void ExecutionEngine::EmitGlobalVariable(const GlobalVariable *GV) { 850 void *GA = getPointerToGlobalIfAvailable(GV); 851 DOUT << "Global '" << GV->getName() << "' -> " << GA << "\n"; 852 853 const Type *ElTy = GV->getType()->getElementType(); 854 size_t GVSize = (size_t)getTargetData()->getTypeSize(ElTy); 855 if (GA == 0) { 856 // If it's not already specified, allocate memory for the global. 857 GA = new char[GVSize]; 858 addGlobalMapping(GV, GA); 859 } 860 861 InitializeMemory(GV->getInitializer(), GA); 862 NumInitBytes += (unsigned)GVSize; 863 ++NumGlobals; 864} 865