LLVM  7.0.0svn
ExecutionEngine.cpp
Go to the documentation of this file.
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 
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/ADT/SmallString.h"
18 #include "llvm/ADT/Statistic.h"
23 #include "llvm/IR/Constants.h"
24 #include "llvm/IR/DataLayout.h"
25 #include "llvm/IR/DerivedTypes.h"
26 #include "llvm/IR/Mangler.h"
27 #include "llvm/IR/Module.h"
28 #include "llvm/IR/Operator.h"
29 #include "llvm/IR/ValueHandle.h"
30 #include "llvm/Object/Archive.h"
31 #include "llvm/Object/ObjectFile.h"
32 #include "llvm/Support/Debug.h"
35 #include "llvm/Support/Host.h"
40 #include <cmath>
41 #include <cstring>
42 using namespace llvm;
43 
44 #define DEBUG_TYPE "jit"
45 
46 STATISTIC(NumInitBytes, "Number of bytes of global vars initialized");
47 STATISTIC(NumGlobals , "Number of global vars initialized");
48 
49 ExecutionEngine *(*ExecutionEngine::MCJITCtor)(
50  std::unique_ptr<Module> M, std::string *ErrorStr,
51  std::shared_ptr<MCJITMemoryManager> MemMgr,
52  std::shared_ptr<LegacyJITSymbolResolver> Resolver,
53  std::unique_ptr<TargetMachine> TM) = nullptr;
54 
55 ExecutionEngine *(*ExecutionEngine::OrcMCJITReplacementCtor)(
56  std::string *ErrorStr, std::shared_ptr<MCJITMemoryManager> MemMgr,
57  std::shared_ptr<LegacyJITSymbolResolver> Resolver,
58  std::unique_ptr<TargetMachine> TM) = nullptr;
59 
60 ExecutionEngine *(*ExecutionEngine::InterpCtor)(std::unique_ptr<Module> M,
61  std::string *ErrorStr) =nullptr;
62 
63 void JITEventListener::anchor() {}
64 
65 void ObjectCache::anchor() {}
66 
67 void ExecutionEngine::Init(std::unique_ptr<Module> M) {
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  assert(M && "Module is null?");
81  Modules.push_back(std::move(M));
82 }
83 
84 ExecutionEngine::ExecutionEngine(std::unique_ptr<Module> M)
85  : DL(M->getDataLayout()), LazyFunctionCreator(nullptr) {
86  Init(std::move(M));
87 }
88 
89 ExecutionEngine::ExecutionEngine(DataLayout DL, std::unique_ptr<Module> M)
90  : DL(std::move(DL)), LazyFunctionCreator(nullptr) {
91  Init(std::move(M));
92 }
93 
96 }
97 
98 namespace {
99 /// \brief Helper class which uses a value handler to automatically deletes the
100 /// memory block when the GlobalVariable is destroyed.
101 class GVMemoryBlock final : public CallbackVH {
102  GVMemoryBlock(const GlobalVariable *GV)
103  : CallbackVH(const_cast<GlobalVariable*>(GV)) {}
104 
105 public:
106  /// \brief Returns the address the GlobalVariable should be written into. The
107  /// GVMemoryBlock object prefixes that.
108  static char *Create(const GlobalVariable *GV, const DataLayout& TD) {
109  Type *ElTy = GV->getValueType();
110  size_t GVSize = (size_t)TD.getTypeAllocSize(ElTy);
111  void *RawMemory = ::operator new(
112  alignTo(sizeof(GVMemoryBlock), TD.getPreferredAlignment(GV)) + GVSize);
113  new(RawMemory) GVMemoryBlock(GV);
114  return static_cast<char*>(RawMemory) + sizeof(GVMemoryBlock);
115  }
116 
117  void deleted() override {
118  // We allocated with operator new and with some extra memory hanging off the
119  // end, so don't just delete this. I'm not sure if this is actually
120  // required.
121  this->~GVMemoryBlock();
122  ::operator delete(this);
123  }
124 };
125 } // anonymous namespace
126 
128  return GVMemoryBlock::Create(GV, getDataLayout());
129 }
130 
131 void ExecutionEngine::addObjectFile(std::unique_ptr<object::ObjectFile> O) {
132  llvm_unreachable("ExecutionEngine subclass doesn't implement addObjectFile.");
133 }
134 
135 void
137  llvm_unreachable("ExecutionEngine subclass doesn't implement addObjectFile.");
138 }
139 
141  llvm_unreachable("ExecutionEngine subclass doesn't implement addArchive.");
142 }
143 
145  for (auto I = Modules.begin(), E = Modules.end(); I != E; ++I) {
146  Module *Found = I->get();
147  if (Found == M) {
148  I->release();
149  Modules.erase(I);
151  return true;
152  }
153  }
154  return false;
155 }
156 
158  for (unsigned i = 0, e = Modules.size(); i != e; ++i) {
159  Function *F = Modules[i]->getFunction(FnName);
160  if (F && !F->isDeclaration())
161  return F;
162  }
163  return nullptr;
164 }
165 
167  for (unsigned i = 0, e = Modules.size(); i != e; ++i) {
168  GlobalVariable *GV = Modules[i]->getGlobalVariable(Name,AllowInternal);
169  if (GV && !GV->isDeclaration())
170  return GV;
171  }
172  return nullptr;
173 }
174 
176  GlobalAddressMapTy::iterator I = GlobalAddressMap.find(Name);
177  uint64_t OldVal;
178 
179  // FIXME: This is silly, we shouldn't end up with a mapping -> 0 in the
180  // GlobalAddressMap.
181  if (I == GlobalAddressMap.end())
182  OldVal = 0;
183  else {
184  GlobalAddressReverseMap.erase(I->second);
185  OldVal = I->second;
186  GlobalAddressMap.erase(I);
187  }
188 
189  return OldVal;
190 }
191 
193  assert(GV->hasName() && "Global must have name.");
194 
195  MutexGuard locked(lock);
196  SmallString<128> FullName;
197 
198  const DataLayout &DL =
200  ? getDataLayout()
201  : GV->getParent()->getDataLayout();
202 
203  Mangler::getNameWithPrefix(FullName, GV->getName(), DL);
204  return FullName.str();
205 }
206 
207 void ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) {
208  MutexGuard locked(lock);
209  addGlobalMapping(getMangledName(GV), (uint64_t) Addr);
210 }
211 
213  MutexGuard locked(lock);
214 
215  assert(!Name.empty() && "Empty GlobalMapping symbol name!");
216 
217  DEBUG(dbgs() << "JIT: Map \'" << Name << "\' to [" << Addr << "]\n";);
218  uint64_t &CurVal = EEState.getGlobalAddressMap()[Name];
219  assert((!CurVal || !Addr) && "GlobalMapping already established!");
220  CurVal = Addr;
221 
222  // If we are using the reverse mapping, add it too.
223  if (!EEState.getGlobalAddressReverseMap().empty()) {
224  std::string &V = EEState.getGlobalAddressReverseMap()[CurVal];
225  assert((!V.empty() || !Name.empty()) &&
226  "GlobalMapping already established!");
227  V = Name;
228  }
229 }
230 
232  MutexGuard locked(lock);
233 
234  EEState.getGlobalAddressMap().clear();
235  EEState.getGlobalAddressReverseMap().clear();
236 }
237 
239  MutexGuard locked(lock);
240 
241  for (GlobalObject &GO : M->global_objects())
242  EEState.RemoveMapping(getMangledName(&GO));
243 }
244 
246  void *Addr) {
247  MutexGuard locked(lock);
248  return updateGlobalMapping(getMangledName(GV), (uint64_t) Addr);
249 }
250 
252  MutexGuard locked(lock);
253 
255  EEState.getGlobalAddressMap();
256 
257  // Deleting from the mapping?
258  if (!Addr)
259  return EEState.RemoveMapping(Name);
260 
261  uint64_t &CurVal = Map[Name];
262  uint64_t OldVal = CurVal;
263 
264  if (CurVal && !EEState.getGlobalAddressReverseMap().empty())
265  EEState.getGlobalAddressReverseMap().erase(CurVal);
266  CurVal = Addr;
267 
268  // If we are using the reverse mapping, add it too.
269  if (!EEState.getGlobalAddressReverseMap().empty()) {
270  std::string &V = EEState.getGlobalAddressReverseMap()[CurVal];
271  assert((!V.empty() || !Name.empty()) &&
272  "GlobalMapping already established!");
273  V = Name;
274  }
275  return OldVal;
276 }
277 
279  MutexGuard locked(lock);
280  uint64_t Address = 0;
282  EEState.getGlobalAddressMap().find(S);
283  if (I != EEState.getGlobalAddressMap().end())
284  Address = I->second;
285  return Address;
286 }
287 
288 
290  MutexGuard locked(lock);
291  if (void* Address = (void *) getAddressToGlobalIfAvailable(S))
292  return Address;
293  return nullptr;
294 }
295 
297  MutexGuard locked(lock);
299 }
300 
302  MutexGuard locked(lock);
303 
304  // If we haven't computed the reverse mapping yet, do so first.
305  if (EEState.getGlobalAddressReverseMap().empty()) {
307  I = EEState.getGlobalAddressMap().begin(),
308  E = EEState.getGlobalAddressMap().end(); I != E; ++I) {
309  StringRef Name = I->first();
310  uint64_t Addr = I->second;
311  EEState.getGlobalAddressReverseMap().insert(std::make_pair(
312  Addr, Name));
313  }
314  }
315 
316  std::map<uint64_t, std::string>::iterator I =
317  EEState.getGlobalAddressReverseMap().find((uint64_t) Addr);
318 
319  if (I != EEState.getGlobalAddressReverseMap().end()) {
320  StringRef Name = I->second;
321  for (unsigned i = 0, e = Modules.size(); i != e; ++i)
322  if (GlobalValue *GV = Modules[i]->getNamedValue(Name))
323  return GV;
324  }
325  return nullptr;
326 }
327 
328 namespace {
329 class ArgvArray {
330  std::unique_ptr<char[]> Array;
331  std::vector<std::unique_ptr<char[]>> Values;
332 public:
333  /// Turn a vector of strings into a nice argv style array of pointers to null
334  /// terminated strings.
335  void *reset(LLVMContext &C, ExecutionEngine *EE,
336  const std::vector<std::string> &InputArgv);
337 };
338 } // anonymous namespace
339 void *ArgvArray::reset(LLVMContext &C, ExecutionEngine *EE,
340  const std::vector<std::string> &InputArgv) {
341  Values.clear(); // Free the old contents.
342  Values.reserve(InputArgv.size());
343  unsigned PtrSize = EE->getDataLayout().getPointerSize();
344  Array = make_unique<char[]>((InputArgv.size()+1)*PtrSize);
345 
346  DEBUG(dbgs() << "JIT: ARGV = " << (void*)Array.get() << "\n");
347  Type *SBytePtr = Type::getInt8PtrTy(C);
348 
349  for (unsigned i = 0; i != InputArgv.size(); ++i) {
350  unsigned Size = InputArgv[i].size()+1;
351  auto Dest = make_unique<char[]>(Size);
352  DEBUG(dbgs() << "JIT: ARGV[" << i << "] = " << (void*)Dest.get() << "\n");
353 
354  std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest.get());
355  Dest[Size-1] = 0;
356 
357  // Endian safe: Array[i] = (PointerTy)Dest;
358  EE->StoreValueToMemory(PTOGV(Dest.get()),
359  (GenericValue*)(&Array[i*PtrSize]), SBytePtr);
360  Values.push_back(std::move(Dest));
361  }
362 
363  // Null terminate it
364  EE->StoreValueToMemory(PTOGV(nullptr),
365  (GenericValue*)(&Array[InputArgv.size()*PtrSize]),
366  SBytePtr);
367  return Array.get();
368 }
369 
371  bool isDtors) {
372  StringRef Name(isDtors ? "llvm.global_dtors" : "llvm.global_ctors");
373  GlobalVariable *GV = module.getNamedGlobal(Name);
374 
375  // If this global has internal linkage, or if it has a use, then it must be
376  // an old-style (llvmgcc3) static ctor with __main linked in and in use. If
377  // this is the case, don't execute any of the global ctors, __main will do
378  // it.
379  if (!GV || GV->isDeclaration() || GV->hasLocalLinkage()) return;
380 
381  // Should be an array of '{ i32, void ()* }' structs. The first value is
382  // the init priority, which we ignore.
384  if (!InitList)
385  return;
386  for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {
387  ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i));
388  if (!CS) continue;
389 
390  Constant *FP = CS->getOperand(1);
391  if (FP->isNullValue())
392  continue; // Found a sentinal value, ignore.
393 
394  // Strip off constant expression casts.
395  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP))
396  if (CE->isCast())
397  FP = CE->getOperand(0);
398 
399  // Execute the ctor/dtor function!
400  if (Function *F = dyn_cast<Function>(FP))
401  runFunction(F, None);
402 
403  // FIXME: It is marginally lame that we just do nothing here if we see an
404  // entry we don't recognize. It might not be unreasonable for the verifier
405  // to not even allow this and just assert here.
406  }
407 }
408 
410  // Execute global ctors/dtors for each module in the program.
411  for (std::unique_ptr<Module> &M : Modules)
413 }
414 
415 #ifndef NDEBUG
416 /// isTargetNullPtr - Return whether the target pointer stored at Loc is null.
417 static bool isTargetNullPtr(ExecutionEngine *EE, void *Loc) {
418  unsigned PtrSize = EE->getDataLayout().getPointerSize();
419  for (unsigned i = 0; i < PtrSize; ++i)
420  if (*(i + (uint8_t*)Loc))
421  return false;
422  return true;
423 }
424 #endif
425 
427  const std::vector<std::string> &argv,
428  const char * const * envp) {
429  std::vector<GenericValue> GVArgs;
430  GenericValue GVArgc;
431  GVArgc.IntVal = APInt(32, argv.size());
432 
433  // Check main() type
434  unsigned NumArgs = Fn->getFunctionType()->getNumParams();
435  FunctionType *FTy = Fn->getFunctionType();
436  Type* PPInt8Ty = Type::getInt8PtrTy(Fn->getContext())->getPointerTo();
437 
438  // Check the argument types.
439  if (NumArgs > 3)
440  report_fatal_error("Invalid number of arguments of main() supplied");
441  if (NumArgs >= 3 && FTy->getParamType(2) != PPInt8Ty)
442  report_fatal_error("Invalid type for third argument of main() supplied");
443  if (NumArgs >= 2 && FTy->getParamType(1) != PPInt8Ty)
444  report_fatal_error("Invalid type for second argument of main() supplied");
445  if (NumArgs >= 1 && !FTy->getParamType(0)->isIntegerTy(32))
446  report_fatal_error("Invalid type for first argument of main() supplied");
447  if (!FTy->getReturnType()->isIntegerTy() &&
448  !FTy->getReturnType()->isVoidTy())
449  report_fatal_error("Invalid return type of main() supplied");
450 
451  ArgvArray CArgv;
452  ArgvArray CEnv;
453  if (NumArgs) {
454  GVArgs.push_back(GVArgc); // Arg #0 = argc.
455  if (NumArgs > 1) {
456  // Arg #1 = argv.
457  GVArgs.push_back(PTOGV(CArgv.reset(Fn->getContext(), this, argv)));
458  assert(!isTargetNullPtr(this, GVTOP(GVArgs[1])) &&
459  "argv[0] was null after CreateArgv");
460  if (NumArgs > 2) {
461  std::vector<std::string> EnvVars;
462  for (unsigned i = 0; envp[i]; ++i)
463  EnvVars.emplace_back(envp[i]);
464  // Arg #2 = envp.
465  GVArgs.push_back(PTOGV(CEnv.reset(Fn->getContext(), this, EnvVars)));
466  }
467  }
468  }
469 
470  return runFunction(Fn, GVArgs).IntVal.getZExtValue();
471 }
472 
474 
475 EngineBuilder::EngineBuilder(std::unique_ptr<Module> M)
476  : M(std::move(M)), WhichEngine(EngineKind::Either), ErrorStr(nullptr),
477  OptLevel(CodeGenOpt::Default), MemMgr(nullptr), Resolver(nullptr),
478  UseOrcMCJITReplacement(false) {
479 // IR module verification is enabled by default in debug builds, and disabled
480 // by default in release builds.
481 #ifndef NDEBUG
482  VerifyModules = true;
483 #else
484  VerifyModules = false;
485 #endif
486 }
487 
489 
491  std::unique_ptr<RTDyldMemoryManager> mcjmm) {
492  auto SharedMM = std::shared_ptr<RTDyldMemoryManager>(std::move(mcjmm));
493  MemMgr = SharedMM;
494  Resolver = SharedMM;
495  return *this;
496 }
497 
499 EngineBuilder::setMemoryManager(std::unique_ptr<MCJITMemoryManager> MM) {
500  MemMgr = std::shared_ptr<MCJITMemoryManager>(std::move(MM));
501  return *this;
502 }
503 
505 EngineBuilder::setSymbolResolver(std::unique_ptr<LegacyJITSymbolResolver> SR) {
506  Resolver = std::shared_ptr<LegacyJITSymbolResolver>(std::move(SR));
507  return *this;
508 }
509 
511  std::unique_ptr<TargetMachine> TheTM(TM); // Take ownership.
512 
513  // Make sure we can resolve symbols in the program as well. The zero arg
514  // to the function tells DynamicLibrary to load the program, not a library.
515  if (sys::DynamicLibrary::LoadLibraryPermanently(nullptr, ErrorStr))
516  return nullptr;
517 
518  // If the user specified a memory manager but didn't specify which engine to
519  // create, we assume they only want the JIT, and we fail if they only want
520  // the interpreter.
521  if (MemMgr) {
522  if (WhichEngine & EngineKind::JIT)
523  WhichEngine = EngineKind::JIT;
524  else {
525  if (ErrorStr)
526  *ErrorStr = "Cannot create an interpreter with a memory manager.";
527  return nullptr;
528  }
529  }
530 
531  // Unless the interpreter was explicitly selected or the JIT is not linked,
532  // try making a JIT.
533  if ((WhichEngine & EngineKind::JIT) && TheTM) {
534  if (!TM->getTarget().hasJIT()) {
535  errs() << "WARNING: This target JIT is not designed for the host"
536  << " you are running. If bad things happen, please choose"
537  << " a different -march switch.\n";
538  }
539 
540  ExecutionEngine *EE = nullptr;
541  if (ExecutionEngine::OrcMCJITReplacementCtor && UseOrcMCJITReplacement) {
542  EE = ExecutionEngine::OrcMCJITReplacementCtor(ErrorStr, std::move(MemMgr),
543  std::move(Resolver),
544  std::move(TheTM));
545  EE->addModule(std::move(M));
546  } else if (ExecutionEngine::MCJITCtor)
547  EE = ExecutionEngine::MCJITCtor(std::move(M), ErrorStr, std::move(MemMgr),
548  std::move(Resolver), std::move(TheTM));
549 
550  if (EE) {
551  EE->setVerifyModules(VerifyModules);
552  return EE;
553  }
554  }
555 
556  // If we can't make a JIT and we didn't request one specifically, try making
557  // an interpreter instead.
558  if (WhichEngine & EngineKind::Interpreter) {
560  return ExecutionEngine::InterpCtor(std::move(M), ErrorStr);
561  if (ErrorStr)
562  *ErrorStr = "Interpreter has not been linked in.";
563  return nullptr;
564  }
565 
566  if ((WhichEngine & EngineKind::JIT) && !ExecutionEngine::MCJITCtor) {
567  if (ErrorStr)
568  *ErrorStr = "JIT has not been linked in.";
569  }
570 
571  return nullptr;
572 }
573 
575  if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV)))
576  return getPointerToFunction(F);
577 
578  MutexGuard locked(lock);
579  if (void* P = getPointerToGlobalIfAvailable(GV))
580  return P;
581 
582  // Global variable might have been added since interpreter started.
583  if (GlobalVariable *GVar =
584  const_cast<GlobalVariable *>(dyn_cast<GlobalVariable>(GV)))
585  EmitGlobalVariable(GVar);
586  else
587  llvm_unreachable("Global hasn't had an address allocated yet!");
588 
589  return getPointerToGlobalIfAvailable(GV);
590 }
591 
592 /// \brief Converts a Constant* into a GenericValue, including handling of
593 /// ConstantExpr values.
595  // If its undefined, return the garbage.
596  if (isa<UndefValue>(C)) {
597  GenericValue Result;
598  switch (C->getType()->getTypeID()) {
599  default:
600  break;
601  case Type::IntegerTyID:
602  case Type::X86_FP80TyID:
603  case Type::FP128TyID:
604  case Type::PPC_FP128TyID:
605  // Although the value is undefined, we still have to construct an APInt
606  // with the correct bit width.
607  Result.IntVal = APInt(C->getType()->getPrimitiveSizeInBits(), 0);
608  break;
609  case Type::StructTyID: {
610  // if the whole struct is 'undef' just reserve memory for the value.
611  if(StructType *STy = dyn_cast<StructType>(C->getType())) {
612  unsigned int elemNum = STy->getNumElements();
613  Result.AggregateVal.resize(elemNum);
614  for (unsigned int i = 0; i < elemNum; ++i) {
615  Type *ElemTy = STy->getElementType(i);
616  if (ElemTy->isIntegerTy())
617  Result.AggregateVal[i].IntVal =
618  APInt(ElemTy->getPrimitiveSizeInBits(), 0);
619  else if (ElemTy->isAggregateType()) {
620  const Constant *ElemUndef = UndefValue::get(ElemTy);
621  Result.AggregateVal[i] = getConstantValue(ElemUndef);
622  }
623  }
624  }
625  }
626  break;
627  case Type::VectorTyID:
628  // if the whole vector is 'undef' just reserve memory for the value.
629  auto* VTy = dyn_cast<VectorType>(C->getType());
630  Type *ElemTy = VTy->getElementType();
631  unsigned int elemNum = VTy->getNumElements();
632  Result.AggregateVal.resize(elemNum);
633  if (ElemTy->isIntegerTy())
634  for (unsigned int i = 0; i < elemNum; ++i)
635  Result.AggregateVal[i].IntVal =
636  APInt(ElemTy->getPrimitiveSizeInBits(), 0);
637  break;
638  }
639  return Result;
640  }
641 
642  // Otherwise, if the value is a ConstantExpr...
643  if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
644  Constant *Op0 = CE->getOperand(0);
645  switch (CE->getOpcode()) {
646  case Instruction::GetElementPtr: {
647  // Compute the index
648  GenericValue Result = getConstantValue(Op0);
649  APInt Offset(DL.getPointerSizeInBits(), 0);
650  cast<GEPOperator>(CE)->accumulateConstantOffset(DL, Offset);
651 
652  char* tmp = (char*) Result.PointerVal;
653  Result = PTOGV(tmp + Offset.getSExtValue());
654  return Result;
655  }
656  case Instruction::Trunc: {
657  GenericValue GV = getConstantValue(Op0);
658  uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
659  GV.IntVal = GV.IntVal.trunc(BitWidth);
660  return GV;
661  }
662  case Instruction::ZExt: {
663  GenericValue GV = getConstantValue(Op0);
664  uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
665  GV.IntVal = GV.IntVal.zext(BitWidth);
666  return GV;
667  }
668  case Instruction::SExt: {
669  GenericValue GV = getConstantValue(Op0);
670  uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
671  GV.IntVal = GV.IntVal.sext(BitWidth);
672  return GV;
673  }
674  case Instruction::FPTrunc: {
675  // FIXME long double
676  GenericValue GV = getConstantValue(Op0);
677  GV.FloatVal = float(GV.DoubleVal);
678  return GV;
679  }
680  case Instruction::FPExt:{
681  // FIXME long double
682  GenericValue GV = getConstantValue(Op0);
683  GV.DoubleVal = double(GV.FloatVal);
684  return GV;
685  }
686  case Instruction::UIToFP: {
687  GenericValue GV = getConstantValue(Op0);
688  if (CE->getType()->isFloatTy())
689  GV.FloatVal = float(GV.IntVal.roundToDouble());
690  else if (CE->getType()->isDoubleTy())
691  GV.DoubleVal = GV.IntVal.roundToDouble();
692  else if (CE->getType()->isX86_FP80Ty()) {
694  (void)apf.convertFromAPInt(GV.IntVal,
695  false,
697  GV.IntVal = apf.bitcastToAPInt();
698  }
699  return GV;
700  }
701  case Instruction::SIToFP: {
702  GenericValue GV = getConstantValue(Op0);
703  if (CE->getType()->isFloatTy())
704  GV.FloatVal = float(GV.IntVal.signedRoundToDouble());
705  else if (CE->getType()->isDoubleTy())
707  else if (CE->getType()->isX86_FP80Ty()) {
709  (void)apf.convertFromAPInt(GV.IntVal,
710  true,
712  GV.IntVal = apf.bitcastToAPInt();
713  }
714  return GV;
715  }
716  case Instruction::FPToUI: // double->APInt conversion handles sign
717  case Instruction::FPToSI: {
718  GenericValue GV = getConstantValue(Op0);
719  uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
720  if (Op0->getType()->isFloatTy())
721  GV.IntVal = APIntOps::RoundFloatToAPInt(GV.FloatVal, BitWidth);
722  else if (Op0->getType()->isDoubleTy())
723  GV.IntVal = APIntOps::RoundDoubleToAPInt(GV.DoubleVal, BitWidth);
724  else if (Op0->getType()->isX86_FP80Ty()) {
726  uint64_t v;
727  bool ignored;
728  (void)apf.convertToInteger(makeMutableArrayRef(v), BitWidth,
729  CE->getOpcode()==Instruction::FPToSI,
730  APFloat::rmTowardZero, &ignored);
731  GV.IntVal = v; // endian?
732  }
733  return GV;
734  }
735  case Instruction::PtrToInt: {
736  GenericValue GV = getConstantValue(Op0);
737  uint32_t PtrWidth = DL.getTypeSizeInBits(Op0->getType());
738  assert(PtrWidth <= 64 && "Bad pointer width");
739  GV.IntVal = APInt(PtrWidth, uintptr_t(GV.PointerVal));
740  uint32_t IntWidth = DL.getTypeSizeInBits(CE->getType());
741  GV.IntVal = GV.IntVal.zextOrTrunc(IntWidth);
742  return GV;
743  }
744  case Instruction::IntToPtr: {
745  GenericValue GV = getConstantValue(Op0);
746  uint32_t PtrWidth = DL.getTypeSizeInBits(CE->getType());
747  GV.IntVal = GV.IntVal.zextOrTrunc(PtrWidth);
748  assert(GV.IntVal.getBitWidth() <= 64 && "Bad pointer width");
749  GV.PointerVal = PointerTy(uintptr_t(GV.IntVal.getZExtValue()));
750  return GV;
751  }
752  case Instruction::BitCast: {
753  GenericValue GV = getConstantValue(Op0);
754  Type* DestTy = CE->getType();
755  switch (Op0->getType()->getTypeID()) {
756  default: llvm_unreachable("Invalid bitcast operand");
757  case Type::IntegerTyID:
758  assert(DestTy->isFloatingPointTy() && "invalid bitcast");
759  if (DestTy->isFloatTy())
760  GV.FloatVal = GV.IntVal.bitsToFloat();
761  else if (DestTy->isDoubleTy())
762  GV.DoubleVal = GV.IntVal.bitsToDouble();
763  break;
764  case Type::FloatTyID:
765  assert(DestTy->isIntegerTy(32) && "Invalid bitcast");
767  break;
768  case Type::DoubleTyID:
769  assert(DestTy->isIntegerTy(64) && "Invalid bitcast");
771  break;
772  case Type::PointerTyID:
773  assert(DestTy->isPointerTy() && "Invalid bitcast");
774  break; // getConstantValue(Op0) above already converted it
775  }
776  return GV;
777  }
778  case Instruction::Add:
779  case Instruction::FAdd:
780  case Instruction::Sub:
781  case Instruction::FSub:
782  case Instruction::Mul:
783  case Instruction::FMul:
784  case Instruction::UDiv:
785  case Instruction::SDiv:
786  case Instruction::URem:
787  case Instruction::SRem:
788  case Instruction::And:
789  case Instruction::Or:
790  case Instruction::Xor: {
791  GenericValue LHS = getConstantValue(Op0);
792  GenericValue RHS = getConstantValue(CE->getOperand(1));
793  GenericValue GV;
794  switch (CE->getOperand(0)->getType()->getTypeID()) {
795  default: llvm_unreachable("Bad add type!");
796  case Type::IntegerTyID:
797  switch (CE->getOpcode()) {
798  default: llvm_unreachable("Invalid integer opcode");
799  case Instruction::Add: GV.IntVal = LHS.IntVal + RHS.IntVal; break;
800  case Instruction::Sub: GV.IntVal = LHS.IntVal - RHS.IntVal; break;
801  case Instruction::Mul: GV.IntVal = LHS.IntVal * RHS.IntVal; break;
802  case Instruction::UDiv:GV.IntVal = LHS.IntVal.udiv(RHS.IntVal); break;
803  case Instruction::SDiv:GV.IntVal = LHS.IntVal.sdiv(RHS.IntVal); break;
804  case Instruction::URem:GV.IntVal = LHS.IntVal.urem(RHS.IntVal); break;
805  case Instruction::SRem:GV.IntVal = LHS.IntVal.srem(RHS.IntVal); break;
806  case Instruction::And: GV.IntVal = LHS.IntVal & RHS.IntVal; break;
807  case Instruction::Or: GV.IntVal = LHS.IntVal | RHS.IntVal; break;
808  case Instruction::Xor: GV.IntVal = LHS.IntVal ^ RHS.IntVal; break;
809  }
810  break;
811  case Type::FloatTyID:
812  switch (CE->getOpcode()) {
813  default: llvm_unreachable("Invalid float opcode");
814  case Instruction::FAdd:
815  GV.FloatVal = LHS.FloatVal + RHS.FloatVal; break;
816  case Instruction::FSub:
817  GV.FloatVal = LHS.FloatVal - RHS.FloatVal; break;
818  case Instruction::FMul:
819  GV.FloatVal = LHS.FloatVal * RHS.FloatVal; break;
820  case Instruction::FDiv:
821  GV.FloatVal = LHS.FloatVal / RHS.FloatVal; break;
822  case Instruction::FRem:
823  GV.FloatVal = std::fmod(LHS.FloatVal,RHS.FloatVal); break;
824  }
825  break;
826  case Type::DoubleTyID:
827  switch (CE->getOpcode()) {
828  default: llvm_unreachable("Invalid double opcode");
829  case Instruction::FAdd:
830  GV.DoubleVal = LHS.DoubleVal + RHS.DoubleVal; break;
831  case Instruction::FSub:
832  GV.DoubleVal = LHS.DoubleVal - RHS.DoubleVal; break;
833  case Instruction::FMul:
834  GV.DoubleVal = LHS.DoubleVal * RHS.DoubleVal; break;
835  case Instruction::FDiv:
836  GV.DoubleVal = LHS.DoubleVal / RHS.DoubleVal; break;
837  case Instruction::FRem:
838  GV.DoubleVal = std::fmod(LHS.DoubleVal,RHS.DoubleVal); break;
839  }
840  break;
841  case Type::X86_FP80TyID:
842  case Type::PPC_FP128TyID:
843  case Type::FP128TyID: {
844  const fltSemantics &Sem = CE->getOperand(0)->getType()->getFltSemantics();
845  APFloat apfLHS = APFloat(Sem, LHS.IntVal);
846  switch (CE->getOpcode()) {
847  default: llvm_unreachable("Invalid long double opcode");
848  case Instruction::FAdd:
849  apfLHS.add(APFloat(Sem, RHS.IntVal), APFloat::rmNearestTiesToEven);
850  GV.IntVal = apfLHS.bitcastToAPInt();
851  break;
852  case Instruction::FSub:
853  apfLHS.subtract(APFloat(Sem, RHS.IntVal),
855  GV.IntVal = apfLHS.bitcastToAPInt();
856  break;
857  case Instruction::FMul:
858  apfLHS.multiply(APFloat(Sem, RHS.IntVal),
860  GV.IntVal = apfLHS.bitcastToAPInt();
861  break;
862  case Instruction::FDiv:
863  apfLHS.divide(APFloat(Sem, RHS.IntVal),
865  GV.IntVal = apfLHS.bitcastToAPInt();
866  break;
867  case Instruction::FRem:
868  apfLHS.mod(APFloat(Sem, RHS.IntVal));
869  GV.IntVal = apfLHS.bitcastToAPInt();
870  break;
871  }
872  }
873  break;
874  }
875  return GV;
876  }
877  default:
878  break;
879  }
880 
881  SmallString<256> Msg;
882  raw_svector_ostream OS(Msg);
883  OS << "ConstantExpr not handled: " << *CE;
884  report_fatal_error(OS.str());
885  }
886 
887  // Otherwise, we have a simple constant.
888  GenericValue Result;
889  switch (C->getType()->getTypeID()) {
890  case Type::FloatTyID:
891  Result.FloatVal = cast<ConstantFP>(C)->getValueAPF().convertToFloat();
892  break;
893  case Type::DoubleTyID:
894  Result.DoubleVal = cast<ConstantFP>(C)->getValueAPF().convertToDouble();
895  break;
896  case Type::X86_FP80TyID:
897  case Type::FP128TyID:
898  case Type::PPC_FP128TyID:
899  Result.IntVal = cast <ConstantFP>(C)->getValueAPF().bitcastToAPInt();
900  break;
901  case Type::IntegerTyID:
902  Result.IntVal = cast<ConstantInt>(C)->getValue();
903  break;
904  case Type::PointerTyID:
905  if (isa<ConstantPointerNull>(C))
906  Result.PointerVal = nullptr;
907  else if (const Function *F = dyn_cast<Function>(C))
908  Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F)));
909  else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C))
910  Result = PTOGV(getOrEmitGlobalVariable(const_cast<GlobalVariable*>(GV)));
911  else
912  llvm_unreachable("Unknown constant pointer type!");
913  break;
914  case Type::VectorTyID: {
915  unsigned elemNum;
916  Type* ElemTy;
918  const ConstantVector *CV = dyn_cast<ConstantVector>(C);
920 
921  if (CDV) {
922  elemNum = CDV->getNumElements();
923  ElemTy = CDV->getElementType();
924  } else if (CV || CAZ) {
925  VectorType* VTy = dyn_cast<VectorType>(C->getType());
926  elemNum = VTy->getNumElements();
927  ElemTy = VTy->getElementType();
928  } else {
929  llvm_unreachable("Unknown constant vector type!");
930  }
931 
932  Result.AggregateVal.resize(elemNum);
933  // Check if vector holds floats.
934  if(ElemTy->isFloatTy()) {
935  if (CAZ) {
936  GenericValue floatZero;
937  floatZero.FloatVal = 0.f;
938  std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
939  floatZero);
940  break;
941  }
942  if(CV) {
943  for (unsigned i = 0; i < elemNum; ++i)
944  if (!isa<UndefValue>(CV->getOperand(i)))
945  Result.AggregateVal[i].FloatVal = cast<ConstantFP>(
946  CV->getOperand(i))->getValueAPF().convertToFloat();
947  break;
948  }
949  if(CDV)
950  for (unsigned i = 0; i < elemNum; ++i)
951  Result.AggregateVal[i].FloatVal = CDV->getElementAsFloat(i);
952 
953  break;
954  }
955  // Check if vector holds doubles.
956  if (ElemTy->isDoubleTy()) {
957  if (CAZ) {
958  GenericValue doubleZero;
959  doubleZero.DoubleVal = 0.0;
960  std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
961  doubleZero);
962  break;
963  }
964  if(CV) {
965  for (unsigned i = 0; i < elemNum; ++i)
966  if (!isa<UndefValue>(CV->getOperand(i)))
967  Result.AggregateVal[i].DoubleVal = cast<ConstantFP>(
968  CV->getOperand(i))->getValueAPF().convertToDouble();
969  break;
970  }
971  if(CDV)
972  for (unsigned i = 0; i < elemNum; ++i)
973  Result.AggregateVal[i].DoubleVal = CDV->getElementAsDouble(i);
974 
975  break;
976  }
977  // Check if vector holds integers.
978  if (ElemTy->isIntegerTy()) {
979  if (CAZ) {
980  GenericValue intZero;
981  intZero.IntVal = APInt(ElemTy->getScalarSizeInBits(), 0ull);
982  std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
983  intZero);
984  break;
985  }
986  if(CV) {
987  for (unsigned i = 0; i < elemNum; ++i)
988  if (!isa<UndefValue>(CV->getOperand(i)))
989  Result.AggregateVal[i].IntVal = cast<ConstantInt>(
990  CV->getOperand(i))->getValue();
991  else {
992  Result.AggregateVal[i].IntVal =
993  APInt(CV->getOperand(i)->getType()->getPrimitiveSizeInBits(), 0);
994  }
995  break;
996  }
997  if(CDV)
998  for (unsigned i = 0; i < elemNum; ++i)
999  Result.AggregateVal[i].IntVal = APInt(
1001  CDV->getElementAsInteger(i));
1002 
1003  break;
1004  }
1005  llvm_unreachable("Unknown constant pointer type!");
1006  }
1007  break;
1008 
1009  default:
1010  SmallString<256> Msg;
1011  raw_svector_ostream OS(Msg);
1012  OS << "ERROR: Constant unimplemented for type: " << *C->getType();
1013  report_fatal_error(OS.str());
1014  }
1015 
1016  return Result;
1017 }
1018 
1019 /// StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst
1020 /// with the integer held in IntVal.
1021 static void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst,
1022  unsigned StoreBytes) {
1023  assert((IntVal.getBitWidth()+7)/8 >= StoreBytes && "Integer too small!");
1024  const uint8_t *Src = (const uint8_t *)IntVal.getRawData();
1025 
1027  // Little-endian host - the source is ordered from LSB to MSB. Order the
1028  // destination from LSB to MSB: Do a straight copy.
1029  memcpy(Dst, Src, StoreBytes);
1030  } else {
1031  // Big-endian host - the source is an array of 64 bit words ordered from
1032  // LSW to MSW. Each word is ordered from MSB to LSB. Order the destination
1033  // from MSB to LSB: Reverse the word order, but not the bytes in a word.
1034  while (StoreBytes > sizeof(uint64_t)) {
1035  StoreBytes -= sizeof(uint64_t);
1036  // May not be aligned so use memcpy.
1037  memcpy(Dst + StoreBytes, Src, sizeof(uint64_t));
1038  Src += sizeof(uint64_t);
1039  }
1040 
1041  memcpy(Dst, Src + sizeof(uint64_t) - StoreBytes, StoreBytes);
1042  }
1043 }
1044 
1046  GenericValue *Ptr, Type *Ty) {
1047  const unsigned StoreBytes = getDataLayout().getTypeStoreSize(Ty);
1048 
1049  switch (Ty->getTypeID()) {
1050  default:
1051  dbgs() << "Cannot store value of type " << *Ty << "!\n";
1052  break;
1053  case Type::IntegerTyID:
1054  StoreIntToMemory(Val.IntVal, (uint8_t*)Ptr, StoreBytes);
1055  break;
1056  case Type::FloatTyID:
1057  *((float*)Ptr) = Val.FloatVal;
1058  break;
1059  case Type::DoubleTyID:
1060  *((double*)Ptr) = Val.DoubleVal;
1061  break;
1062  case Type::X86_FP80TyID:
1063  memcpy(Ptr, Val.IntVal.getRawData(), 10);
1064  break;
1065  case Type::PointerTyID:
1066  // Ensure 64 bit target pointers are fully initialized on 32 bit hosts.
1067  if (StoreBytes != sizeof(PointerTy))
1068  memset(&(Ptr->PointerVal), 0, StoreBytes);
1069 
1070  *((PointerTy*)Ptr) = Val.PointerVal;
1071  break;
1072  case Type::VectorTyID:
1073  for (unsigned i = 0; i < Val.AggregateVal.size(); ++i) {
1074  if (cast<VectorType>(Ty)->getElementType()->isDoubleTy())
1075  *(((double*)Ptr)+i) = Val.AggregateVal[i].DoubleVal;
1076  if (cast<VectorType>(Ty)->getElementType()->isFloatTy())
1077  *(((float*)Ptr)+i) = Val.AggregateVal[i].FloatVal;
1078  if (cast<VectorType>(Ty)->getElementType()->isIntegerTy()) {
1079  unsigned numOfBytes =(Val.AggregateVal[i].IntVal.getBitWidth()+7)/8;
1080  StoreIntToMemory(Val.AggregateVal[i].IntVal,
1081  (uint8_t*)Ptr + numOfBytes*i, numOfBytes);
1082  }
1083  }
1084  break;
1085  }
1086 
1087  if (sys::IsLittleEndianHost != getDataLayout().isLittleEndian())
1088  // Host and target are different endian - reverse the stored bytes.
1089  std::reverse((uint8_t*)Ptr, StoreBytes + (uint8_t*)Ptr);
1090 }
1091 
1092 /// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting
1093 /// from Src into IntVal, which is assumed to be wide enough and to hold zero.
1094 static void LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes) {
1095  assert((IntVal.getBitWidth()+7)/8 >= LoadBytes && "Integer too small!");
1096  uint8_t *Dst = reinterpret_cast<uint8_t *>(
1097  const_cast<uint64_t *>(IntVal.getRawData()));
1098 
1100  // Little-endian host - the destination must be ordered from LSB to MSB.
1101  // The source is ordered from LSB to MSB: Do a straight copy.
1102  memcpy(Dst, Src, LoadBytes);
1103  else {
1104  // Big-endian - the destination is an array of 64 bit words ordered from
1105  // LSW to MSW. Each word must be ordered from MSB to LSB. The source is
1106  // ordered from MSB to LSB: Reverse the word order, but not the bytes in
1107  // a word.
1108  while (LoadBytes > sizeof(uint64_t)) {
1109  LoadBytes -= sizeof(uint64_t);
1110  // May not be aligned so use memcpy.
1111  memcpy(Dst, Src + LoadBytes, sizeof(uint64_t));
1112  Dst += sizeof(uint64_t);
1113  }
1114 
1115  memcpy(Dst + sizeof(uint64_t) - LoadBytes, Src, LoadBytes);
1116  }
1117 }
1118 
1119 /// FIXME: document
1120 ///
1122  GenericValue *Ptr,
1123  Type *Ty) {
1124  const unsigned LoadBytes = getDataLayout().getTypeStoreSize(Ty);
1125 
1126  switch (Ty->getTypeID()) {
1127  case Type::IntegerTyID:
1128  // An APInt with all words initially zero.
1129  Result.IntVal = APInt(cast<IntegerType>(Ty)->getBitWidth(), 0);
1130  LoadIntFromMemory(Result.IntVal, (uint8_t*)Ptr, LoadBytes);
1131  break;
1132  case Type::FloatTyID:
1133  Result.FloatVal = *((float*)Ptr);
1134  break;
1135  case Type::DoubleTyID:
1136  Result.DoubleVal = *((double*)Ptr);
1137  break;
1138  case Type::PointerTyID:
1139  Result.PointerVal = *((PointerTy*)Ptr);
1140  break;
1141  case Type::X86_FP80TyID: {
1142  // This is endian dependent, but it will only work on x86 anyway.
1143  // FIXME: Will not trap if loading a signaling NaN.
1144  uint64_t y[2];
1145  memcpy(y, Ptr, 10);
1146  Result.IntVal = APInt(80, y);
1147  break;
1148  }
1149  case Type::VectorTyID: {
1150  auto *VT = cast<VectorType>(Ty);
1151  Type *ElemT = VT->getElementType();
1152  const unsigned numElems = VT->getNumElements();
1153  if (ElemT->isFloatTy()) {
1154  Result.AggregateVal.resize(numElems);
1155  for (unsigned i = 0; i < numElems; ++i)
1156  Result.AggregateVal[i].FloatVal = *((float*)Ptr+i);
1157  }
1158  if (ElemT->isDoubleTy()) {
1159  Result.AggregateVal.resize(numElems);
1160  for (unsigned i = 0; i < numElems; ++i)
1161  Result.AggregateVal[i].DoubleVal = *((double*)Ptr+i);
1162  }
1163  if (ElemT->isIntegerTy()) {
1164  GenericValue intZero;
1165  const unsigned elemBitWidth = cast<IntegerType>(ElemT)->getBitWidth();
1166  intZero.IntVal = APInt(elemBitWidth, 0);
1167  Result.AggregateVal.resize(numElems, intZero);
1168  for (unsigned i = 0; i < numElems; ++i)
1169  LoadIntFromMemory(Result.AggregateVal[i].IntVal,
1170  (uint8_t*)Ptr+((elemBitWidth+7)/8)*i, (elemBitWidth+7)/8);
1171  }
1172  break;
1173  }
1174  default:
1175  SmallString<256> Msg;
1176  raw_svector_ostream OS(Msg);
1177  OS << "Cannot load value of type " << *Ty << "!";
1178  report_fatal_error(OS.str());
1179  }
1180 }
1181 
1183  DEBUG(dbgs() << "JIT: Initializing " << Addr << " ");
1184  DEBUG(Init->dump());
1185  if (isa<UndefValue>(Init))
1186  return;
1187 
1188  if (const ConstantVector *CP = dyn_cast<ConstantVector>(Init)) {
1189  unsigned ElementSize =
1190  getDataLayout().getTypeAllocSize(CP->getType()->getElementType());
1191  for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
1192  InitializeMemory(CP->getOperand(i), (char*)Addr+i*ElementSize);
1193  return;
1194  }
1195 
1196  if (isa<ConstantAggregateZero>(Init)) {
1197  memset(Addr, 0, (size_t)getDataLayout().getTypeAllocSize(Init->getType()));
1198  return;
1199  }
1200 
1201  if (const ConstantArray *CPA = dyn_cast<ConstantArray>(Init)) {
1202  unsigned ElementSize =
1203  getDataLayout().getTypeAllocSize(CPA->getType()->getElementType());
1204  for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i)
1205  InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize);
1206  return;
1207  }
1208 
1209  if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(Init)) {
1210  const StructLayout *SL =
1211  getDataLayout().getStructLayout(cast<StructType>(CPS->getType()));
1212  for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i)
1213  InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->getElementOffset(i));
1214  return;
1215  }
1216 
1217  if (const ConstantDataSequential *CDS =
1218  dyn_cast<ConstantDataSequential>(Init)) {
1219  // CDS is already laid out in host memory order.
1220  StringRef Data = CDS->getRawDataValues();
1221  memcpy(Addr, Data.data(), Data.size());
1222  return;
1223  }
1224 
1225  if (Init->getType()->isFirstClassType()) {
1226  GenericValue Val = getConstantValue(Init);
1227  StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType());
1228  return;
1229  }
1230 
1231  DEBUG(dbgs() << "Bad Type: " << *Init->getType() << "\n");
1232  llvm_unreachable("Unknown constant type to initialize memory with!");
1233 }
1234 
1235 /// EmitGlobals - Emit all of the global variables to memory, storing their
1236 /// addresses into GlobalAddress. This must make sure to copy the contents of
1237 /// their initializers into the memory.
1239  // Loop over all of the global variables in the program, allocating the memory
1240  // to hold them. If there is more than one module, do a prepass over globals
1241  // to figure out how the different modules should link together.
1242  std::map<std::pair<std::string, Type*>,
1243  const GlobalValue*> LinkedGlobalsMap;
1244 
1245  if (Modules.size() != 1) {
1246  for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
1247  Module &M = *Modules[m];
1248  for (const auto &GV : M.globals()) {
1249  if (GV.hasLocalLinkage() || GV.isDeclaration() ||
1250  GV.hasAppendingLinkage() || !GV.hasName())
1251  continue;// Ignore external globals and globals with internal linkage.
1252 
1253  const GlobalValue *&GVEntry =
1254  LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())];
1255 
1256  // If this is the first time we've seen this global, it is the canonical
1257  // version.
1258  if (!GVEntry) {
1259  GVEntry = &GV;
1260  continue;
1261  }
1262 
1263  // If the existing global is strong, never replace it.
1264  if (GVEntry->hasExternalLinkage())
1265  continue;
1266 
1267  // Otherwise, we know it's linkonce/weak, replace it if this is a strong
1268  // symbol. FIXME is this right for common?
1269  if (GV.hasExternalLinkage() || GVEntry->hasExternalWeakLinkage())
1270  GVEntry = &GV;
1271  }
1272  }
1273  }
1274 
1275  std::vector<const GlobalValue*> NonCanonicalGlobals;
1276  for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
1277  Module &M = *Modules[m];
1278  for (const auto &GV : M.globals()) {
1279  // In the multi-module case, see what this global maps to.
1280  if (!LinkedGlobalsMap.empty()) {
1281  if (const GlobalValue *GVEntry =
1282  LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())]) {
1283  // If something else is the canonical global, ignore this one.
1284  if (GVEntry != &GV) {
1285  NonCanonicalGlobals.push_back(&GV);
1286  continue;
1287  }
1288  }
1289  }
1290 
1291  if (!GV.isDeclaration()) {
1292  addGlobalMapping(&GV, getMemoryForGV(&GV));
1293  } else {
1294  // External variable reference. Try to use the dynamic loader to
1295  // get a pointer to it.
1296  if (void *SymAddr =
1298  addGlobalMapping(&GV, SymAddr);
1299  else {
1300  report_fatal_error("Could not resolve external global address: "
1301  +GV.getName());
1302  }
1303  }
1304  }
1305 
1306  // If there are multiple modules, map the non-canonical globals to their
1307  // canonical location.
1308  if (!NonCanonicalGlobals.empty()) {
1309  for (unsigned i = 0, e = NonCanonicalGlobals.size(); i != e; ++i) {
1310  const GlobalValue *GV = NonCanonicalGlobals[i];
1311  const GlobalValue *CGV =
1312  LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())];
1313  void *Ptr = getPointerToGlobalIfAvailable(CGV);
1314  assert(Ptr && "Canonical global wasn't codegen'd!");
1315  addGlobalMapping(GV, Ptr);
1316  }
1317  }
1318 
1319  // Now that all of the globals are set up in memory, loop through them all
1320  // and initialize their contents.
1321  for (const auto &GV : M.globals()) {
1322  if (!GV.isDeclaration()) {
1323  if (!LinkedGlobalsMap.empty()) {
1324  if (const GlobalValue *GVEntry =
1325  LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())])
1326  if (GVEntry != &GV) // Not the canonical variable.
1327  continue;
1328  }
1329  EmitGlobalVariable(&GV);
1330  }
1331  }
1332  }
1333 }
1334 
1335 // EmitGlobalVariable - This method emits the specified global variable to the
1336 // address specified in GlobalAddresses, or allocates new memory if it's not
1337 // already in the map.
1339  void *GA = getPointerToGlobalIfAvailable(GV);
1340 
1341  if (!GA) {
1342  // If it's not already specified, allocate memory for the global.
1343  GA = getMemoryForGV(GV);
1344 
1345  // If we failed to allocate memory for this global, return.
1346  if (!GA) return;
1347 
1348  addGlobalMapping(GV, GA);
1349  }
1350 
1351  // Don't initialize if it's thread local, let the client do it.
1352  if (!GV->isThreadLocal())
1353  InitializeMemory(GV->getInitializer(), GA);
1354 
1355  Type *ElTy = GV->getValueType();
1356  size_t GVSize = (size_t)getDataLayout().getTypeAllocSize(ElTy);
1357  NumInitBytes += (unsigned)GVSize;
1358  ++NumGlobals;
1359 }
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double, and whose elements are just simple data values (i.e.
Definition: Constants.h:740
uint64_t CallInst * C
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:245
PointerTy PointerVal
Definition: GenericValue.h:32
std::vector< GenericValue > AggregateVal
Definition: GenericValue.h:38
static void * SearchForAddressOfSymbol(const char *symbolName)
This function will search through all previously loaded dynamic libraries for the symbol symbolName...
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM)
Definition: APFloat.h:1077
bool hasLocalLinkage() const
Definition: GlobalValue.h:435
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1542
APInt sext(unsigned width) const
Sign extend to a new width.
Definition: APInt.cpp:842
std::string getMangledName(const GlobalValue *GV)
getMangledName - Get mangled name.
void clearAllGlobalMappings()
clearAllGlobalMappings - Clear all global mappings and start over again, for use in dynamic compilati...
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:236
MutableArrayRef< T > makeMutableArrayRef(T &OneElt)
Construct a MutableArrayRef from a single element.
Definition: ArrayRef.h:503
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:115
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
static ExecutionEngine *(* MCJITCtor)(std::unique_ptr< Module > M, std::string *ErrorStr, std::shared_ptr< MCJITMemoryManager > MM, std::shared_ptr< LegacyJITSymbolResolver > SR, std::unique_ptr< TargetMachine > TM)
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:135
int runFunctionAsMain(Function *Fn, const std::vector< std::string > &argv, const char *const *envp)
runFunctionAsMain - This is a helper function which wraps runFunction to handle the common task of st...
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
virtual bool removeModule(Module *M)
removeModule - Removes a Module from the list of modules, but does not free the module&#39;s memory...
2: 32-bit floating point type
Definition: Type.h:59
APInt sdiv(const APInt &RHS) const
Signed division function for APInt.
Definition: APInt.cpp:1601
void * getPointerToGlobalIfAvailable(StringRef S)
getPointerToGlobalIfAvailable - This returns the address of the specified global value if it is has a...
sys::Mutex lock
lock - This lock protects the ExecutionEngine and MCJIT classes.
uint64_t updateGlobalMapping(const GlobalValue *GV, void *Addr)
updateGlobalMapping - Replace an existing mapping for GV with a new address.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
APInt zext(unsigned width) const
Zero extend to a new width.
Definition: APInt.cpp:866
APInt udiv(const APInt &RHS) const
Unsigned division operation.
Definition: APInt.cpp:1530
virtual GenericValue runFunction(Function *F, ArrayRef< GenericValue > ArgValues)=0
runFunction - Execute the specified function with the specified arguments, and return the result...
const GlobalVariable * getNamedGlobal(StringRef Name) const
Return the global variable in the module with the specified name, of arbitrary type.
Definition: Module.h:383
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:489
void EmitGlobalVariable(const GlobalVariable *GV)
static bool getConstantValue(SDValue N, uint32_t &Out)
APInt trunc(unsigned width) const
Truncate to new width.
Definition: APInt.cpp:819
13: Structures
Definition: Type.h:73
STATISTIC(NumFunctions, "Total number of functions")
F(f)
4: 80-bit floating point type (X87)
Definition: Type.h:61
uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew=0)
Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Alig...
Definition: MathExtras.h:677
static APFloat getZero(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Zero.
Definition: APFloat.h:855
bool hasExternalWeakLinkage() const
Definition: GlobalValue.h:436
const DataLayout & getDataLayout() const
APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
Definition: APInt.cpp:884
15: Pointers
Definition: Type.h:75
double roundToDouble(bool isSigned) const
Converts this APInt to a double value.
Definition: APInt.cpp:758
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:128
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1488
iterator_range< global_object_iterator > global_objects()
Definition: Module.h:636
opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const
Definition: APFloat.h:1069
void dump() const
Support for debugging, callable in GDB: V->dump()
Definition: AsmWriter.cpp:3648
opStatus divide(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:968
void * PointerTy
Definition: GenericValue.h:22
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
Definition: DataLayout.h:511
Definition: BitVector.h:920
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:361
virtual void runStaticConstructorsDestructors(bool isDtors)
runStaticConstructorsDestructors - This method is used to execute all of the static constructors or d...
static APInt doubleToBits(double V)
Converts a double to APInt bits.
Definition: APInt.h:1710
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:138
bool isFloatingPointTy() const
Return true if this is one of the six floating-point types.
Definition: Type.h:162
void * getPointerToGlobal(const GlobalValue *GV)
getPointerToGlobal - This returns the address of the specified global value.
void InitializeMemory(const Constant *Init, void *Addr)
Class to represent struct types.
Definition: DerivedTypes.h:201
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:197
EngineBuilder()
Default constructor for EngineBuilder.
static bool LoadLibraryPermanently(const char *Filename, std::string *ErrMsg=nullptr)
This function permanently loads the dynamic library at the given path.
uint64_t getNumElements() const
Definition: DerivedTypes.h:359
virtual void addModule(std::unique_ptr< Module > M)
Add a Module to the list of modules that we can JIT from.
All zero aggregate value.
Definition: Constants.h:337
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:267
auto reverse(ContainerTy &&C, typename std::enable_if< has_rbegin< ContainerTy >::value >::type *=nullptr) -> decltype(make_range(C.rbegin(), C.rend()))
Definition: STLExtras.h:233
bool hasExternalLinkage() const
Definition: GlobalValue.h:421
static const bool IsLittleEndianHost
Definition: Host.h:50
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:85
Class to represent function types.
Definition: DerivedTypes.h:103
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:867
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
bool isFirstClassType() const
Return true if the type is "first class", meaning it is a valid type for a Value. ...
Definition: Type.h:241
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
Definition: Constants.h:570
static void LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes)
LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting from Src into IntVal...
virtual char * getMemoryForGV(const GlobalVariable *GV)
getMemoryforGV - Allocate memory for a global variable.
void LoadValueFromMemory(GenericValue &Result, GenericValue *Ptr, Type *Ty)
FIXME: document.
static bool isTargetNullPtr(ExecutionEngine *EE, void *Loc)
isTargetNullPtr - Return whether the target pointer stored at Loc is null.
EngineBuilder & setSymbolResolver(std::unique_ptr< LegacyJITSymbolResolver > SR)
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
opStatus subtract(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:950
GenericValue getConstantValue(const Constant *C)
Converts a Constant* into a GenericValue, including handling of ConstantExpr values.
void emitGlobals()
EmitGlobals - Emit all of the global variables to memory, storing their addresses into GlobalAddress...
uint64_t RemoveMapping(StringRef Name)
Erase an entry from the mapping table.
void StoreValueToMemory(const GenericValue &Val, GenericValue *Ptr, Type *Ty)
StoreValueToMemory - Stores the data in Val of type Ty at address Ptr.
Type * getElementType() const
Return the element type of the array/vector.
Definition: Constants.cpp:2307
Value * getOperand(unsigned i) const
Definition: User.h:154
11: Arbitrary bit width integers
Definition: Type.h:71
bool isVoidTy() const
Return true if this is &#39;void&#39;.
Definition: Type.h:141
bool isFloatTy() const
Return true if this is &#39;float&#39;, a 32-bit IEEE fp type.
Definition: Type.h:147
Instances of this class acquire a given Mutex Lock when constructed and hold that lock until destruct...
Definition: MutexGuard.h:27
#define P(N)
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
APInt urem(const APInt &RHS) const
Unsigned remainder operation.
Definition: APInt.cpp:1623
bool hasName() const
Definition: Value.h:251
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:42
unsigned getPointerSize(unsigned AS=0) const
Layout pointer size FIXME: The defaults need to be removed once all of the backends/clients are updat...
Definition: DataLayout.cpp:620
This file contains the declarations for the subclasses of Constant, which represent the different fla...
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:221
void erase(iterator I)
Definition: StringMap.h:438
EngineBuilder & setMemoryManager(std::unique_ptr< MCJITMemoryManager > MM)
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:139
virtual void addObjectFile(std::unique_ptr< object::ObjectFile > O)
addObjectFile - Add an ObjectFile to the execution engine.
float getElementAsFloat(unsigned i) const
If this is an sequential container of floats, return the specified element as a float.
Definition: Constants.cpp:2669
static const Kind Either
opStatus multiply(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:959
6: 128-bit floating point type (two 64-bits, PowerPC)
Definition: Type.h:63
static const fltSemantics & x87DoubleExtended() LLVM_READNONE
Definition: APFloat.cpp:128
Constant Vector Declarations.
Definition: Constants.h:496
static void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst, unsigned StoreBytes)
StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst with the integer held in In...
const Target & getTarget() const
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:194
static UndefValue * get(Type *T)
Static factory methods - Return an &#39;undef&#39; object of the specified type.
Definition: Constants.cpp:1356
void clearGlobalMappingsFromModule(Module *M)
clearGlobalMappingsFromModule - Clear all global mappings that came from a particular module...
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:220
static ExecutionEngine *(* InterpCtor)(std::unique_ptr< Module > M, std::string *ErrorStr)
virtual Function * FindFunctionNamed(StringRef FnName)
FindFunctionNamed - Search all of the active modules to find the function that defines FnName...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Abstract interface for implementation execution of LLVM modules, designed to support both interpreter...
void * GVTOP(const GenericValue &GV)
Definition: GenericValue.h:51
unsigned getNumOperands() const
Definition: User.h:176
ExecutionEngine(DataLayout DL)
16: SIMD &#39;packed&#39; format, or other vector type
Definition: Type.h:76
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type...
Definition: Type.cpp:130
uint64_t getElementAsInteger(unsigned i) const
If this is a sequential container of integers (of any size), return the specified element in the low ...
Definition: Constants.cpp:2600
Module.h This file contains the declarations for the Module class.
bool isAggregateType() const
Return true if the type is an aggregate type.
Definition: Type.h:255
Type * getReturnType() const
Definition: DerivedTypes.h:124
StringRef str()
Return a StringRef for the vector contents.
Definition: raw_ostream.h:514
bool isDefault() const
Test if the DataLayout was constructed from an empty string.
Definition: DataLayout.h:232
void setVerifyModules(bool Verify)
Enable/Disable IR module verification.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:145
unsigned getPreferredAlignment(const GlobalVariable *GV) const
Returns the preferred alignment of the specified global.
Definition: DataLayout.cpp:801
Class to represent vector types.
Definition: DerivedTypes.h:393
virtual void addArchive(object::OwningBinary< object::Archive > A)
addArchive - Add an Archive to the execution engine.
GenericValue PTOGV(void *P)
Definition: GenericValue.h:50
Class for arbitrary precision integers.
Definition: APInt.h:69
ConstantArray - Constant Array Declarations.
Definition: Constants.h:410
static ExecutionEngine *(* OrcMCJITReplacementCtor)(std::string *ErrorStr, std::shared_ptr< MCJITMemoryManager > MM, std::shared_ptr< LegacyJITSymbolResolver > SR, std::unique_ptr< TargetMachine > TM)
opStatus mod(const APFloat &RHS)
Definition: APFloat.h:986
SmallVector< std::unique_ptr< Module >, 1 > Modules
The list of Modules that we are JIT&#39;ing from.
bool isX86_FP80Ty() const
Return true if this is x86 long double.
Definition: Type.h:153
APInt RoundFloatToAPInt(float Float, unsigned width)
Converts a float value into a APInt.
Definition: APInt.h:2145
const uint64_t * getRawData() const
This function returns a pointer to the internal storage of the APInt.
Definition: APInt.h:668
uint64_t getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:418
opStatus add(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:941
ExecutionEngine * create()
void addGlobalMapping(const GlobalValue *GV, void *Addr)
addGlobalMapping - Tell the execution engine that the specified global is at the specified location...
uint64_t getElementOffset(unsigned Idx) const
Definition: DataLayout.h:533
double getElementAsDouble(unsigned i) const
If this is an sequential container of doubles, return the specified element as a double.
Definition: Constants.cpp:2675
APInt srem(const APInt &RHS) const
Function for signed remainder operation.
Definition: APInt.cpp:1693
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:224
#define I(x, y, z)
Definition: MD5.cpp:58
uint64_t getAddressToGlobalIfAvailable(StringRef S)
getAddressToGlobalIfAvailable - This returns the address of the specified global symbol.
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
Type * getValueType() const
Definition: GlobalValue.h:275
const GlobalValue * getGlobalValueAtAddress(void *Addr)
getGlobalValueAtAddress - Return the LLVM global value object that starts at the specified address...
Builder class for ExecutionEngines.
EngineBuilder & setMCJITMemoryManager(std::unique_ptr< RTDyldMemoryManager > mcjmm)
setMCJITMemoryManager - Sets the MCJIT memory manager to use.
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:201
float bitsToFloat() const
Converts APInt bits to a double.
Definition: APInt.h:1702
3: 64-bit floating point type
Definition: Type.h:60
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
FunctionCreator LazyFunctionCreator
LazyFunctionCreator - If an unknown function is needed, this function pointer is invoked to create it...
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:115
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:565
bool hasJIT() const
hasJIT - Check if this targets supports the just-in-time compilation.
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
#define DEBUG(X)
Definition: Debug.h:118
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:59
void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const
Print the appropriate prefix and the specified global variable&#39;s name.
Definition: Mangler.cpp:109
Type * getElementType() const
Definition: DerivedTypes.h:360
bool isThreadLocal() const
If the value is "Thread Local", its value isn&#39;t shared by the threads.
Definition: GlobalValue.h:246
iterator_range< global_iterator > globals()
Definition: Module.h:561
Value handle with callbacks on RAUW and destruction.
Definition: ValueHandle.h:389
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
APInt bitcastToAPInt() const
Definition: APFloat.h:1094
unsigned getNumElements() const
Return the number of elements in the array or vector.
Definition: Constants.cpp:2330
APInt RoundDoubleToAPInt(double Double, unsigned width)
Converts the given double value into a APInt.
Definition: APInt.cpp:715
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:866
static APInt floatToBits(float V)
Converts a float to APInt bits.
Definition: APInt.h:1718
bool isDoubleTy() const
Return true if this is &#39;double&#39;, a 64-bit IEEE fp type.
Definition: Type.h:150
double bitsToDouble() const
Converts APInt bits to a double.
Definition: APInt.h:1693
double signedRoundToDouble() const
Converts this signed APInt to a double value.
Definition: APInt.h:1686
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:273
virtual GlobalVariable * FindGlobalVariableNamed(StringRef Name, bool AllowInternal=false)
FindGlobalVariableNamed - Search all of the active modules to find the global variable that defines N...
5: 128-bit floating point type (112-bit mantissa)
Definition: Type.h:62