lib/ExecutionEngine/ExecutionEngine.cpp

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