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 #include "llvm/ExecutionEngine/ExecutionEngine.h"
  16 #include "llvm/ADT/SmallString.h"
  17 #include "llvm/ADT/Statistic.h"
  18 #include "llvm/ExecutionEngine/GenericValue.h"
  19 #include "llvm/ExecutionEngine/JITMemoryManager.h"
  20 #include "llvm/ExecutionEngine/ObjectCache.h"
  21 #include "llvm/IR/Constants.h"
  22 #include "llvm/IR/DataLayout.h"
  23 #include "llvm/IR/DerivedTypes.h"
  24 #include "llvm/IR/Module.h"
  25 #include "llvm/IR/Operator.h"
  26 #include "llvm/IR/ValueHandle.h"
  27 #include "llvm/Object/ObjectFile.h"
  28 #include "llvm/Support/Debug.h"
  29 #include "llvm/Support/DynamicLibrary.h"
  30 #include "llvm/Support/ErrorHandling.h"
  31 #include "llvm/Support/Host.h"
  32 #include "llvm/Support/MutexGuard.h"
  33 #include "llvm/Support/TargetRegistry.h"
  34 #include "llvm/Support/raw_ostream.h"
  35 #include "llvm/Target/TargetMachine.h"
  36 #include <cmath>
  37 #include <cstring>
  38 using namespace llvm;
  39
  40 #define DEBUG_TYPE "jit"
  41
  42 STATISTIC(NumInitBytes, "Number of bytes of global vars initialized");
  43 STATISTIC(NumGlobals  , "Number of global vars initialized");
  44
  45 // Pin the vtable to this file.
  46 void ObjectCache::anchor() {}
  47 void ObjectBuffer::anchor() {}
  48 void ObjectBufferStream::anchor() {}
  49
  50 ExecutionEngine *(*ExecutionEngine::JITCtor)(
  51   Module *M,
  52   std::string *ErrorStr,
  53   JITMemoryManager *JMM,
  54   bool GVsWithCode,
  55   TargetMachine *TM) = nullptr;
  56 ExecutionEngine *(*ExecutionEngine::MCJITCtor)(
  57   Module *M,
  58   std::string *ErrorStr,
  59   RTDyldMemoryManager *MCJMM,
  60   bool GVsWithCode,
  61   TargetMachine *TM) = nullptr;
  62 ExecutionEngine *(*ExecutionEngine::InterpCtor)(Module *M,
  63                                                 std::string *ErrorStr) =nullptr;
  64
  65 ExecutionEngine::ExecutionEngine(Module *M)
  66   : EEState(*this),
  67     LazyFunctionCreator(nullptr) {
  68   CompilingLazily         = false;
  69   GVCompilationDisabled   = false;
  70   SymbolSearchingDisabled = false;
  71
  72   // IR module verification is enabled by default in debug builds, and disabled
  73   // by default in release builds.
  74 #ifndef NDEBUG
  75   VerifyModules = true;
  76 #else
  77   VerifyModules = false;
  78 #endif
  79
  80   Modules.push_back(M);
  81   assert(M && "Module is null?");
  82 }
  83
  84 ExecutionEngine::~ExecutionEngine() {
  85   clearAllGlobalMappings();
  86   for (unsigned i = 0, e = Modules.size(); i != e; ++i)
  87     delete Modules[i];
  88 }
  89
  90 namespace {
  91 /// \brief Helper class which uses a value handler to automatically deletes the
  92 /// memory block when the GlobalVariable is destroyed.
  93 class GVMemoryBlock : public CallbackVH {
  94   GVMemoryBlock(const GlobalVariable *GV)
  95     : CallbackVH(const_cast<GlobalVariable*>(GV)) {}
  96
  97 public:
  98   /// \brief Returns the address the GlobalVariable should be written into.  The
  99   /// GVMemoryBlock object prefixes that.
 100   static char *Create(const GlobalVariable *GV, const DataLayout& TD) {
 101     Type *ElTy = GV->getType()->getElementType();
 102     size_t GVSize = (size_t)TD.getTypeAllocSize(ElTy);
 103     void *RawMemory = ::operator new(
 104       DataLayout::RoundUpAlignment(sizeof(GVMemoryBlock),
 105                                    TD.getPreferredAlignment(GV))
 106       + GVSize);
 107     new(RawMemory) GVMemoryBlock(GV);
 108     return static_cast<char*>(RawMemory) + sizeof(GVMemoryBlock);
 109   }
 110
 111   void deleted() override {
 112     // We allocated with operator new and with some extra memory hanging off the
 113     // end, so don't just delete this.  I'm not sure if this is actually
 114     // required.
 115     this->~GVMemoryBlock();
 116     ::operator delete(this);
 117   }
 118 };
 119 }  // anonymous namespace
 120
 121 char *ExecutionEngine::getMemoryForGV(const GlobalVariable *GV) {
 122   return GVMemoryBlock::Create(GV, *getDataLayout());
 123 }
 124
 125 void ExecutionEngine::addObjectFile(std::unique_ptr<object::ObjectFile> O) {
 126   llvm_unreachable("ExecutionEngine subclass doesn't implement addObjectFile.");
 127 }
 128
 129 bool ExecutionEngine::removeModule(Module *M) {
 130   for(SmallVectorImpl<Module *>::iterator I = Modules.begin(),
 131         E = Modules.end(); I != E; ++I) {
 132     Module *Found = *I;
 133     if (Found == M) {
 134       Modules.erase(I);
 135       clearGlobalMappingsFromModule(M);
 136       return true;
 137     }
 138   }
 139   return false;
 140 }
 141
 142 Function *ExecutionEngine::FindFunctionNamed(const char *FnName) {
 143   for (unsigned i = 0, e = Modules.size(); i != e; ++i) {
 144     if (Function *F = Modules[i]->getFunction(FnName))
 145       return F;
 146   }
 147   return nullptr;
 148 }
 149
 150
 151 void *ExecutionEngineState::RemoveMapping(const GlobalValue *ToUnmap) {
 152   GlobalAddressMapTy::iterator I = GlobalAddressMap.find(ToUnmap);
 153   void *OldVal;
 154
 155   // FIXME: This is silly, we shouldn't end up with a mapping -> 0 in the
 156   // GlobalAddressMap.
 157   if (I == GlobalAddressMap.end())
 158     OldVal = nullptr;
 159   else {
 160     OldVal = I->second;
 161     GlobalAddressMap.erase(I);
 162   }
 163
 164   GlobalAddressReverseMap.erase(OldVal);
 165   return OldVal;
 166 }
 167
 168 void ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) {
 169   MutexGuard locked(lock);
 170
 171   DEBUG(dbgs() << "JIT: Map \'" << GV->getName()
 172         << "\' to [" << Addr << "]\n";);
 173   void *&CurVal = EEState.getGlobalAddressMap()[GV];
 174   assert((!CurVal || !Addr) && "GlobalMapping already established!");
 175   CurVal = Addr;
 176
 177   // If we are using the reverse mapping, add it too.
 178   if (!EEState.getGlobalAddressReverseMap().empty()) {
 179     AssertingVH<const GlobalValue> &V =
 180       EEState.getGlobalAddressReverseMap()[Addr];
 181     assert((!V || !GV) && "GlobalMapping already established!");
 182     V = GV;
 183   }
 184 }
 185
 186 void ExecutionEngine::clearAllGlobalMappings() {
 187   MutexGuard locked(lock);
 188
 189   EEState.getGlobalAddressMap().clear();
 190   EEState.getGlobalAddressReverseMap().clear();
 191 }
 192
 193 void ExecutionEngine::clearGlobalMappingsFromModule(Module *M) {
 194   MutexGuard locked(lock);
 195
 196   for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI)
 197     EEState.RemoveMapping(FI);
 198   for (Module::global_iterator GI = M->global_begin(), GE = M->global_end();
 199        GI != GE; ++GI)
 200     EEState.RemoveMapping(GI);
 201 }
 202
 203 void *ExecutionEngine::updateGlobalMapping(const GlobalValue *GV, void *Addr) {
 204   MutexGuard locked(lock);
 205
 206   ExecutionEngineState::GlobalAddressMapTy &Map =
 207     EEState.getGlobalAddressMap();
 208
 209   // Deleting from the mapping?
 210   if (!Addr)
 211     return EEState.RemoveMapping(GV);
 212
 213   void *&CurVal = Map[GV];
 214   void *OldVal = CurVal;
 215
 216   if (CurVal && !EEState.getGlobalAddressReverseMap().empty())
 217     EEState.getGlobalAddressReverseMap().erase(CurVal);
 218   CurVal = Addr;
 219
 220   // If we are using the reverse mapping, add it too.
 221   if (!EEState.getGlobalAddressReverseMap().empty()) {
 222     AssertingVH<const GlobalValue> &V =
 223       EEState.getGlobalAddressReverseMap()[Addr];
 224     assert((!V || !GV) && "GlobalMapping already established!");
 225     V = GV;
 226   }
 227   return OldVal;
 228 }
 229
 230 void *ExecutionEngine::getPointerToGlobalIfAvailable(const GlobalValue *GV) {
 231   MutexGuard locked(lock);
 232
 233   ExecutionEngineState::GlobalAddressMapTy::iterator I =
 234     EEState.getGlobalAddressMap().find(GV);
 235   return I != EEState.getGlobalAddressMap().end() ? I->second : nullptr;
 236 }
 237
 238 const GlobalValue *ExecutionEngine::getGlobalValueAtAddress(void *Addr) {
 239   MutexGuard locked(lock);
 240
 241   // If we haven't computed the reverse mapping yet, do so first.
 242   if (EEState.getGlobalAddressReverseMap().empty()) {
 243     for (ExecutionEngineState::GlobalAddressMapTy::iterator
 244          I = EEState.getGlobalAddressMap().begin(),
 245          E = EEState.getGlobalAddressMap().end(); I != E; ++I)
 246       EEState.getGlobalAddressReverseMap().insert(std::make_pair(
 247                                                           I->second, I->first));
 248   }
 249
 250   std::map<void *, AssertingVH<const GlobalValue> >::iterator I =
 251     EEState.getGlobalAddressReverseMap().find(Addr);
 252   return I != EEState.getGlobalAddressReverseMap().end() ? I->second : nullptr;
 253 }
 254
 255 namespace {
 256 class ArgvArray {
 257   char *Array;
 258   std::vector<char*> Values;
 259 public:
 260   ArgvArray() : Array(nullptr) {}
 261   ~ArgvArray() { clear(); }
 262   void clear() {
 263     delete[] Array;
 264     Array = nullptr;
 265     for (size_t I = 0, E = Values.size(); I != E; ++I) {
 266       delete[] Values[I];
 267     }
 268     Values.clear();
 269   }
 270   /// Turn a vector of strings into a nice argv style array of pointers to null
 271   /// terminated strings.
 272   void *reset(LLVMContext &C, ExecutionEngine *EE,
 273               const std::vector<std::string> &InputArgv);
 274 };
 275 }  // anonymous namespace
 276 void *ArgvArray::reset(LLVMContext &C, ExecutionEngine *EE,
 277                        const std::vector<std::string> &InputArgv) {
 278   clear();  // Free the old contents.
 279   unsigned PtrSize = EE->getDataLayout()->getPointerSize();
 280   Array = new char[(InputArgv.size()+1)*PtrSize];
 281
 282   DEBUG(dbgs() << "JIT: ARGV = " << (void*)Array << "\n");
 283   Type *SBytePtr = Type::getInt8PtrTy(C);
 284
 285   for (unsigned i = 0; i != InputArgv.size(); ++i) {
 286     unsigned Size = InputArgv[i].size()+1;
 287     char *Dest = new char[Size];
 288     Values.push_back(Dest);
 289     DEBUG(dbgs() << "JIT: ARGV[" << i << "] = " << (void*)Dest << "\n");
 290
 291     std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest);
 292     Dest[Size-1] = 0;
 293
 294     // Endian safe: Array[i] = (PointerTy)Dest;
 295     EE->StoreValueToMemory(PTOGV(Dest), (GenericValue*)(Array+i*PtrSize),
 296                            SBytePtr);
 297   }
 298
 299   // Null terminate it
 300   EE->StoreValueToMemory(PTOGV(nullptr),
 301                          (GenericValue*)(Array+InputArgv.size()*PtrSize),
 302                          SBytePtr);
 303   return Array;
 304 }
 305
 306 void ExecutionEngine::runStaticConstructorsDestructors(Module *module,
 307                                                        bool isDtors) {
 308   const char *Name = isDtors ? "llvm.global_dtors" : "llvm.global_ctors";
 309   GlobalVariable *GV = module->getNamedGlobal(Name);
 310
 311   // If this global has internal linkage, or if it has a use, then it must be
 312   // an old-style (llvmgcc3) static ctor with __main linked in and in use.  If
 313   // this is the case, don't execute any of the global ctors, __main will do
 314   // it.
 315   if (!GV || GV->isDeclaration() || GV->hasLocalLinkage()) return;
 316
 317   // Should be an array of '{ i32, void ()* }' structs.  The first value is
 318   // the init priority, which we ignore.
 319   ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
 320   if (!InitList)
 321     return;
 322   for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {
 323     ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i));
 324     if (!CS) continue;
 325
 326     Constant *FP = CS->getOperand(1);
 327     if (FP->isNullValue())
 328       continue;  // Found a sentinal value, ignore.
 329
 330     // Strip off constant expression casts.
 331     if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP))
 332       if (CE->isCast())
 333         FP = CE->getOperand(0);
 334
 335     // Execute the ctor/dtor function!
 336     if (Function *F = dyn_cast<Function>(FP))
 337       runFunction(F, std::vector<GenericValue>());
 338
 339     // FIXME: It is marginally lame that we just do nothing here if we see an
 340     // entry we don't recognize. It might not be unreasonable for the verifier
 341     // to not even allow this and just assert here.
 342   }
 343 }
 344
 345 void ExecutionEngine::runStaticConstructorsDestructors(bool isDtors) {
 346   // Execute global ctors/dtors for each module in the program.
 347   for (unsigned i = 0, e = Modules.size(); i != e; ++i)
 348     runStaticConstructorsDestructors(Modules[i], isDtors);
 349 }
 350
 351 #ifndef NDEBUG
 352 /// isTargetNullPtr - Return whether the target pointer stored at Loc is null.
 353 static bool isTargetNullPtr(ExecutionEngine *EE, void *Loc) {
 354   unsigned PtrSize = EE->getDataLayout()->getPointerSize();
 355   for (unsigned i = 0; i < PtrSize; ++i)
 356     if (*(i + (uint8_t*)Loc))
 357       return false;
 358   return true;
 359 }
 360 #endif
 361
 362 int ExecutionEngine::runFunctionAsMain(Function *Fn,
 363                                        const std::vector<std::string> &argv,
 364                                        const char * const * envp) {
 365   std::vector<GenericValue> GVArgs;
 366   GenericValue GVArgc;
 367   GVArgc.IntVal = APInt(32, argv.size());
 368
 369   // Check main() type
 370   unsigned NumArgs = Fn->getFunctionType()->getNumParams();
 371   FunctionType *FTy = Fn->getFunctionType();
 372   Type* PPInt8Ty = Type::getInt8PtrTy(Fn->getContext())->getPointerTo();
 373
 374   // Check the argument types.
 375   if (NumArgs > 3)
 376     report_fatal_error("Invalid number of arguments of main() supplied");
 377   if (NumArgs >= 3 && FTy->getParamType(2) != PPInt8Ty)
 378     report_fatal_error("Invalid type for third argument of main() supplied");
 379   if (NumArgs >= 2 && FTy->getParamType(1) != PPInt8Ty)
 380     report_fatal_error("Invalid type for second argument of main() supplied");
 381   if (NumArgs >= 1 && !FTy->getParamType(0)->isIntegerTy(32))
 382     report_fatal_error("Invalid type for first argument of main() supplied");
 383   if (!FTy->getReturnType()->isIntegerTy() &&
 384       !FTy->getReturnType()->isVoidTy())
 385     report_fatal_error("Invalid return type of main() supplied");
 386
 387   ArgvArray CArgv;
 388   ArgvArray CEnv;
 389   if (NumArgs) {
 390     GVArgs.push_back(GVArgc); // Arg #0 = argc.
 391     if (NumArgs > 1) {
 392       // Arg #1 = argv.
 393       GVArgs.push_back(PTOGV(CArgv.reset(Fn->getContext(), this, argv)));
 394       assert(!isTargetNullPtr(this, GVTOP(GVArgs[1])) &&
 395              "argv[0] was null after CreateArgv");
 396       if (NumArgs > 2) {
 397         std::vector<std::string> EnvVars;
 398         for (unsigned i = 0; envp[i]; ++i)
 399           EnvVars.push_back(envp[i]);
 400         // Arg #2 = envp.
 401         GVArgs.push_back(PTOGV(CEnv.reset(Fn->getContext(), this, EnvVars)));
 402       }
 403     }
 404   }
 405
 406   return runFunction(Fn, GVArgs).IntVal.getZExtValue();
 407 }
 408
 409 ExecutionEngine *ExecutionEngine::create(Module *M,
 410                                          bool ForceInterpreter,
 411                                          std::string *ErrorStr,
 412                                          CodeGenOpt::Level OptLevel,
 413                                          bool GVsWithCode) {
 414
 415   EngineBuilder EB =
 416       EngineBuilder(M)
 417           .setEngineKind(ForceInterpreter ? EngineKind::Interpreter
 418                                           : EngineKind::Either)
 419           .setErrorStr(ErrorStr)
 420           .setOptLevel(OptLevel)
 421           .setAllocateGVsWithCode(GVsWithCode);
 422
 423   return EB.create();
 424 }
 425
 426 /// createJIT - This is the factory method for creating a JIT for the current
 427 /// machine, it does not fall back to the interpreter.  This takes ownership
 428 /// of the module.
 429 ExecutionEngine *ExecutionEngine::createJIT(Module *M,
 430                                             std::string *ErrorStr,
 431                                             JITMemoryManager *JMM,
 432                                             CodeGenOpt::Level OL,
 433                                             bool GVsWithCode,
 434                                             Reloc::Model RM,
 435                                             CodeModel::Model CMM) {
 436   if (!ExecutionEngine::JITCtor) {
 437     if (ErrorStr)
 438       *ErrorStr = "JIT has not been linked in.";
 439     return nullptr;
 440   }
 441
 442   // Use the defaults for extra parameters.  Users can use EngineBuilder to
 443   // set them.
 444   EngineBuilder EB(M);
 445   EB.setEngineKind(EngineKind::JIT);
 446   EB.setErrorStr(ErrorStr);
 447   EB.setRelocationModel(RM);
 448   EB.setCodeModel(CMM);
 449   EB.setAllocateGVsWithCode(GVsWithCode);
 450   EB.setOptLevel(OL);
 451   EB.setJITMemoryManager(JMM);
 452
 453   // TODO: permit custom TargetOptions here
 454   TargetMachine *TM = EB.selectTarget();
 455   if (!TM || (ErrorStr && ErrorStr->length() > 0)) return nullptr;
 456
 457   return ExecutionEngine::JITCtor(M, ErrorStr, JMM, GVsWithCode, TM);
 458 }
 459
 460 void EngineBuilder::InitEngine() {
 461   WhichEngine = EngineKind::Either;
 462   ErrorStr = nullptr;
 463   OptLevel = CodeGenOpt::Default;
 464   MCJMM = nullptr;
 465   JMM = nullptr;
 466   Options = TargetOptions();
 467   AllocateGVsWithCode = false;
 468   RelocModel = Reloc::Default;
 469   CMModel = CodeModel::JITDefault;
 470   UseMCJIT = false;
 471
 472 // IR module verification is enabled by default in debug builds, and disabled
 473 // by default in release builds.
 474 #ifndef NDEBUG
 475   VerifyModules = true;
 476 #else
 477   VerifyModules = false;
 478 #endif
 479 }
 480
 481 ExecutionEngine *EngineBuilder::create(TargetMachine *TM) {
 482   std::unique_ptr<TargetMachine> TheTM(TM); // Take ownership.
 483
 484   // Make sure we can resolve symbols in the program as well. The zero arg
 485   // to the function tells DynamicLibrary to load the program, not a library.
 486   if (sys::DynamicLibrary::LoadLibraryPermanently(nullptr, ErrorStr))
 487     return nullptr;
 488
 489   assert(!(JMM && MCJMM));
 490
 491   // If the user specified a memory manager but didn't specify which engine to
 492   // create, we assume they only want the JIT, and we fail if they only want
 493   // the interpreter.
 494   if (JMM || MCJMM) {
 495     if (WhichEngine & EngineKind::JIT)
 496       WhichEngine = EngineKind::JIT;
 497     else {
 498       if (ErrorStr)
 499         *ErrorStr = "Cannot create an interpreter with a memory manager.";
 500       return nullptr;
 501     }
 502   }
 503
 504   if (MCJMM && ! UseMCJIT) {
 505     if (ErrorStr)
 506       *ErrorStr =
 507         "Cannot create a legacy JIT with a runtime dyld memory "
 508         "manager.";
 509     return nullptr;
 510   }
 511
 512   // Unless the interpreter was explicitly selected or the JIT is not linked,
 513   // try making a JIT.
 514   if ((WhichEngine & EngineKind::JIT) && TheTM) {
 515     Triple TT(M->getTargetTriple());
 516     if (!TM->getTarget().hasJIT()) {
 517       errs() << "WARNING: This target JIT is not designed for the host"
 518              << " you are running.  If bad things happen, please choose"
 519              << " a different -march switch.\n";
 520     }
 521
 522     ExecutionEngine *EE = nullptr;
 523     if (UseMCJIT && ExecutionEngine::MCJITCtor)
 524       EE = ExecutionEngine::MCJITCtor(M, ErrorStr, MCJMM ? MCJMM : JMM,
 525                                       AllocateGVsWithCode, TheTM.release());
 526     else if (ExecutionEngine::JITCtor)
 527       EE = ExecutionEngine::JITCtor(M, ErrorStr, JMM,
 528                                     AllocateGVsWithCode, TheTM.release());
 529
 530     if (EE) {
 531       EE->setVerifyModules(VerifyModules);
 532       return EE;
 533     }
 534   }
 535
 536   // If we can't make a JIT and we didn't request one specifically, try making
 537   // an interpreter instead.
 538   if (WhichEngine & EngineKind::Interpreter) {
 539     if (ExecutionEngine::InterpCtor)
 540       return ExecutionEngine::InterpCtor(M, ErrorStr);
 541     if (ErrorStr)
 542       *ErrorStr = "Interpreter has not been linked in.";
 543     return nullptr;
 544   }
 545
 546   if ((WhichEngine & EngineKind::JIT) && !ExecutionEngine::JITCtor &&
 547       !ExecutionEngine::MCJITCtor) {
 548     if (ErrorStr)
 549       *ErrorStr = "JIT has not been linked in.";
 550   }
 551
 552   return nullptr;
 553 }
 554
 555 void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) {
 556   if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV)))
 557     return getPointerToFunction(F);
 558
 559   MutexGuard locked(lock);
 560   if (void *P = EEState.getGlobalAddressMap()[GV])
 561     return P;
 562
 563   // Global variable might have been added since interpreter started.
 564   if (GlobalVariable *GVar =
 565           const_cast<GlobalVariable *>(dyn_cast<GlobalVariable>(GV)))
 566     EmitGlobalVariable(GVar);
 567   else
 568     llvm_unreachable("Global hasn't had an address allocated yet!");
 569
 570   return EEState.getGlobalAddressMap()[GV];
 571 }
 572
 573 /// \brief Converts a Constant* into a GenericValue, including handling of
 574 /// ConstantExpr values.
 575 GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
 576   // If its undefined, return the garbage.
 577   if (isa<UndefValue>(C)) {
 578     GenericValue Result;
 579     switch (C->getType()->getTypeID()) {
 580     default:
 581       break;
 582     case Type::IntegerTyID:
 583     case Type::X86_FP80TyID:
 584     case Type::FP128TyID:
 585     case Type::PPC_FP128TyID:
 586       // Although the value is undefined, we still have to construct an APInt
 587       // with the correct bit width.
 588       Result.IntVal = APInt(C->getType()->getPrimitiveSizeInBits(), 0);
 589       break;
 590     case Type::StructTyID: {
 591       // if the whole struct is 'undef' just reserve memory for the value.
 592       if(StructType *STy = dyn_cast<StructType>(C->getType())) {
 593         unsigned int elemNum = STy->getNumElements();
 594         Result.AggregateVal.resize(elemNum);
 595         for (unsigned int i = 0; i < elemNum; ++i) {
 596           Type *ElemTy = STy->getElementType(i);
 597           if (ElemTy->isIntegerTy())
 598             Result.AggregateVal[i].IntVal =
 599               APInt(ElemTy->getPrimitiveSizeInBits(), 0);
 600           else if (ElemTy->isAggregateType()) {
 601               const Constant *ElemUndef = UndefValue::get(ElemTy);
 602               Result.AggregateVal[i] = getConstantValue(ElemUndef);
 603             }
 604           }
 605         }
 606       }
 607       break;
 608     case Type::VectorTyID:
 609       // if the whole vector is 'undef' just reserve memory for the value.
 610       const VectorType* VTy = dyn_cast<VectorType>(C->getType());
 611       const Type *ElemTy = VTy->getElementType();
 612       unsigned int elemNum = VTy->getNumElements();
 613       Result.AggregateVal.resize(elemNum);
 614       if (ElemTy->isIntegerTy())
 615         for (unsigned int i = 0; i < elemNum; ++i)
 616           Result.AggregateVal[i].IntVal =
 617             APInt(ElemTy->getPrimitiveSizeInBits(), 0);
 618       break;
 619     }
 620     return Result;
 621   }
 622
 623   // Otherwise, if the value is a ConstantExpr...
 624   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
 625     Constant *Op0 = CE->getOperand(0);
 626     switch (CE->getOpcode()) {
 627     case Instruction::GetElementPtr: {
 628       // Compute the index
 629       GenericValue Result = getConstantValue(Op0);
 630       APInt Offset(DL->getPointerSizeInBits(), 0);
 631       cast<GEPOperator>(CE)->accumulateConstantOffset(*DL, Offset);
 632
 633       char* tmp = (char*) Result.PointerVal;
 634       Result = PTOGV(tmp + Offset.getSExtValue());
 635       return Result;
 636     }
 637     case Instruction::Trunc: {
 638       GenericValue GV = getConstantValue(Op0);
 639       uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
 640       GV.IntVal = GV.IntVal.trunc(BitWidth);
 641       return GV;
 642     }
 643     case Instruction::ZExt: {
 644       GenericValue GV = getConstantValue(Op0);
 645       uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
 646       GV.IntVal = GV.IntVal.zext(BitWidth);
 647       return GV;
 648     }
 649     case Instruction::SExt: {
 650       GenericValue GV = getConstantValue(Op0);
 651       uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
 652       GV.IntVal = GV.IntVal.sext(BitWidth);
 653       return GV;
 654     }
 655     case Instruction::FPTrunc: {
 656       // FIXME long double
 657       GenericValue GV = getConstantValue(Op0);
 658       GV.FloatVal = float(GV.DoubleVal);
 659       return GV;
 660     }
 661     case Instruction::FPExt:{
 662       // FIXME long double
 663       GenericValue GV = getConstantValue(Op0);
 664       GV.DoubleVal = double(GV.FloatVal);
 665       return GV;
 666     }
 667     case Instruction::UIToFP: {
 668       GenericValue GV = getConstantValue(Op0);
 669       if (CE->getType()->isFloatTy())
 670         GV.FloatVal = float(GV.IntVal.roundToDouble());
 671       else if (CE->getType()->isDoubleTy())
 672         GV.DoubleVal = GV.IntVal.roundToDouble();
 673       else if (CE->getType()->isX86_FP80Ty()) {
 674         APFloat apf = APFloat::getZero(APFloat::x87DoubleExtended);
 675         (void)apf.convertFromAPInt(GV.IntVal,
 676                                    false,
 677                                    APFloat::rmNearestTiesToEven);
 678         GV.IntVal = apf.bitcastToAPInt();
 679       }
 680       return GV;
 681     }
 682     case Instruction::SIToFP: {
 683       GenericValue GV = getConstantValue(Op0);
 684       if (CE->getType()->isFloatTy())
 685         GV.FloatVal = float(GV.IntVal.signedRoundToDouble());
 686       else if (CE->getType()->isDoubleTy())
 687         GV.DoubleVal = GV.IntVal.signedRoundToDouble();
 688       else if (CE->getType()->isX86_FP80Ty()) {
 689         APFloat apf = APFloat::getZero(APFloat::x87DoubleExtended);
 690         (void)apf.convertFromAPInt(GV.IntVal,
 691                                    true,
 692                                    APFloat::rmNearestTiesToEven);
 693         GV.IntVal = apf.bitcastToAPInt();
 694       }
 695       return GV;
 696     }
 697     case Instruction::FPToUI: // double->APInt conversion handles sign
 698     case Instruction::FPToSI: {
 699       GenericValue GV = getConstantValue(Op0);
 700       uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
 701       if (Op0->getType()->isFloatTy())
 702         GV.IntVal = APIntOps::RoundFloatToAPInt(GV.FloatVal, BitWidth);
 703       else if (Op0->getType()->isDoubleTy())
 704         GV.IntVal = APIntOps::RoundDoubleToAPInt(GV.DoubleVal, BitWidth);
 705       else if (Op0->getType()->isX86_FP80Ty()) {
 706         APFloat apf = APFloat(APFloat::x87DoubleExtended, GV.IntVal);
 707         uint64_t v;
 708         bool ignored;
 709         (void)apf.convertToInteger(&v, BitWidth,
 710                                    CE->getOpcode()==Instruction::FPToSI,
 711                                    APFloat::rmTowardZero, &ignored);
 712         GV.IntVal = v; // endian?
 713       }
 714       return GV;
 715     }
 716     case Instruction::PtrToInt: {
 717       GenericValue GV = getConstantValue(Op0);
 718       uint32_t PtrWidth = DL->getTypeSizeInBits(Op0->getType());
 719       assert(PtrWidth <= 64 && "Bad pointer width");
 720       GV.IntVal = APInt(PtrWidth, uintptr_t(GV.PointerVal));
 721       uint32_t IntWidth = DL->getTypeSizeInBits(CE->getType());
 722       GV.IntVal = GV.IntVal.zextOrTrunc(IntWidth);
 723       return GV;
 724     }
 725     case Instruction::IntToPtr: {
 726       GenericValue GV = getConstantValue(Op0);
 727       uint32_t PtrWidth = DL->getTypeSizeInBits(CE->getType());
 728       GV.IntVal = GV.IntVal.zextOrTrunc(PtrWidth);
 729       assert(GV.IntVal.getBitWidth() <= 64 && "Bad pointer width");
 730       GV.PointerVal = PointerTy(uintptr_t(GV.IntVal.getZExtValue()));
 731       return GV;
 732     }
 733     case Instruction::BitCast: {
 734       GenericValue GV = getConstantValue(Op0);
 735       Type* DestTy = CE->getType();
 736       switch (Op0->getType()->getTypeID()) {
 737         default: llvm_unreachable("Invalid bitcast operand");
 738         case Type::IntegerTyID:
 739           assert(DestTy->isFloatingPointTy() && "invalid bitcast");
 740           if (DestTy->isFloatTy())
 741             GV.FloatVal = GV.IntVal.bitsToFloat();
 742           else if (DestTy->isDoubleTy())
 743             GV.DoubleVal = GV.IntVal.bitsToDouble();
 744           break;
 745         case Type::FloatTyID:
 746           assert(DestTy->isIntegerTy(32) && "Invalid bitcast");
 747           GV.IntVal = APInt::floatToBits(GV.FloatVal);
 748           break;
 749         case Type::DoubleTyID:
 750           assert(DestTy->isIntegerTy(64) && "Invalid bitcast");
 751           GV.IntVal = APInt::doubleToBits(GV.DoubleVal);
 752           break;
 753         case Type::PointerTyID:
 754           assert(DestTy->isPointerTy() && "Invalid bitcast");
 755           break; // getConstantValue(Op0)  above already converted it
 756       }
 757       return GV;
 758     }
 759     case Instruction::Add:
 760     case Instruction::FAdd:
 761     case Instruction::Sub:
 762     case Instruction::FSub:
 763     case Instruction::Mul:
 764     case Instruction::FMul:
 765     case Instruction::UDiv:
 766     case Instruction::SDiv:
 767     case Instruction::URem:
 768     case Instruction::SRem:
 769     case Instruction::And:
 770     case Instruction::Or:
 771     case Instruction::Xor: {
 772       GenericValue LHS = getConstantValue(Op0);
 773       GenericValue RHS = getConstantValue(CE->getOperand(1));
 774       GenericValue GV;
 775       switch (CE->getOperand(0)->getType()->getTypeID()) {
 776       default: llvm_unreachable("Bad add type!");
 777       case Type::IntegerTyID:
 778         switch (CE->getOpcode()) {
 779           default: llvm_unreachable("Invalid integer opcode");
 780           case Instruction::Add: GV.IntVal = LHS.IntVal + RHS.IntVal; break;
 781           case Instruction::Sub: GV.IntVal = LHS.IntVal - RHS.IntVal; break;
 782           case Instruction::Mul: GV.IntVal = LHS.IntVal * RHS.IntVal; break;
 783           case Instruction::UDiv:GV.IntVal = LHS.IntVal.udiv(RHS.IntVal); break;
 784           case Instruction::SDiv:GV.IntVal = LHS.IntVal.sdiv(RHS.IntVal); break;
 785           case Instruction::URem:GV.IntVal = LHS.IntVal.urem(RHS.IntVal); break;
 786           case Instruction::SRem:GV.IntVal = LHS.IntVal.srem(RHS.IntVal); break;
 787           case Instruction::And: GV.IntVal = LHS.IntVal & RHS.IntVal; break;
 788           case Instruction::Or:  GV.IntVal = LHS.IntVal | RHS.IntVal; break;
 789           case Instruction::Xor: GV.IntVal = LHS.IntVal ^ RHS.IntVal; break;
 790         }
 791         break;
 792       case Type::FloatTyID:
 793         switch (CE->getOpcode()) {
 794           default: llvm_unreachable("Invalid float opcode");
 795           case Instruction::FAdd:
 796             GV.FloatVal = LHS.FloatVal + RHS.FloatVal; break;
 797           case Instruction::FSub:
 798             GV.FloatVal = LHS.FloatVal - RHS.FloatVal; break;
 799           case Instruction::FMul:
 800             GV.FloatVal = LHS.FloatVal * RHS.FloatVal; break;
 801           case Instruction::FDiv:
 802             GV.FloatVal = LHS.FloatVal / RHS.FloatVal; break;
 803           case Instruction::FRem:
 804             GV.FloatVal = std::fmod(LHS.FloatVal,RHS.FloatVal); break;
 805         }
 806         break;
 807       case Type::DoubleTyID:
 808         switch (CE->getOpcode()) {
 809           default: llvm_unreachable("Invalid double opcode");
 810           case Instruction::FAdd:
 811             GV.DoubleVal = LHS.DoubleVal + RHS.DoubleVal; break;
 812           case Instruction::FSub:
 813             GV.DoubleVal = LHS.DoubleVal - RHS.DoubleVal; break;
 814           case Instruction::FMul:
 815             GV.DoubleVal = LHS.DoubleVal * RHS.DoubleVal; break;
 816           case Instruction::FDiv:
 817             GV.DoubleVal = LHS.DoubleVal / RHS.DoubleVal; break;
 818           case Instruction::FRem:
 819             GV.DoubleVal = std::fmod(LHS.DoubleVal,RHS.DoubleVal); break;
 820         }
 821         break;
 822       case Type::X86_FP80TyID:
 823       case Type::PPC_FP128TyID:
 824       case Type::FP128TyID: {
 825         const fltSemantics &Sem = CE->getOperand(0)->getType()->getFltSemantics();
 826         APFloat apfLHS = APFloat(Sem, LHS.IntVal);
 827         switch (CE->getOpcode()) {
 828           default: llvm_unreachable("Invalid long double opcode");
 829           case Instruction::FAdd:
 830             apfLHS.add(APFloat(Sem, RHS.IntVal), APFloat::rmNearestTiesToEven);
 831             GV.IntVal = apfLHS.bitcastToAPInt();
 832             break;
 833           case Instruction::FSub:
 834             apfLHS.subtract(APFloat(Sem, RHS.IntVal),
 835                             APFloat::rmNearestTiesToEven);
 836             GV.IntVal = apfLHS.bitcastToAPInt();
 837             break;
 838           case Instruction::FMul:
 839             apfLHS.multiply(APFloat(Sem, RHS.IntVal),
 840                             APFloat::rmNearestTiesToEven);
 841             GV.IntVal = apfLHS.bitcastToAPInt();
 842             break;
 843           case Instruction::FDiv:
 844             apfLHS.divide(APFloat(Sem, RHS.IntVal),
 845                           APFloat::rmNearestTiesToEven);
 846             GV.IntVal = apfLHS.bitcastToAPInt();
 847             break;
 848           case Instruction::FRem:
 849             apfLHS.mod(APFloat(Sem, RHS.IntVal),
 850                        APFloat::rmNearestTiesToEven);
 851             GV.IntVal = apfLHS.bitcastToAPInt();
 852             break;
 853           }
 854         }
 855         break;
 856       }
 857       return GV;
 858     }
 859     default:
 860       break;
 861     }
 862
 863     SmallString<256> Msg;
 864     raw_svector_ostream OS(Msg);
 865     OS << "ConstantExpr not handled: " << *CE;
 866     report_fatal_error(OS.str());
 867   }
 868
 869   // Otherwise, we have a simple constant.
 870   GenericValue Result;
 871   switch (C->getType()->getTypeID()) {
 872   case Type::FloatTyID:
 873     Result.FloatVal = cast<ConstantFP>(C)->getValueAPF().convertToFloat();
 874     break;
 875   case Type::DoubleTyID:
 876     Result.DoubleVal = cast<ConstantFP>(C)->getValueAPF().convertToDouble();
 877     break;
 878   case Type::X86_FP80TyID:
 879   case Type::FP128TyID:
 880   case Type::PPC_FP128TyID:
 881     Result.IntVal = cast <ConstantFP>(C)->getValueAPF().bitcastToAPInt();
 882     break;
 883   case Type::IntegerTyID:
 884     Result.IntVal = cast<ConstantInt>(C)->getValue();
 885     break;
 886   case Type::PointerTyID:
 887     if (isa<ConstantPointerNull>(C))
 888       Result.PointerVal = nullptr;
 889     else if (const Function *F = dyn_cast<Function>(C))
 890       Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F)));
 891     else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C))
 892       Result = PTOGV(getOrEmitGlobalVariable(const_cast<GlobalVariable*>(GV)));
 893     else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C))
 894       Result = PTOGV(getPointerToBasicBlock(const_cast<BasicBlock*>(
 895                                                         BA->getBasicBlock())));
 896     else
 897       llvm_unreachable("Unknown constant pointer type!");
 898     break;
 899   case Type::VectorTyID: {
 900     unsigned elemNum;
 901     Type* ElemTy;
 902     const ConstantDataVector *CDV = dyn_cast<ConstantDataVector>(C);
 903     const ConstantVector *CV = dyn_cast<ConstantVector>(C);
 904     const ConstantAggregateZero *CAZ = dyn_cast<ConstantAggregateZero>(C);
 905
 906     if (CDV) {
 907         elemNum = CDV->getNumElements();
 908         ElemTy = CDV->getElementType();
 909     } else if (CV || CAZ) {
 910         VectorType* VTy = dyn_cast<VectorType>(C->getType());
 911         elemNum = VTy->getNumElements();
 912         ElemTy = VTy->getElementType();
 913     } else {
 914         llvm_unreachable("Unknown constant vector type!");
 915     }
 916
 917     Result.AggregateVal.resize(elemNum);
 918     // Check if vector holds floats.
 919     if(ElemTy->isFloatTy()) {
 920       if (CAZ) {
 921         GenericValue floatZero;
 922         floatZero.FloatVal = 0.f;
 923         std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
 924                   floatZero);
 925         break;
 926       }
 927       if(CV) {
 928         for (unsigned i = 0; i < elemNum; ++i)
 929           if (!isa<UndefValue>(CV->getOperand(i)))
 930             Result.AggregateVal[i].FloatVal = cast<ConstantFP>(
 931               CV->getOperand(i))->getValueAPF().convertToFloat();
 932         break;
 933       }
 934       if(CDV)
 935         for (unsigned i = 0; i < elemNum; ++i)
 936           Result.AggregateVal[i].FloatVal = CDV->getElementAsFloat(i);
 937
 938       break;
 939     }
 940     // Check if vector holds doubles.
 941     if (ElemTy->isDoubleTy()) {
 942       if (CAZ) {
 943         GenericValue doubleZero;
 944         doubleZero.DoubleVal = 0.0;
 945         std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
 946                   doubleZero);
 947         break;
 948       }
 949       if(CV) {
 950         for (unsigned i = 0; i < elemNum; ++i)
 951           if (!isa<UndefValue>(CV->getOperand(i)))
 952             Result.AggregateVal[i].DoubleVal = cast<ConstantFP>(
 953               CV->getOperand(i))->getValueAPF().convertToDouble();
 954         break;
 955       }
 956       if(CDV)
 957         for (unsigned i = 0; i < elemNum; ++i)
 958           Result.AggregateVal[i].DoubleVal = CDV->getElementAsDouble(i);
 959
 960       break;
 961     }
 962     // Check if vector holds integers.
 963     if (ElemTy->isIntegerTy()) {
 964       if (CAZ) {
 965         GenericValue intZero;
 966         intZero.IntVal = APInt(ElemTy->getScalarSizeInBits(), 0ull);
 967         std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
 968                   intZero);
 969         break;
 970       }
 971       if(CV) {
 972         for (unsigned i = 0; i < elemNum; ++i)
 973           if (!isa<UndefValue>(CV->getOperand(i)))
 974             Result.AggregateVal[i].IntVal = cast<ConstantInt>(
 975                                             CV->getOperand(i))->getValue();
 976           else {
 977             Result.AggregateVal[i].IntVal =
 978               APInt(CV->getOperand(i)->getType()->getPrimitiveSizeInBits(), 0);
 979           }
 980         break;
 981       }
 982       if(CDV)
 983         for (unsigned i = 0; i < elemNum; ++i)
 984           Result.AggregateVal[i].IntVal = APInt(
 985             CDV->getElementType()->getPrimitiveSizeInBits(),
 986             CDV->getElementAsInteger(i));
 987
 988       break;
 989     }
 990     llvm_unreachable("Unknown constant pointer type!");
 991   }
 992   break;
 993
 994   default:
 995     SmallString<256> Msg;
 996     raw_svector_ostream OS(Msg);
 997     OS << "ERROR: Constant unimplemented for type: " << *C->getType();
 998     report_fatal_error(OS.str());
 999   }
1000
1001   return Result;
1002 }
1003
1004 /// StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst
1005 /// with the integer held in IntVal.
1006 static void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst,
1007                              unsigned StoreBytes) {
1008   assert((IntVal.getBitWidth()+7)/8 >= StoreBytes && "Integer too small!");
1009   const uint8_t *Src = (const uint8_t *)IntVal.getRawData();
1010
1011   if (sys::IsLittleEndianHost) {
1012     // Little-endian host - the source is ordered from LSB to MSB.  Order the
1013     // destination from LSB to MSB: Do a straight copy.
1014     memcpy(Dst, Src, StoreBytes);
1015   } else {
1016     // Big-endian host - the source is an array of 64 bit words ordered from
1017     // LSW to MSW.  Each word is ordered from MSB to LSB.  Order the destination
1018     // from MSB to LSB: Reverse the word order, but not the bytes in a word.
1019     while (StoreBytes > sizeof(uint64_t)) {
1020       StoreBytes -= sizeof(uint64_t);
1021       // May not be aligned so use memcpy.
1022       memcpy(Dst + StoreBytes, Src, sizeof(uint64_t));
1023       Src += sizeof(uint64_t);
1024     }
1025
1026     memcpy(Dst, Src + sizeof(uint64_t) - StoreBytes, StoreBytes);
1027   }
1028 }
1029
1030 void ExecutionEngine::StoreValueToMemory(const GenericValue &Val,
1031                                          GenericValue *Ptr, Type *Ty) {
1032   const unsigned StoreBytes = getDataLayout()->getTypeStoreSize(Ty);
1033
1034   switch (Ty->getTypeID()) {
1035   default:
1036     dbgs() << "Cannot store value of type " << *Ty << "!\n";
1037     break;
1038   case Type::IntegerTyID:
1039     StoreIntToMemory(Val.IntVal, (uint8_t*)Ptr, StoreBytes);
1040     break;
1041   case Type::FloatTyID:
1042     *((float*)Ptr) = Val.FloatVal;
1043     break;
1044   case Type::DoubleTyID:
1045     *((double*)Ptr) = Val.DoubleVal;
1046     break;
1047   case Type::X86_FP80TyID:
1048     memcpy(Ptr, Val.IntVal.getRawData(), 10);
1049     break;
1050   case Type::PointerTyID:
1051     // Ensure 64 bit target pointers are fully initialized on 32 bit hosts.
1052     if (StoreBytes != sizeof(PointerTy))
1053       memset(&(Ptr->PointerVal), 0, StoreBytes);
1054
1055     *((PointerTy*)Ptr) = Val.PointerVal;
1056     break;
1057   case Type::VectorTyID:
1058     for (unsigned i = 0; i < Val.AggregateVal.size(); ++i) {
1059       if (cast<VectorType>(Ty)->getElementType()->isDoubleTy())
1060         *(((double*)Ptr)+i) = Val.AggregateVal[i].DoubleVal;
1061       if (cast<VectorType>(Ty)->getElementType()->isFloatTy())
1062         *(((float*)Ptr)+i) = Val.AggregateVal[i].FloatVal;
1063       if (cast<VectorType>(Ty)->getElementType()->isIntegerTy()) {
1064         unsigned numOfBytes =(Val.AggregateVal[i].IntVal.getBitWidth()+7)/8;
1065         StoreIntToMemory(Val.AggregateVal[i].IntVal,
1066           (uint8_t*)Ptr + numOfBytes*i, numOfBytes);
1067       }
1068     }
1069     break;
1070   }
1071
1072   if (sys::IsLittleEndianHost != getDataLayout()->isLittleEndian())
1073     // Host and target are different endian - reverse the stored bytes.
1074     std::reverse((uint8_t*)Ptr, StoreBytes + (uint8_t*)Ptr);
1075 }
1076
1077 /// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting
1078 /// from Src into IntVal, which is assumed to be wide enough and to hold zero.
1079 static void LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes) {
1080   assert((IntVal.getBitWidth()+7)/8 >= LoadBytes && "Integer too small!");
1081   uint8_t *Dst = reinterpret_cast<uint8_t *>(
1082                    const_cast<uint64_t *>(IntVal.getRawData()));
1083
1084   if (sys::IsLittleEndianHost)
1085     // Little-endian host - the destination must be ordered from LSB to MSB.
1086     // The source is ordered from LSB to MSB: Do a straight copy.
1087     memcpy(Dst, Src, LoadBytes);
1088   else {
1089     // Big-endian - the destination is an array of 64 bit words ordered from
1090     // LSW to MSW.  Each word must be ordered from MSB to LSB.  The source is
1091     // ordered from MSB to LSB: Reverse the word order, but not the bytes in
1092     // a word.
1093     while (LoadBytes > sizeof(uint64_t)) {
1094       LoadBytes -= sizeof(uint64_t);
1095       // May not be aligned so use memcpy.
1096       memcpy(Dst, Src + LoadBytes, sizeof(uint64_t));
1097       Dst += sizeof(uint64_t);
1098     }
1099
1100     memcpy(Dst + sizeof(uint64_t) - LoadBytes, Src, LoadBytes);
1101   }
1102 }
1103
1104 /// FIXME: document
1105 ///
1106 void ExecutionEngine::LoadValueFromMemory(GenericValue &Result,
1107                                           GenericValue *Ptr,
1108                                           Type *Ty) {
1109   const unsigned LoadBytes = getDataLayout()->getTypeStoreSize(Ty);
1110
1111   switch (Ty->getTypeID()) {
1112   case Type::IntegerTyID:
1113     // An APInt with all words initially zero.
1114     Result.IntVal = APInt(cast<IntegerType>(Ty)->getBitWidth(), 0);
1115     LoadIntFromMemory(Result.IntVal, (uint8_t*)Ptr, LoadBytes);
1116     break;
1117   case Type::FloatTyID:
1118     Result.FloatVal = *((float*)Ptr);
1119     break;
1120   case Type::DoubleTyID:
1121     Result.DoubleVal = *((double*)Ptr);
1122     break;
1123   case Type::PointerTyID:
1124     Result.PointerVal = *((PointerTy*)Ptr);
1125     break;
1126   case Type::X86_FP80TyID: {
1127     // This is endian dependent, but it will only work on x86 anyway.
1128     // FIXME: Will not trap if loading a signaling NaN.
1129     uint64_t y[2];
1130     memcpy(y, Ptr, 10);
1131     Result.IntVal = APInt(80, y);
1132     break;
1133   }
1134   case Type::VectorTyID: {
1135     const VectorType *VT = cast<VectorType>(Ty);
1136     const Type *ElemT = VT->getElementType();
1137     const unsigned numElems = VT->getNumElements();
1138     if (ElemT->isFloatTy()) {
1139       Result.AggregateVal.resize(numElems);
1140       for (unsigned i = 0; i < numElems; ++i)
1141         Result.AggregateVal[i].FloatVal = *((float*)Ptr+i);
1142     }
1143     if (ElemT->isDoubleTy()) {
1144       Result.AggregateVal.resize(numElems);
1145       for (unsigned i = 0; i < numElems; ++i)
1146         Result.AggregateVal[i].DoubleVal = *((double*)Ptr+i);
1147     }
1148     if (ElemT->isIntegerTy()) {
1149       GenericValue intZero;
1150       const unsigned elemBitWidth = cast<IntegerType>(ElemT)->getBitWidth();
1151       intZero.IntVal = APInt(elemBitWidth, 0);
1152       Result.AggregateVal.resize(numElems, intZero);
1153       for (unsigned i = 0; i < numElems; ++i)
1154         LoadIntFromMemory(Result.AggregateVal[i].IntVal,
1155           (uint8_t*)Ptr+((elemBitWidth+7)/8)*i, (elemBitWidth+7)/8);
1156     }
1157   break;
1158   }
1159   default:
1160     SmallString<256> Msg;
1161     raw_svector_ostream OS(Msg);
1162     OS << "Cannot load value of type " << *Ty << "!";
1163     report_fatal_error(OS.str());
1164   }
1165 }
1166
1167 void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) {
1168   DEBUG(dbgs() << "JIT: Initializing " << Addr << " ");
1169   DEBUG(Init->dump());
1170   if (isa<UndefValue>(Init))
1171     return;
1172
1173   if (const ConstantVector *CP = dyn_cast<ConstantVector>(Init)) {
1174     unsigned ElementSize =
1175       getDataLayout()->getTypeAllocSize(CP->getType()->getElementType());
1176     for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
1177       InitializeMemory(CP->getOperand(i), (char*)Addr+i*ElementSize);
1178     return;
1179   }
1180
1181   if (isa<ConstantAggregateZero>(Init)) {
1182     memset(Addr, 0, (size_t)getDataLayout()->getTypeAllocSize(Init->getType()));
1183     return;
1184   }
1185
1186   if (const ConstantArray *CPA = dyn_cast<ConstantArray>(Init)) {
1187     unsigned ElementSize =
1188       getDataLayout()->getTypeAllocSize(CPA->getType()->getElementType());
1189     for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i)
1190       InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize);
1191     return;
1192   }
1193
1194   if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(Init)) {
1195     const StructLayout *SL =
1196       getDataLayout()->getStructLayout(cast<StructType>(CPS->getType()));
1197     for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i)
1198       InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->getElementOffset(i));
1199     return;
1200   }
1201
1202   if (const ConstantDataSequential *CDS =
1203                dyn_cast<ConstantDataSequential>(Init)) {
1204     // CDS is already laid out in host memory order.
1205     StringRef Data = CDS->getRawDataValues();
1206     memcpy(Addr, Data.data(), Data.size());
1207     return;
1208   }
1209
1210   if (Init->getType()->isFirstClassType()) {
1211     GenericValue Val = getConstantValue(Init);
1212     StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType());
1213     return;
1214   }
1215
1216   DEBUG(dbgs() << "Bad Type: " << *Init->getType() << "\n");
1217   llvm_unreachable("Unknown constant type to initialize memory with!");
1218 }
1219
1220 /// EmitGlobals - Emit all of the global variables to memory, storing their
1221 /// addresses into GlobalAddress.  This must make sure to copy the contents of
1222 /// their initializers into the memory.
1223 void ExecutionEngine::emitGlobals() {
1224   // Loop over all of the global variables in the program, allocating the memory
1225   // to hold them.  If there is more than one module, do a prepass over globals
1226   // to figure out how the different modules should link together.
1227   std::map<std::pair<std::string, Type*>,
1228            const GlobalValue*> LinkedGlobalsMap;
1229
1230   if (Modules.size() != 1) {
1231     for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
1232       Module &M = *Modules[m];
1233       for (const auto &GV : M.globals()) {
1234         if (GV.hasLocalLinkage() || GV.isDeclaration() ||
1235             GV.hasAppendingLinkage() || !GV.hasName())
1236           continue;// Ignore external globals and globals with internal linkage.
1237
1238         const GlobalValue *&GVEntry =
1239           LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())];
1240
1241         // If this is the first time we've seen this global, it is the canonical
1242         // version.
1243         if (!GVEntry) {
1244           GVEntry = &GV;
1245           continue;
1246         }
1247
1248         // If the existing global is strong, never replace it.
1249         if (GVEntry->hasExternalLinkage())
1250           continue;
1251
1252         // Otherwise, we know it's linkonce/weak, replace it if this is a strong
1253         // symbol.  FIXME is this right for common?
1254         if (GV.hasExternalLinkage() || GVEntry->hasExternalWeakLinkage())
1255           GVEntry = &GV;
1256       }
1257     }
1258   }
1259
1260   std::vector<const GlobalValue*> NonCanonicalGlobals;
1261   for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
1262     Module &M = *Modules[m];
1263     for (const auto &GV : M.globals()) {
1264       // In the multi-module case, see what this global maps to.
1265       if (!LinkedGlobalsMap.empty()) {
1266         if (const GlobalValue *GVEntry =
1267               LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())]) {
1268           // If something else is the canonical global, ignore this one.
1269           if (GVEntry != &GV) {
1270             NonCanonicalGlobals.push_back(&GV);
1271             continue;
1272           }
1273         }
1274       }
1275
1276       if (!GV.isDeclaration()) {
1277         addGlobalMapping(&GV, getMemoryForGV(&GV));
1278       } else {
1279         // External variable reference. Try to use the dynamic loader to
1280         // get a pointer to it.
1281         if (void *SymAddr =
1282             sys::DynamicLibrary::SearchForAddressOfSymbol(GV.getName()))
1283           addGlobalMapping(&GV, SymAddr);
1284         else {
1285           report_fatal_error("Could not resolve external global address: "
1286                             +GV.getName());
1287         }
1288       }
1289     }
1290
1291     // If there are multiple modules, map the non-canonical globals to their
1292     // canonical location.
1293     if (!NonCanonicalGlobals.empty()) {
1294       for (unsigned i = 0, e = NonCanonicalGlobals.size(); i != e; ++i) {
1295         const GlobalValue *GV = NonCanonicalGlobals[i];
1296         const GlobalValue *CGV =
1297           LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())];
1298         void *Ptr = getPointerToGlobalIfAvailable(CGV);
1299         assert(Ptr && "Canonical global wasn't codegen'd!");
1300         addGlobalMapping(GV, Ptr);
1301       }
1302     }
1303
1304     // Now that all of the globals are set up in memory, loop through them all
1305     // and initialize their contents.
1306     for (const auto &GV : M.globals()) {
1307       if (!GV.isDeclaration()) {
1308         if (!LinkedGlobalsMap.empty()) {
1309           if (const GlobalValue *GVEntry =
1310                 LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())])
1311             if (GVEntry != &GV)  // Not the canonical variable.
1312               continue;
1313         }
1314         EmitGlobalVariable(&GV);
1315       }
1316     }
1317   }
1318 }
1319
1320 // EmitGlobalVariable - This method emits the specified global variable to the
1321 // address specified in GlobalAddresses, or allocates new memory if it's not
1322 // already in the map.
1323 void ExecutionEngine::EmitGlobalVariable(const GlobalVariable *GV) {
1324   void *GA = getPointerToGlobalIfAvailable(GV);
1325
1326   if (!GA) {
1327     // If it's not already specified, allocate memory for the global.
1328     GA = getMemoryForGV(GV);
1329
1330     // If we failed to allocate memory for this global, return.
1331     if (!GA) return;
1332
1333     addGlobalMapping(GV, GA);
1334   }
1335
1336   // Don't initialize if it's thread local, let the client do it.
1337   if (!GV->isThreadLocal())
1338     InitializeMemory(GV->getInitializer(), GA);
1339
1340   Type *ElTy = GV->getType()->getElementType();
1341   size_t GVSize = (size_t)getDataLayout()->getTypeAllocSize(ElTy);
1342   NumInitBytes += (unsigned)GVSize;
1343   ++NumGlobals;
1344 }
1345
1346 ExecutionEngineState::ExecutionEngineState(ExecutionEngine &EE)
1347   : EE(EE), GlobalAddressMap(this) {
1348 }
1349
1350 sys::Mutex *
1351 ExecutionEngineState::AddressMapConfig::getMutex(ExecutionEngineState *EES) {
1352   return &EES->EE.lock;
1353 }
1354
1355 void ExecutionEngineState::AddressMapConfig::onDelete(ExecutionEngineState *EES,
1356                                                       const GlobalValue *Old) {
1357   void *OldVal = EES->GlobalAddressMap.lookup(Old);
1358   EES->GlobalAddressReverseMap.erase(OldVal);
1359 }
1360
1361 void ExecutionEngineState::AddressMapConfig::onRAUW(ExecutionEngineState *,
1362                                                     const GlobalValue *,
1363                                                     const GlobalValue *) {
1364   llvm_unreachable("The ExecutionEngine doesn't know how to handle a"
1365                    " RAUW on a value it has a global mapping for.");
1366 }