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