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