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/CodeGen/IntrinsicLowering.h" 22 #include "llvm/ExecutionEngine/ExecutionEngine.h" 23 #include "llvm/ExecutionEngine/GenericValue.h" 24 #include "llvm/Support/Debug.h" 25 #include "llvm/System/DynamicLibrary.h" 26 #include "llvm/Target/TargetData.h" 27 #include <iostream> 28 using namespace llvm; 29 30 namespace { 31 Statistic<> NumInitBytes("lli", "Number of bytes of global vars initialized"); 32 Statistic<> NumGlobals ("lli", "Number of global vars initialized"); 33 } 34 35 ExecutionEngine::EECtorFn ExecutionEngine::JITCtor = 0; 36 ExecutionEngine::EECtorFn ExecutionEngine::InterpCtor = 0; 37 38 ExecutionEngine::ExecutionEngine(ModuleProvider *P) : 39 CurMod(*P->getModule()), MP(P) { 40 assert(P && "ModuleProvider is null?"); 41 } 42 43 ExecutionEngine::ExecutionEngine(Module *M) : CurMod(*M), MP(0) { 44 assert(M && "Module is null?"); 45 } 46 47 ExecutionEngine::~ExecutionEngine() { 48 delete MP; 49 } 50 51 /// getGlobalValueAtAddress - Return the LLVM global value object that starts 52 /// at the specified address. 53 /// 54 const GlobalValue *ExecutionEngine::getGlobalValueAtAddress(void *Addr) { 55 MutexGuard locked(lock); 56 57 // If we haven't computed the reverse mapping yet, do so first. 58 if (state.getGlobalAddressReverseMap(locked).empty()) { 59 for (std::map<const GlobalValue*, void *>::iterator I = 60 state.getGlobalAddressMap(locked).begin(), E = state.getGlobalAddressMap(locked).end(); I != E; ++I) 61 state.getGlobalAddressReverseMap(locked).insert(std::make_pair(I->second, I->first)); 62 } 63 64 std::map<void *, const GlobalValue*>::iterator I = 65 state.getGlobalAddressReverseMap(locked).find(Addr); 66 return I != state.getGlobalAddressReverseMap(locked).end() ? I->second : 0; 67 } 68 69 // CreateArgv - Turn a vector of strings into a nice argv style array of 70 // pointers to null terminated strings. 71 // 72 static void *CreateArgv(ExecutionEngine *EE, 73 const std::vector<std::string> &InputArgv) { 74 unsigned PtrSize = EE->getTargetData().getPointerSize(); 75 char *Result = new char[(InputArgv.size()+1)*PtrSize]; 76 77 DEBUG(std::cerr << "ARGV = " << (void*)Result << "\n"); 78 const Type *SBytePtr = PointerType::get(Type::SByteTy); 79 80 for (unsigned i = 0; i != InputArgv.size(); ++i) { 81 unsigned Size = InputArgv[i].size()+1; 82 char *Dest = new char[Size]; 83 DEBUG(std::cerr << "ARGV[" << i << "] = " << (void*)Dest << "\n"); 84 85 std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest); 86 Dest[Size-1] = 0; 87 88 // Endian safe: Result[i] = (PointerTy)Dest; 89 EE->StoreValueToMemory(PTOGV(Dest), (GenericValue*)(Result+i*PtrSize), 90 SBytePtr); 91 } 92 93 // Null terminate it 94 EE->StoreValueToMemory(PTOGV(0), 95 (GenericValue*)(Result+InputArgv.size()*PtrSize), 96 SBytePtr); 97 return Result; 98 } 99 100 101 /// runStaticConstructorsDestructors - This method is used to execute all of 102 /// the static constructors or destructors for a module, depending on the 103 /// value of isDtors. 104 void ExecutionEngine::runStaticConstructorsDestructors(bool isDtors) { 105 const char *Name = isDtors ? "llvm.global_dtors" : "llvm.global_ctors"; 106 GlobalVariable *GV = CurMod.getNamedGlobal(Name); 107 if (!GV || GV->isExternal() || !GV->hasInternalLinkage()) return; 108 109 // Should be an array of '{ int, void ()* }' structs. The first value is the 110 // init priority, which we ignore. 111 ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer()); 112 if (!InitList) return; 113 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) 114 if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){ 115 if (CS->getNumOperands() != 2) return; // Not array of 2-element structs. 116 117 Constant *FP = CS->getOperand(1); 118 if (FP->isNullValue()) 119 return; // Found a null terminator, exit. 120 121 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP)) 122 if (CE->getOpcode() == Instruction::Cast) 123 FP = CE->getOperand(0); 124 if (Function *F = dyn_cast<Function>(FP)) { 125 // Execute the ctor/dtor function! 126 runFunction(F, std::vector<GenericValue>()); 127 } 128 } 129 } 130 131 /// runFunctionAsMain - This is a helper function which wraps runFunction to 132 /// handle the common task of starting up main with the specified argc, argv, 133 /// and envp parameters. 134 int ExecutionEngine::runFunctionAsMain(Function *Fn, 135 const std::vector<std::string> &argv, 136 const char * const * envp) { 137 std::vector<GenericValue> GVArgs; 138 GenericValue GVArgc; 139 GVArgc.IntVal = argv.size(); 140 unsigned NumArgs = Fn->getFunctionType()->getNumParams(); 141 if (NumArgs) { 142 GVArgs.push_back(GVArgc); // Arg #0 = argc. 143 if (NumArgs > 1) { 144 GVArgs.push_back(PTOGV(CreateArgv(this, argv))); // Arg #1 = argv. 145 assert(((char **)GVTOP(GVArgs[1]))[0] && 146 "argv[0] was null after CreateArgv"); 147 if (NumArgs > 2) { 148 std::vector<std::string> EnvVars; 149 for (unsigned i = 0; envp[i]; ++i) 150 EnvVars.push_back(envp[i]); 151 GVArgs.push_back(PTOGV(CreateArgv(this, EnvVars))); // Arg #2 = envp. 152 } 153 } 154 } 155 return runFunction(Fn, GVArgs).IntVal; 156 } 157 158 /// If possible, create a JIT, unless the caller specifically requests an 159 /// Interpreter or there's an error. If even an Interpreter cannot be created, 160 /// NULL is returned. 161 /// 162 ExecutionEngine *ExecutionEngine::create(ModuleProvider *MP, 163 bool ForceInterpreter) { 164 ExecutionEngine *EE = 0; 165 166 // Unless the interpreter was explicitly selected, try making a JIT. 167 if (!ForceInterpreter && JITCtor) 168 EE = JITCtor(MP); 169 170 // If we can't make a JIT, make an interpreter instead. 171 if (EE == 0 && InterpCtor) 172 EE = InterpCtor(MP); 173 174 if (EE) { 175 // Make sure we can resolve symbols in the program as well. The zero arg 176 // to the function tells DynamicLibrary to load the program, not a library. 177 sys::DynamicLibrary::LoadLibraryPermanently(0); 178 } 179 180 return EE; 181 } 182 183 /// getPointerToGlobal - This returns the address of the specified global 184 /// value. This may involve code generation if it's a function. 185 /// 186 void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) { 187 if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV))) 188 return getPointerToFunction(F); 189 190 MutexGuard locked(lock); 191 void *p = state.getGlobalAddressMap(locked)[GV]; 192 if (p) 193 return p; 194 195 // Global variable might have been added since interpreter started. 196 if (GlobalVariable *GVar = 197 const_cast<GlobalVariable *>(dyn_cast<GlobalVariable>(GV))) 198 EmitGlobalVariable(GVar); 199 else 200 assert("Global hasn't had an address allocated yet!"); 201 return state.getGlobalAddressMap(locked)[GV]; 202 } 203 204 /// FIXME: document 205 /// 206 GenericValue ExecutionEngine::getConstantValue(const Constant *C) { 207 GenericValue Result; 208 if (isa<UndefValue>(C)) return Result; 209 210 if (ConstantExpr *CE = const_cast<ConstantExpr*>(dyn_cast<ConstantExpr>(C))) { 211 switch (CE->getOpcode()) { 212 case Instruction::GetElementPtr: { 213 Result = getConstantValue(CE->getOperand(0)); 214 std::vector<Value*> Indexes(CE->op_begin()+1, CE->op_end()); 215 uint64_t Offset = 216 TD->getIndexedOffset(CE->getOperand(0)->getType(), Indexes); 217 218 if (getTargetData().getPointerSize() == 4) 219 Result.IntVal += Offset; 220 else 221 Result.LongVal += Offset; 222 return Result; 223 } 224 case Instruction::Cast: { 225 // We only need to handle a few cases here. Almost all casts will 226 // automatically fold, just the ones involving pointers won't. 227 // 228 Constant *Op = CE->getOperand(0); 229 GenericValue GV = getConstantValue(Op); 230 231 // Handle cast of pointer to pointer... 232 if (Op->getType()->getTypeID() == C->getType()->getTypeID()) 233 return GV; 234 235 // Handle a cast of pointer to any integral type... 236 if (isa<PointerType>(Op->getType()) && C->getType()->isIntegral()) 237 return GV; 238 239 // Handle cast of integer to a pointer... 240 if (isa<PointerType>(C->getType()) && Op->getType()->isIntegral()) 241 switch (Op->getType()->getTypeID()) { 242 case Type::BoolTyID: return PTOGV((void*)(uintptr_t)GV.BoolVal); 243 case Type::SByteTyID: return PTOGV((void*)( intptr_t)GV.SByteVal); 244 case Type::UByteTyID: return PTOGV((void*)(uintptr_t)GV.UByteVal); 245 case Type::ShortTyID: return PTOGV((void*)( intptr_t)GV.ShortVal); 246 case Type::UShortTyID: return PTOGV((void*)(uintptr_t)GV.UShortVal); 247 case Type::IntTyID: return PTOGV((void*)( intptr_t)GV.IntVal); 248 case Type::UIntTyID: return PTOGV((void*)(uintptr_t)GV.UIntVal); 249 case Type::LongTyID: return PTOGV((void*)( intptr_t)GV.LongVal); 250 case Type::ULongTyID: return PTOGV((void*)(uintptr_t)GV.ULongVal); 251 default: assert(0 && "Unknown integral type!"); 252 } 253 break; 254 } 255 256 case Instruction::Add: 257 switch (CE->getOperand(0)->getType()->getTypeID()) { 258 default: assert(0 && "Bad add type!"); abort(); 259 case Type::LongTyID: 260 case Type::ULongTyID: 261 Result.LongVal = getConstantValue(CE->getOperand(0)).LongVal + 262 getConstantValue(CE->getOperand(1)).LongVal; 263 break; 264 case Type::IntTyID: 265 case Type::UIntTyID: 266 Result.IntVal = getConstantValue(CE->getOperand(0)).IntVal + 267 getConstantValue(CE->getOperand(1)).IntVal; 268 break; 269 case Type::ShortTyID: 270 case Type::UShortTyID: 271 Result.ShortVal = getConstantValue(CE->getOperand(0)).ShortVal + 272 getConstantValue(CE->getOperand(1)).ShortVal; 273 break; 274 case Type::SByteTyID: 275 case Type::UByteTyID: 276 Result.SByteVal = getConstantValue(CE->getOperand(0)).SByteVal + 277 getConstantValue(CE->getOperand(1)).SByteVal; 278 break; 279 case Type::FloatTyID: 280 Result.FloatVal = getConstantValue(CE->getOperand(0)).FloatVal + 281 getConstantValue(CE->getOperand(1)).FloatVal; 282 break; 283 case Type::DoubleTyID: 284 Result.DoubleVal = getConstantValue(CE->getOperand(0)).DoubleVal + 285 getConstantValue(CE->getOperand(1)).DoubleVal; 286 break; 287 } 288 return Result; 289 default: 290 break; 291 } 292 std::cerr << "ConstantExpr not handled as global var init: " << *CE << "\n"; 293 abort(); 294 } 295 296 switch (C->getType()->getTypeID()) { 297 #define GET_CONST_VAL(TY, CTY, CLASS) \ 298 case Type::TY##TyID: Result.TY##Val = (CTY)cast<CLASS>(C)->getValue(); break 299 GET_CONST_VAL(Bool , bool , ConstantBool); 300 GET_CONST_VAL(UByte , unsigned char , ConstantUInt); 301 GET_CONST_VAL(SByte , signed char , ConstantSInt); 302 GET_CONST_VAL(UShort , unsigned short, ConstantUInt); 303 GET_CONST_VAL(Short , signed short , ConstantSInt); 304 GET_CONST_VAL(UInt , unsigned int , ConstantUInt); 305 GET_CONST_VAL(Int , signed int , ConstantSInt); 306 GET_CONST_VAL(ULong , uint64_t , ConstantUInt); 307 GET_CONST_VAL(Long , int64_t , ConstantSInt); 308 GET_CONST_VAL(Float , float , ConstantFP); 309 GET_CONST_VAL(Double , double , ConstantFP); 310 #undef GET_CONST_VAL 311 case Type::PointerTyID: 312 if (isa<ConstantPointerNull>(C)) 313 Result.PointerVal = 0; 314 else if (const Function *F = dyn_cast<Function>(C)) 315 Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F))); 316 else if (const GlobalVariable* GV = dyn_cast<GlobalVariable>(C)) 317 Result = PTOGV(getOrEmitGlobalVariable(const_cast<GlobalVariable*>(GV))); 318 else 319 assert(0 && "Unknown constant pointer type!"); 320 break; 321 default: 322 std::cout << "ERROR: Constant unimp for type: " << *C->getType() << "\n"; 323 abort(); 324 } 325 return Result; 326 } 327 328 /// FIXME: document 329 /// 330 void ExecutionEngine::StoreValueToMemory(GenericValue Val, GenericValue *Ptr, 331 const Type *Ty) { 332 if (getTargetData().isLittleEndian()) { 333 switch (Ty->getTypeID()) { 334 case Type::BoolTyID: 335 case Type::UByteTyID: 336 case Type::SByteTyID: Ptr->Untyped[0] = Val.UByteVal; break; 337 case Type::UShortTyID: 338 case Type::ShortTyID: Ptr->Untyped[0] = Val.UShortVal & 255; 339 Ptr->Untyped[1] = (Val.UShortVal >> 8) & 255; 340 break; 341 Store4BytesLittleEndian: 342 case Type::FloatTyID: 343 case Type::UIntTyID: 344 case Type::IntTyID: Ptr->Untyped[0] = Val.UIntVal & 255; 345 Ptr->Untyped[1] = (Val.UIntVal >> 8) & 255; 346 Ptr->Untyped[2] = (Val.UIntVal >> 16) & 255; 347 Ptr->Untyped[3] = (Val.UIntVal >> 24) & 255; 348 break; 349 case Type::PointerTyID: if (getTargetData().getPointerSize() == 4) 350 goto Store4BytesLittleEndian; 351 case Type::DoubleTyID: 352 case Type::ULongTyID: 353 case Type::LongTyID: 354 Ptr->Untyped[0] = (unsigned char)(Val.ULongVal ); 355 Ptr->Untyped[1] = (unsigned char)(Val.ULongVal >> 8); 356 Ptr->Untyped[2] = (unsigned char)(Val.ULongVal >> 16); 357 Ptr->Untyped[3] = (unsigned char)(Val.ULongVal >> 24); 358 Ptr->Untyped[4] = (unsigned char)(Val.ULongVal >> 32); 359 Ptr->Untyped[5] = (unsigned char)(Val.ULongVal >> 40); 360 Ptr->Untyped[6] = (unsigned char)(Val.ULongVal >> 48); 361 Ptr->Untyped[7] = (unsigned char)(Val.ULongVal >> 56); 362 break; 363 default: 364 std::cout << "Cannot store value of type " << *Ty << "!\n"; 365 } 366 } else { 367 switch (Ty->getTypeID()) { 368 case Type::BoolTyID: 369 case Type::UByteTyID: 370 case Type::SByteTyID: Ptr->Untyped[0] = Val.UByteVal; break; 371 case Type::UShortTyID: 372 case Type::ShortTyID: Ptr->Untyped[1] = Val.UShortVal & 255; 373 Ptr->Untyped[0] = (Val.UShortVal >> 8) & 255; 374 break; 375 Store4BytesBigEndian: 376 case Type::FloatTyID: 377 case Type::UIntTyID: 378 case Type::IntTyID: Ptr->Untyped[3] = Val.UIntVal & 255; 379 Ptr->Untyped[2] = (Val.UIntVal >> 8) & 255; 380 Ptr->Untyped[1] = (Val.UIntVal >> 16) & 255; 381 Ptr->Untyped[0] = (Val.UIntVal >> 24) & 255; 382 break; 383 case Type::PointerTyID: if (getTargetData().getPointerSize() == 4) 384 goto Store4BytesBigEndian; 385 case Type::DoubleTyID: 386 case Type::ULongTyID: 387 case Type::LongTyID: 388 Ptr->Untyped[7] = (unsigned char)(Val.ULongVal ); 389 Ptr->Untyped[6] = (unsigned char)(Val.ULongVal >> 8); 390 Ptr->Untyped[5] = (unsigned char)(Val.ULongVal >> 16); 391 Ptr->Untyped[4] = (unsigned char)(Val.ULongVal >> 24); 392 Ptr->Untyped[3] = (unsigned char)(Val.ULongVal >> 32); 393 Ptr->Untyped[2] = (unsigned char)(Val.ULongVal >> 40); 394 Ptr->Untyped[1] = (unsigned char)(Val.ULongVal >> 48); 395 Ptr->Untyped[0] = (unsigned char)(Val.ULongVal >> 56); 396 break; 397 default: 398 std::cout << "Cannot store value of type " << *Ty << "!\n"; 399 } 400 } 401 } 402 403 /// FIXME: document 404 /// 405 GenericValue ExecutionEngine::LoadValueFromMemory(GenericValue *Ptr, 406 const Type *Ty) { 407 GenericValue Result; 408 if (getTargetData().isLittleEndian()) { 409 switch (Ty->getTypeID()) { 410 case Type::BoolTyID: 411 case Type::UByteTyID: 412 case Type::SByteTyID: Result.UByteVal = Ptr->Untyped[0]; break; 413 case Type::UShortTyID: 414 case Type::ShortTyID: Result.UShortVal = (unsigned)Ptr->Untyped[0] | 415 ((unsigned)Ptr->Untyped[1] << 8); 416 break; 417 Load4BytesLittleEndian: 418 case Type::FloatTyID: 419 case Type::UIntTyID: 420 case Type::IntTyID: Result.UIntVal = (unsigned)Ptr->Untyped[0] | 421 ((unsigned)Ptr->Untyped[1] << 8) | 422 ((unsigned)Ptr->Untyped[2] << 16) | 423 ((unsigned)Ptr->Untyped[3] << 24); 424 break; 425 case Type::PointerTyID: if (getTargetData().getPointerSize() == 4) 426 goto Load4BytesLittleEndian; 427 case Type::DoubleTyID: 428 case Type::ULongTyID: 429 case Type::LongTyID: Result.ULongVal = (uint64_t)Ptr->Untyped[0] | 430 ((uint64_t)Ptr->Untyped[1] << 8) | 431 ((uint64_t)Ptr->Untyped[2] << 16) | 432 ((uint64_t)Ptr->Untyped[3] << 24) | 433 ((uint64_t)Ptr->Untyped[4] << 32) | 434 ((uint64_t)Ptr->Untyped[5] << 40) | 435 ((uint64_t)Ptr->Untyped[6] << 48) | 436 ((uint64_t)Ptr->Untyped[7] << 56); 437 break; 438 default: 439 std::cout << "Cannot load value of type " << *Ty << "!\n"; 440 abort(); 441 } 442 } else { 443 switch (Ty->getTypeID()) { 444 case Type::BoolTyID: 445 case Type::UByteTyID: 446 case Type::SByteTyID: Result.UByteVal = Ptr->Untyped[0]; break; 447 case Type::UShortTyID: 448 case Type::ShortTyID: Result.UShortVal = (unsigned)Ptr->Untyped[1] | 449 ((unsigned)Ptr->Untyped[0] << 8); 450 break; 451 Load4BytesBigEndian: 452 case Type::FloatTyID: 453 case Type::UIntTyID: 454 case Type::IntTyID: Result.UIntVal = (unsigned)Ptr->Untyped[3] | 455 ((unsigned)Ptr->Untyped[2] << 8) | 456 ((unsigned)Ptr->Untyped[1] << 16) | 457 ((unsigned)Ptr->Untyped[0] << 24); 458 break; 459 case Type::PointerTyID: if (getTargetData().getPointerSize() == 4) 460 goto Load4BytesBigEndian; 461 case Type::DoubleTyID: 462 case Type::ULongTyID: 463 case Type::LongTyID: Result.ULongVal = (uint64_t)Ptr->Untyped[7] | 464 ((uint64_t)Ptr->Untyped[6] << 8) | 465 ((uint64_t)Ptr->Untyped[5] << 16) | 466 ((uint64_t)Ptr->Untyped[4] << 24) | 467 ((uint64_t)Ptr->Untyped[3] << 32) | 468 ((uint64_t)Ptr->Untyped[2] << 40) | 469 ((uint64_t)Ptr->Untyped[1] << 48) | 470 ((uint64_t)Ptr->Untyped[0] << 56); 471 break; 472 default: 473 std::cout << "Cannot load value of type " << *Ty << "!\n"; 474 abort(); 475 } 476 } 477 return Result; 478 } 479 480 // InitializeMemory - Recursive function to apply a Constant value into the 481 // specified memory location... 482 // 483 void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) { 484 if (isa<UndefValue>(Init)) { 485 return; 486 } else if (const ConstantPacked *CP = dyn_cast<ConstantPacked>(Init)) { 487 unsigned ElementSize = 488 getTargetData().getTypeSize(CP->getType()->getElementType()); 489 for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i) 490 InitializeMemory(CP->getOperand(i), (char*)Addr+i*ElementSize); 491 return; 492 } else if (Init->getType()->isFirstClassType()) { 493 GenericValue Val = getConstantValue(Init); 494 StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType()); 495 return; 496 } else if (isa<ConstantAggregateZero>(Init)) { 497 memset(Addr, 0, (size_t)getTargetData().getTypeSize(Init->getType())); 498 return; 499 } 500 501 switch (Init->getType()->getTypeID()) { 502 case Type::ArrayTyID: { 503 const ConstantArray *CPA = cast<ConstantArray>(Init); 504 unsigned ElementSize = 505 getTargetData().getTypeSize(CPA->getType()->getElementType()); 506 for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i) 507 InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize); 508 return; 509 } 510 511 case Type::StructTyID: { 512 const ConstantStruct *CPS = cast<ConstantStruct>(Init); 513 const StructLayout *SL = 514 getTargetData().getStructLayout(cast<StructType>(CPS->getType())); 515 for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i) 516 InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->MemberOffsets[i]); 517 return; 518 } 519 520 default: 521 std::cerr << "Bad Type: " << *Init->getType() << "\n"; 522 assert(0 && "Unknown constant type to initialize memory with!"); 523 } 524 } 525 526 /// EmitGlobals - Emit all of the global variables to memory, storing their 527 /// addresses into GlobalAddress. This must make sure to copy the contents of 528 /// their initializers into the memory. 529 /// 530 void ExecutionEngine::emitGlobals() { 531 const TargetData &TD = getTargetData(); 532 533 // Loop over all of the global variables in the program, allocating the memory 534 // to hold them. 535 Module &M = getModule(); 536 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 537 I != E; ++I) 538 if (!I->isExternal()) { 539 // Get the type of the global... 540 const Type *Ty = I->getType()->getElementType(); 541 542 // Allocate some memory for it! 543 unsigned Size = TD.getTypeSize(Ty); 544 addGlobalMapping(I, new char[Size]); 545 } else { 546 // External variable reference. Try to use the dynamic loader to 547 // get a pointer to it. 548 if (void *SymAddr = sys::DynamicLibrary::SearchForAddressOfSymbol( 549 I->getName().c_str())) 550 addGlobalMapping(I, SymAddr); 551 else { 552 std::cerr << "Could not resolve external global address: " 553 << I->getName() << "\n"; 554 abort(); 555 } 556 } 557 558 // Now that all of the globals are set up in memory, loop through them all and 559 // initialize their contents. 560 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 561 I != E; ++I) 562 if (!I->isExternal()) 563 EmitGlobalVariable(I); 564 } 565 566 // EmitGlobalVariable - This method emits the specified global variable to the 567 // address specified in GlobalAddresses, or allocates new memory if it's not 568 // already in the map. 569 void ExecutionEngine::EmitGlobalVariable(const GlobalVariable *GV) { 570 void *GA = getPointerToGlobalIfAvailable(GV); 571 DEBUG(std::cerr << "Global '" << GV->getName() << "' -> " << GA << "\n"); 572 573 const Type *ElTy = GV->getType()->getElementType(); 574 size_t GVSize = (size_t)getTargetData().getTypeSize(ElTy); 575 if (GA == 0) { 576 // If it's not already specified, allocate memory for the global. 577 GA = new char[GVSize]; 578 addGlobalMapping(GV, GA); 579 } 580 581 InitializeMemory(GV->getInitializer(), GA); 582 NumInitBytes += (unsigned)GVSize; 583 ++NumGlobals; 584 } 585