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