lib/ExecutionEngine/ExecutionEngine.cpp

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