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 /// 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  /// 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  LLVM_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  LLVM_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  LLVM_DEBUG(dbgs() << "JIT: ARGV[" << i << "] = " << (void *)Dest.get()
353  << "\n");
354 
355  std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest.get());
356  Dest[Size-1] = 0;
357 
358  // Endian safe: Array[i] = (PointerTy)Dest;
359  EE->StoreValueToMemory(PTOGV(Dest.get()),
360  (GenericValue*)(&Array[i*PtrSize]), SBytePtr);
361  Values.push_back(std::move(Dest));
362  }
363 
364  // Null terminate it
365  EE->StoreValueToMemory(PTOGV(nullptr),
366  (GenericValue*)(&Array[InputArgv.size()*PtrSize]),
367  SBytePtr);
368  return Array.get();
369 }
370 
372  bool isDtors) {
373  StringRef Name(isDtors ? "llvm.global_dtors" : "llvm.global_ctors");
374  GlobalVariable *GV = module.getNamedGlobal(Name);
375 
376  // If this global has internal linkage, or if it has a use, then it must be
377  // an old-style (llvmgcc3) static ctor with __main linked in and in use. If
378  // this is the case, don't execute any of the global ctors, __main will do
379  // it.
380  if (!GV || GV->isDeclaration() || GV->hasLocalLinkage()) return;
381 
382  // Should be an array of '{ i32, void ()* }' structs. The first value is
383  // the init priority, which we ignore.
385  if (!InitList)
386  return;
387  for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {
388  ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i));
389  if (!CS) continue;
390 
391  Constant *FP = CS->getOperand(1);
392  if (FP->isNullValue())
393  continue; // Found a sentinal value, ignore.
394 
395  // Strip off constant expression casts.
396  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP))
397  if (CE->isCast())
398  FP = CE->getOperand(0);
399 
400  // Execute the ctor/dtor function!
401  if (Function *F = dyn_cast<Function>(FP))
402  runFunction(F, None);
403 
404  // FIXME: It is marginally lame that we just do nothing here if we see an
405  // entry we don't recognize. It might not be unreasonable for the verifier
406  // to not even allow this and just assert here.
407  }
408 }
409 
411  // Execute global ctors/dtors for each module in the program.
412  for (std::unique_ptr<Module> &M : Modules)
414 }
415 
416 #ifndef NDEBUG
417 /// isTargetNullPtr - Return whether the target pointer stored at Loc is null.
418 static bool isTargetNullPtr(ExecutionEngine *EE, void *Loc) {
419  unsigned PtrSize = EE->getDataLayout().getPointerSize();
420  for (unsigned i = 0; i < PtrSize; ++i)
421  if (*(i + (uint8_t*)Loc))
422  return false;
423  return true;
424 }
425 #endif
426 
428  const std::vector<std::string> &argv,
429  const char * const * envp) {
430  std::vector<GenericValue> GVArgs;
431  GenericValue GVArgc;
432  GVArgc.IntVal = APInt(32, argv.size());
433 
434  // Check main() type
435  unsigned NumArgs = Fn->getFunctionType()->getNumParams();
436  FunctionType *FTy = Fn->getFunctionType();
437  Type* PPInt8Ty = Type::getInt8PtrTy(Fn->getContext())->getPointerTo();
438 
439  // Check the argument types.
440  if (NumArgs > 3)
441  report_fatal_error("Invalid number of arguments of main() supplied");
442  if (NumArgs >= 3 && FTy->getParamType(2) != PPInt8Ty)
443  report_fatal_error("Invalid type for third argument of main() supplied");
444  if (NumArgs >= 2 && FTy->getParamType(1) != PPInt8Ty)
445  report_fatal_error("Invalid type for second argument of main() supplied");
446  if (NumArgs >= 1 && !FTy->getParamType(0)->isIntegerTy(32))
447  report_fatal_error("Invalid type for first argument of main() supplied");
448  if (!FTy->getReturnType()->isIntegerTy() &&
449  !FTy->getReturnType()->isVoidTy())
450  report_fatal_error("Invalid return type of main() supplied");
451 
452  ArgvArray CArgv;
453  ArgvArray CEnv;
454  if (NumArgs) {
455  GVArgs.push_back(GVArgc); // Arg #0 = argc.
456  if (NumArgs > 1) {
457  // Arg #1 = argv.
458  GVArgs.push_back(PTOGV(CArgv.reset(Fn->getContext(), this, argv)));
459  assert(!isTargetNullPtr(this, GVTOP(GVArgs[1])) &&
460  "argv[0] was null after CreateArgv");
461  if (NumArgs > 2) {
462  std::vector<std::string> EnvVars;
463  for (unsigned i = 0; envp[i]; ++i)
464  EnvVars.emplace_back(envp[i]);
465  // Arg #2 = envp.
466  GVArgs.push_back(PTOGV(CEnv.reset(Fn->getContext(), this, EnvVars)));
467  }
468  }
469  }
470 
471  return runFunction(Fn, GVArgs).IntVal.getZExtValue();
472 }
473 
475 
476 EngineBuilder::EngineBuilder(std::unique_ptr<Module> M)
477  : M(std::move(M)), WhichEngine(EngineKind::Either), ErrorStr(nullptr),
478  OptLevel(CodeGenOpt::Default), MemMgr(nullptr), Resolver(nullptr),
479  UseOrcMCJITReplacement(false) {
480 // IR module verification is enabled by default in debug builds, and disabled
481 // by default in release builds.
482 #ifndef NDEBUG
483  VerifyModules = true;
484 #else
485  VerifyModules = false;
486 #endif
487 }
488 
490 
492  std::unique_ptr<RTDyldMemoryManager> mcjmm) {
493  auto SharedMM = std::shared_ptr<RTDyldMemoryManager>(std::move(mcjmm));
494  MemMgr = SharedMM;
495  Resolver = SharedMM;
496  return *this;
497 }
498 
500 EngineBuilder::setMemoryManager(std::unique_ptr<MCJITMemoryManager> MM) {
501  MemMgr = std::shared_ptr<MCJITMemoryManager>(std::move(MM));
502  return *this;
503 }
504 
506 EngineBuilder::setSymbolResolver(std::unique_ptr<LegacyJITSymbolResolver> SR) {
507  Resolver = std::shared_ptr<LegacyJITSymbolResolver>(std::move(SR));
508  return *this;
509 }
510 
512  std::unique_ptr<TargetMachine> TheTM(TM); // Take ownership.
513 
514  // Make sure we can resolve symbols in the program as well. The zero arg
515  // to the function tells DynamicLibrary to load the program, not a library.
516  if (sys::DynamicLibrary::LoadLibraryPermanently(nullptr, ErrorStr))
517  return nullptr;
518 
519  // If the user specified a memory manager but didn't specify which engine to
520  // create, we assume they only want the JIT, and we fail if they only want
521  // the interpreter.
522  if (MemMgr) {
523  if (WhichEngine & EngineKind::JIT)
524  WhichEngine = EngineKind::JIT;
525  else {
526  if (ErrorStr)
527  *ErrorStr = "Cannot create an interpreter with a memory manager.";
528  return nullptr;
529  }
530  }
531 
532  // Unless the interpreter was explicitly selected or the JIT is not linked,
533  // try making a JIT.
534  if ((WhichEngine & EngineKind::JIT) && TheTM) {
535  if (!TM->getTarget().hasJIT()) {
536  errs() << "WARNING: This target JIT is not designed for the host"
537  << " you are running. If bad things happen, please choose"
538  << " a different -march switch.\n";
539  }
540 
541  ExecutionEngine *EE = nullptr;
542  if (ExecutionEngine::OrcMCJITReplacementCtor && UseOrcMCJITReplacement) {
543  EE = ExecutionEngine::OrcMCJITReplacementCtor(ErrorStr, std::move(MemMgr),
544  std::move(Resolver),
545  std::move(TheTM));
546  EE->addModule(std::move(M));
547  } else if (ExecutionEngine::MCJITCtor)
548  EE = ExecutionEngine::MCJITCtor(std::move(M), ErrorStr, std::move(MemMgr),
549  std::move(Resolver), std::move(TheTM));
550 
551  if (EE) {
552  EE->setVerifyModules(VerifyModules);
553  return EE;
554  }
555  }
556 
557  // If we can't make a JIT and we didn't request one specifically, try making
558  // an interpreter instead.
559  if (WhichEngine & EngineKind::Interpreter) {
561  return ExecutionEngine::InterpCtor(std::move(M), ErrorStr);
562  if (ErrorStr)
563  *ErrorStr = "Interpreter has not been linked in.";
564  return nullptr;
565  }
566 
567  if ((WhichEngine & EngineKind::JIT) && !ExecutionEngine::MCJITCtor) {
568  if (ErrorStr)
569  *ErrorStr = "JIT has not been linked in.";
570  }
571 
572  return nullptr;
573 }
574 
576  if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV)))
577  return getPointerToFunction(F);
578 
579  MutexGuard locked(lock);
580  if (void* P = getPointerToGlobalIfAvailable(GV))
581  return P;
582 
583  // Global variable might have been added since interpreter started.
584  if (GlobalVariable *GVar =
585  const_cast<GlobalVariable *>(dyn_cast<GlobalVariable>(GV)))
586  EmitGlobalVariable(GVar);
587  else
588  llvm_unreachable("Global hasn't had an address allocated yet!");
589 
590  return getPointerToGlobalIfAvailable(GV);
591 }
592 
593 /// Converts a Constant* into a GenericValue, including handling of
594 /// ConstantExpr values.
596  // If its undefined, return the garbage.
597  if (isa<UndefValue>(C)) {
598  GenericValue Result;
599  switch (C->getType()->getTypeID()) {
600  default:
601  break;
602  case Type::IntegerTyID:
603  case Type::X86_FP80TyID:
604  case Type::FP128TyID:
605  case Type::PPC_FP128TyID:
606  // Although the value is undefined, we still have to construct an APInt
607  // with the correct bit width.
608  Result.IntVal = APInt(C->getType()->getPrimitiveSizeInBits(), 0);
609  break;
610  case Type::StructTyID: {
611  // if the whole struct is 'undef' just reserve memory for the value.
612  if(StructType *STy = dyn_cast<StructType>(C->getType())) {
613  unsigned int elemNum = STy->getNumElements();
614  Result.AggregateVal.resize(elemNum);
615  for (unsigned int i = 0; i < elemNum; ++i) {
616  Type *ElemTy = STy->getElementType(i);
617  if (ElemTy->isIntegerTy())
618  Result.AggregateVal[i].IntVal =
619  APInt(ElemTy->getPrimitiveSizeInBits(), 0);
620  else if (ElemTy->isAggregateType()) {
621  const Constant *ElemUndef = UndefValue::get(ElemTy);
622  Result.AggregateVal[i] = getConstantValue(ElemUndef);
623  }
624  }
625  }
626  }
627  break;
628  case Type::VectorTyID:
629  // if the whole vector is 'undef' just reserve memory for the value.
630  auto* VTy = dyn_cast<VectorType>(C->getType());
631  Type *ElemTy = VTy->getElementType();
632  unsigned int elemNum = VTy->getNumElements();
633  Result.AggregateVal.resize(elemNum);
634  if (ElemTy->isIntegerTy())
635  for (unsigned int i = 0; i < elemNum; ++i)
636  Result.AggregateVal[i].IntVal =
637  APInt(ElemTy->getPrimitiveSizeInBits(), 0);
638  break;
639  }
640  return Result;
641  }
642 
643  // Otherwise, if the value is a ConstantExpr...
644  if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
645  Constant *Op0 = CE->getOperand(0);
646  switch (CE->getOpcode()) {
647  case Instruction::GetElementPtr: {
648  // Compute the index
649  GenericValue Result = getConstantValue(Op0);
650  APInt Offset(DL.getPointerSizeInBits(), 0);
651  cast<GEPOperator>(CE)->accumulateConstantOffset(DL, Offset);
652 
653  char* tmp = (char*) Result.PointerVal;
654  Result = PTOGV(tmp + Offset.getSExtValue());
655  return Result;
656  }
657  case Instruction::Trunc: {
658  GenericValue GV = getConstantValue(Op0);
659  uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
660  GV.IntVal = GV.IntVal.trunc(BitWidth);
661  return GV;
662  }
663  case Instruction::ZExt: {
664  GenericValue GV = getConstantValue(Op0);
665  uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
666  GV.IntVal = GV.IntVal.zext(BitWidth);
667  return GV;
668  }
669  case Instruction::SExt: {
670  GenericValue GV = getConstantValue(Op0);
671  uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
672  GV.IntVal = GV.IntVal.sext(BitWidth);
673  return GV;
674  }
675  case Instruction::FPTrunc: {
676  // FIXME long double
677  GenericValue GV = getConstantValue(Op0);
678  GV.FloatVal = float(GV.DoubleVal);
679  return GV;
680  }
681  case Instruction::FPExt:{
682  // FIXME long double
683  GenericValue GV = getConstantValue(Op0);
684  GV.DoubleVal = double(GV.FloatVal);
685  return GV;
686  }
687  case Instruction::UIToFP: {
688  GenericValue GV = getConstantValue(Op0);
689  if (CE->getType()->isFloatTy())
690  GV.FloatVal = float(GV.IntVal.roundToDouble());
691  else if (CE->getType()->isDoubleTy())
692  GV.DoubleVal = GV.IntVal.roundToDouble();
693  else if (CE->getType()->isX86_FP80Ty()) {
695  (void)apf.convertFromAPInt(GV.IntVal,
696  false,
698  GV.IntVal = apf.bitcastToAPInt();
699  }
700  return GV;
701  }
702  case Instruction::SIToFP: {
703  GenericValue GV = getConstantValue(Op0);
704  if (CE->getType()->isFloatTy())
705  GV.FloatVal = float(GV.IntVal.signedRoundToDouble());
706  else if (CE->getType()->isDoubleTy())
708  else if (CE->getType()->isX86_FP80Ty()) {
710  (void)apf.convertFromAPInt(GV.IntVal,
711  true,
713  GV.IntVal = apf.bitcastToAPInt();
714  }
715  return GV;
716  }
717  case Instruction::FPToUI: // double->APInt conversion handles sign
718  case Instruction::FPToSI: {
719  GenericValue GV = getConstantValue(Op0);
720  uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
721  if (Op0->getType()->isFloatTy())
722  GV.IntVal = APIntOps::RoundFloatToAPInt(GV.FloatVal, BitWidth);
723  else if (Op0->getType()->isDoubleTy())
724  GV.IntVal = APIntOps::RoundDoubleToAPInt(GV.DoubleVal, BitWidth);
725  else if (Op0->getType()->isX86_FP80Ty()) {
727  uint64_t v;
728  bool ignored;
729  (void)apf.convertToInteger(makeMutableArrayRef(v), BitWidth,
730  CE->getOpcode()==Instruction::FPToSI,
731  APFloat::rmTowardZero, &ignored);
732  GV.IntVal = v; // endian?
733  }
734  return GV;
735  }
736  case Instruction::PtrToInt: {
737  GenericValue GV = getConstantValue(Op0);
738  uint32_t PtrWidth = DL.getTypeSizeInBits(Op0->getType());
739  assert(PtrWidth <= 64 && "Bad pointer width");
740  GV.IntVal = APInt(PtrWidth, uintptr_t(GV.PointerVal));
741  uint32_t IntWidth = DL.getTypeSizeInBits(CE->getType());
742  GV.IntVal = GV.IntVal.zextOrTrunc(IntWidth);
743  return GV;
744  }
745  case Instruction::IntToPtr: {
746  GenericValue GV = getConstantValue(Op0);
747  uint32_t PtrWidth = DL.getTypeSizeInBits(CE->getType());
748  GV.IntVal = GV.IntVal.zextOrTrunc(PtrWidth);
749  assert(GV.IntVal.getBitWidth() <= 64 && "Bad pointer width");
750  GV.PointerVal = PointerTy(uintptr_t(GV.IntVal.getZExtValue()));
751  return GV;
752  }
753  case Instruction::BitCast: {
754  GenericValue GV = getConstantValue(Op0);
755  Type* DestTy = CE->getType();
756  switch (Op0->getType()->getTypeID()) {
757  default: llvm_unreachable("Invalid bitcast operand");
758  case Type::IntegerTyID:
759  assert(DestTy->isFloatingPointTy() && "invalid bitcast");
760  if (DestTy->isFloatTy())
761  GV.FloatVal = GV.IntVal.bitsToFloat();
762  else if (DestTy->isDoubleTy())
763  GV.DoubleVal = GV.IntVal.bitsToDouble();
764  break;
765  case Type::FloatTyID:
766  assert(DestTy->isIntegerTy(32) && "Invalid bitcast");
768  break;
769  case Type::DoubleTyID:
770  assert(DestTy->isIntegerTy(64) && "Invalid bitcast");
772  break;
773  case Type::PointerTyID:
774  assert(DestTy->isPointerTy() && "Invalid bitcast");
775  break; // getConstantValue(Op0) above already converted it
776  }
777  return GV;
778  }
779  case Instruction::Add:
780  case Instruction::FAdd:
781  case Instruction::Sub:
782  case Instruction::FSub:
783  case Instruction::Mul:
784  case Instruction::FMul:
785  case Instruction::UDiv:
786  case Instruction::SDiv:
787  case Instruction::URem:
788  case Instruction::SRem:
789  case Instruction::And:
790  case Instruction::Or:
791  case Instruction::Xor: {
792  GenericValue LHS = getConstantValue(Op0);
793  GenericValue RHS = getConstantValue(CE->getOperand(1));
794  GenericValue GV;
795  switch (CE->getOperand(0)->getType()->getTypeID()) {
796  default: llvm_unreachable("Bad add type!");
797  case Type::IntegerTyID:
798  switch (CE->getOpcode()) {
799  default: llvm_unreachable("Invalid integer opcode");
800  case Instruction::Add: GV.IntVal = LHS.IntVal + RHS.IntVal; break;
801  case Instruction::Sub: GV.IntVal = LHS.IntVal - RHS.IntVal; break;
802  case Instruction::Mul: GV.IntVal = LHS.IntVal * RHS.IntVal; break;
803  case Instruction::UDiv:GV.IntVal = LHS.IntVal.udiv(RHS.IntVal); break;
804  case Instruction::SDiv:GV.IntVal = LHS.IntVal.sdiv(RHS.IntVal); break;
805  case Instruction::URem:GV.IntVal = LHS.IntVal.urem(RHS.IntVal); break;
806  case Instruction::SRem:GV.IntVal = LHS.IntVal.srem(RHS.IntVal); break;
807  case Instruction::And: GV.IntVal = LHS.IntVal & RHS.IntVal; break;
808  case Instruction::Or: GV.IntVal = LHS.IntVal | RHS.IntVal; break;
809  case Instruction::Xor: GV.IntVal = LHS.IntVal ^ RHS.IntVal; break;
810  }
811  break;
812  case Type::FloatTyID:
813  switch (CE->getOpcode()) {
814  default: llvm_unreachable("Invalid float opcode");
815  case Instruction::FAdd:
816  GV.FloatVal = LHS.FloatVal + RHS.FloatVal; break;
817  case Instruction::FSub:
818  GV.FloatVal = LHS.FloatVal - RHS.FloatVal; break;
819  case Instruction::FMul:
820  GV.FloatVal = LHS.FloatVal * RHS.FloatVal; break;
821  case Instruction::FDiv:
822  GV.FloatVal = LHS.FloatVal / RHS.FloatVal; break;
823  case Instruction::FRem:
824  GV.FloatVal = std::fmod(LHS.FloatVal,RHS.FloatVal); break;
825  }
826  break;
827  case Type::DoubleTyID:
828  switch (CE->getOpcode()) {
829  default: llvm_unreachable("Invalid double opcode");
830  case Instruction::FAdd:
831  GV.DoubleVal = LHS.DoubleVal + RHS.DoubleVal; break;
832  case Instruction::FSub:
833  GV.DoubleVal = LHS.DoubleVal - RHS.DoubleVal; break;
834  case Instruction::FMul:
835  GV.DoubleVal = LHS.DoubleVal * RHS.DoubleVal; break;
836  case Instruction::FDiv:
837  GV.DoubleVal = LHS.DoubleVal / RHS.DoubleVal; break;
838  case Instruction::FRem:
839  GV.DoubleVal = std::fmod(LHS.DoubleVal,RHS.DoubleVal); break;
840  }
841  break;
842  case Type::X86_FP80TyID:
843  case Type::PPC_FP128TyID:
844  case Type::FP128TyID: {
845  const fltSemantics &Sem = CE->getOperand(0)->getType()->getFltSemantics();
846  APFloat apfLHS = APFloat(Sem, LHS.IntVal);
847  switch (CE->getOpcode()) {
848  default: llvm_unreachable("Invalid long double opcode");
849  case Instruction::FAdd:
850  apfLHS.add(APFloat(Sem, RHS.IntVal), APFloat::rmNearestTiesToEven);
851  GV.IntVal = apfLHS.bitcastToAPInt();
852  break;
853  case Instruction::FSub:
854  apfLHS.subtract(APFloat(Sem, RHS.IntVal),
856  GV.IntVal = apfLHS.bitcastToAPInt();
857  break;
858  case Instruction::FMul:
859  apfLHS.multiply(APFloat(Sem, RHS.IntVal),
861  GV.IntVal = apfLHS.bitcastToAPInt();
862  break;
863  case Instruction::FDiv:
864  apfLHS.divide(APFloat(Sem, RHS.IntVal),
866  GV.IntVal = apfLHS.bitcastToAPInt();
867  break;
868  case Instruction::FRem:
869  apfLHS.mod(APFloat(Sem, RHS.IntVal));
870  GV.IntVal = apfLHS.bitcastToAPInt();
871  break;
872  }
873  }
874  break;
875  }
876  return GV;
877  }
878  default:
879  break;
880  }
881 
882  SmallString<256> Msg;
883  raw_svector_ostream OS(Msg);
884  OS << "ConstantExpr not handled: " << *CE;
885  report_fatal_error(OS.str());
886  }
887 
888  // Otherwise, we have a simple constant.
889  GenericValue Result;
890  switch (C->getType()->getTypeID()) {
891  case Type::FloatTyID:
892  Result.FloatVal = cast<ConstantFP>(C)->getValueAPF().convertToFloat();
893  break;
894  case Type::DoubleTyID:
895  Result.DoubleVal = cast<ConstantFP>(C)->getValueAPF().convertToDouble();
896  break;
897  case Type::X86_FP80TyID:
898  case Type::FP128TyID:
899  case Type::PPC_FP128TyID:
900  Result.IntVal = cast <ConstantFP>(C)->getValueAPF().bitcastToAPInt();
901  break;
902  case Type::IntegerTyID:
903  Result.IntVal = cast<ConstantInt>(C)->getValue();
904  break;
905  case Type::PointerTyID:
906  while (auto *A = dyn_cast<GlobalAlias>(C)) {
907  C = A->getAliasee();
908  }
909  if (isa<ConstantPointerNull>(C))
910  Result.PointerVal = nullptr;
911  else if (const Function *F = dyn_cast<Function>(C))
912  Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F)));
913  else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C))
914  Result = PTOGV(getOrEmitGlobalVariable(const_cast<GlobalVariable*>(GV)));
915  else
916  llvm_unreachable("Unknown constant pointer type!");
917  break;
918  case Type::VectorTyID: {
919  unsigned elemNum;
920  Type* ElemTy;
922  const ConstantVector *CV = dyn_cast<ConstantVector>(C);
924 
925  if (CDV) {
926  elemNum = CDV->getNumElements();
927  ElemTy = CDV->getElementType();
928  } else if (CV || CAZ) {
929  VectorType* VTy = dyn_cast<VectorType>(C->getType());
930  elemNum = VTy->getNumElements();
931  ElemTy = VTy->getElementType();
932  } else {
933  llvm_unreachable("Unknown constant vector type!");
934  }
935 
936  Result.AggregateVal.resize(elemNum);
937  // Check if vector holds floats.
938  if(ElemTy->isFloatTy()) {
939  if (CAZ) {
940  GenericValue floatZero;
941  floatZero.FloatVal = 0.f;
942  std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
943  floatZero);
944  break;
945  }
946  if(CV) {
947  for (unsigned i = 0; i < elemNum; ++i)
948  if (!isa<UndefValue>(CV->getOperand(i)))
949  Result.AggregateVal[i].FloatVal = cast<ConstantFP>(
950  CV->getOperand(i))->getValueAPF().convertToFloat();
951  break;
952  }
953  if(CDV)
954  for (unsigned i = 0; i < elemNum; ++i)
955  Result.AggregateVal[i].FloatVal = CDV->getElementAsFloat(i);
956 
957  break;
958  }
959  // Check if vector holds doubles.
960  if (ElemTy->isDoubleTy()) {
961  if (CAZ) {
962  GenericValue doubleZero;
963  doubleZero.DoubleVal = 0.0;
964  std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
965  doubleZero);
966  break;
967  }
968  if(CV) {
969  for (unsigned i = 0; i < elemNum; ++i)
970  if (!isa<UndefValue>(CV->getOperand(i)))
971  Result.AggregateVal[i].DoubleVal = cast<ConstantFP>(
972  CV->getOperand(i))->getValueAPF().convertToDouble();
973  break;
974  }
975  if(CDV)
976  for (unsigned i = 0; i < elemNum; ++i)
977  Result.AggregateVal[i].DoubleVal = CDV->getElementAsDouble(i);
978 
979  break;
980  }
981  // Check if vector holds integers.
982  if (ElemTy->isIntegerTy()) {
983  if (CAZ) {
984  GenericValue intZero;
985  intZero.IntVal = APInt(ElemTy->getScalarSizeInBits(), 0ull);
986  std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
987  intZero);
988  break;
989  }
990  if(CV) {
991  for (unsigned i = 0; i < elemNum; ++i)
992  if (!isa<UndefValue>(CV->getOperand(i)))
993  Result.AggregateVal[i].IntVal = cast<ConstantInt>(
994  CV->getOperand(i))->getValue();
995  else {
996  Result.AggregateVal[i].IntVal =
997  APInt(CV->getOperand(i)->getType()->getPrimitiveSizeInBits(), 0);
998  }
999  break;
1000  }
1001  if(CDV)
1002  for (unsigned i = 0; i < elemNum; ++i)
1003  Result.AggregateVal[i].IntVal = APInt(
1005  CDV->getElementAsInteger(i));
1006 
1007  break;
1008  }
1009  llvm_unreachable("Unknown constant pointer type!");
1010  }
1011  break;
1012 
1013  default:
1014  SmallString<256> Msg;
1015  raw_svector_ostream OS(Msg);
1016  OS << "ERROR: Constant unimplemented for type: " << *C->getType();
1017  report_fatal_error(OS.str());
1018  }
1019 
1020  return Result;
1021 }
1022 
1023 /// StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst
1024 /// with the integer held in IntVal.
1025 static void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst,
1026  unsigned StoreBytes) {
1027  assert((IntVal.getBitWidth()+7)/8 >= StoreBytes && "Integer too small!");
1028  const uint8_t *Src = (const uint8_t *)IntVal.getRawData();
1029 
1031  // Little-endian host - the source is ordered from LSB to MSB. Order the
1032  // destination from LSB to MSB: Do a straight copy.
1033  memcpy(Dst, Src, StoreBytes);
1034  } else {
1035  // Big-endian host - the source is an array of 64 bit words ordered from
1036  // LSW to MSW. Each word is ordered from MSB to LSB. Order the destination
1037  // from MSB to LSB: Reverse the word order, but not the bytes in a word.
1038  while (StoreBytes > sizeof(uint64_t)) {
1039  StoreBytes -= sizeof(uint64_t);
1040  // May not be aligned so use memcpy.
1041  memcpy(Dst + StoreBytes, Src, sizeof(uint64_t));
1042  Src += sizeof(uint64_t);
1043  }
1044 
1045  memcpy(Dst, Src + sizeof(uint64_t) - StoreBytes, StoreBytes);
1046  }
1047 }
1048 
1050  GenericValue *Ptr, Type *Ty) {
1051  const unsigned StoreBytes = getDataLayout().getTypeStoreSize(Ty);
1052 
1053  switch (Ty->getTypeID()) {
1054  default:
1055  dbgs() << "Cannot store value of type " << *Ty << "!\n";
1056  break;
1057  case Type::IntegerTyID:
1058  StoreIntToMemory(Val.IntVal, (uint8_t*)Ptr, StoreBytes);
1059  break;
1060  case Type::FloatTyID:
1061  *((float*)Ptr) = Val.FloatVal;
1062  break;
1063  case Type::DoubleTyID:
1064  *((double*)Ptr) = Val.DoubleVal;
1065  break;
1066  case Type::X86_FP80TyID:
1067  memcpy(Ptr, Val.IntVal.getRawData(), 10);
1068  break;
1069  case Type::PointerTyID:
1070  // Ensure 64 bit target pointers are fully initialized on 32 bit hosts.
1071  if (StoreBytes != sizeof(PointerTy))
1072  memset(&(Ptr->PointerVal), 0, StoreBytes);
1073 
1074  *((PointerTy*)Ptr) = Val.PointerVal;
1075  break;
1076  case Type::VectorTyID:
1077  for (unsigned i = 0; i < Val.AggregateVal.size(); ++i) {
1078  if (cast<VectorType>(Ty)->getElementType()->isDoubleTy())
1079  *(((double*)Ptr)+i) = Val.AggregateVal[i].DoubleVal;
1080  if (cast<VectorType>(Ty)->getElementType()->isFloatTy())
1081  *(((float*)Ptr)+i) = Val.AggregateVal[i].FloatVal;
1082  if (cast<VectorType>(Ty)->getElementType()->isIntegerTy()) {
1083  unsigned numOfBytes =(Val.AggregateVal[i].IntVal.getBitWidth()+7)/8;
1084  StoreIntToMemory(Val.AggregateVal[i].IntVal,
1085  (uint8_t*)Ptr + numOfBytes*i, numOfBytes);
1086  }
1087  }
1088  break;
1089  }
1090 
1091  if (sys::IsLittleEndianHost != getDataLayout().isLittleEndian())
1092  // Host and target are different endian - reverse the stored bytes.
1093  std::reverse((uint8_t*)Ptr, StoreBytes + (uint8_t*)Ptr);
1094 }
1095 
1096 /// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting
1097 /// from Src into IntVal, which is assumed to be wide enough and to hold zero.
1098 static void LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes) {
1099  assert((IntVal.getBitWidth()+7)/8 >= LoadBytes && "Integer too small!");
1100  uint8_t *Dst = reinterpret_cast<uint8_t *>(
1101  const_cast<uint64_t *>(IntVal.getRawData()));
1102 
1104  // Little-endian host - the destination must be ordered from LSB to MSB.
1105  // The source is ordered from LSB to MSB: Do a straight copy.
1106  memcpy(Dst, Src, LoadBytes);
1107  else {
1108  // Big-endian - the destination is an array of 64 bit words ordered from
1109  // LSW to MSW. Each word must be ordered from MSB to LSB. The source is
1110  // ordered from MSB to LSB: Reverse the word order, but not the bytes in
1111  // a word.
1112  while (LoadBytes > sizeof(uint64_t)) {
1113  LoadBytes -= sizeof(uint64_t);
1114  // May not be aligned so use memcpy.
1115  memcpy(Dst, Src + LoadBytes, sizeof(uint64_t));
1116  Dst += sizeof(uint64_t);
1117  }
1118 
1119  memcpy(Dst + sizeof(uint64_t) - LoadBytes, Src, LoadBytes);
1120  }
1121 }
1122 
1123 /// FIXME: document
1124 ///
1126  GenericValue *Ptr,
1127  Type *Ty) {
1128  const unsigned LoadBytes = getDataLayout().getTypeStoreSize(Ty);
1129 
1130  switch (Ty->getTypeID()) {
1131  case Type::IntegerTyID:
1132  // An APInt with all words initially zero.
1133  Result.IntVal = APInt(cast<IntegerType>(Ty)->getBitWidth(), 0);
1134  LoadIntFromMemory(Result.IntVal, (uint8_t*)Ptr, LoadBytes);
1135  break;
1136  case Type::FloatTyID:
1137  Result.FloatVal = *((float*)Ptr);
1138  break;
1139  case Type::DoubleTyID:
1140  Result.DoubleVal = *((double*)Ptr);
1141  break;
1142  case Type::PointerTyID:
1143  Result.PointerVal = *((PointerTy*)Ptr);
1144  break;
1145  case Type::X86_FP80TyID: {
1146  // This is endian dependent, but it will only work on x86 anyway.
1147  // FIXME: Will not trap if loading a signaling NaN.
1148  uint64_t y[2];
1149  memcpy(y, Ptr, 10);
1150  Result.IntVal = APInt(80, y);
1151  break;
1152  }
1153  case Type::VectorTyID: {
1154  auto *VT = cast<VectorType>(Ty);
1155  Type *ElemT = VT->getElementType();
1156  const unsigned numElems = VT->getNumElements();
1157  if (ElemT->isFloatTy()) {
1158  Result.AggregateVal.resize(numElems);
1159  for (unsigned i = 0; i < numElems; ++i)
1160  Result.AggregateVal[i].FloatVal = *((float*)Ptr+i);
1161  }
1162  if (ElemT->isDoubleTy()) {
1163  Result.AggregateVal.resize(numElems);
1164  for (unsigned i = 0; i < numElems; ++i)
1165  Result.AggregateVal[i].DoubleVal = *((double*)Ptr+i);
1166  }
1167  if (ElemT->isIntegerTy()) {
1168  GenericValue intZero;
1169  const unsigned elemBitWidth = cast<IntegerType>(ElemT)->getBitWidth();
1170  intZero.IntVal = APInt(elemBitWidth, 0);
1171  Result.AggregateVal.resize(numElems, intZero);
1172  for (unsigned i = 0; i < numElems; ++i)
1173  LoadIntFromMemory(Result.AggregateVal[i].IntVal,
1174  (uint8_t*)Ptr+((elemBitWidth+7)/8)*i, (elemBitWidth+7)/8);
1175  }
1176  break;
1177  }
1178  default:
1179  SmallString<256> Msg;
1180  raw_svector_ostream OS(Msg);
1181  OS << "Cannot load value of type " << *Ty << "!";
1182  report_fatal_error(OS.str());
1183  }
1184 }
1185 
1187  LLVM_DEBUG(dbgs() << "JIT: Initializing " << Addr << " ");
1188  LLVM_DEBUG(Init->dump());
1189  if (isa<UndefValue>(Init))
1190  return;
1191 
1192  if (const ConstantVector *CP = dyn_cast<ConstantVector>(Init)) {
1193  unsigned ElementSize =
1194  getDataLayout().getTypeAllocSize(CP->getType()->getElementType());
1195  for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
1196  InitializeMemory(CP->getOperand(i), (char*)Addr+i*ElementSize);
1197  return;
1198  }
1199 
1200  if (isa<ConstantAggregateZero>(Init)) {
1201  memset(Addr, 0, (size_t)getDataLayout().getTypeAllocSize(Init->getType()));
1202  return;
1203  }
1204 
1205  if (const ConstantArray *CPA = dyn_cast<ConstantArray>(Init)) {
1206  unsigned ElementSize =
1207  getDataLayout().getTypeAllocSize(CPA->getType()->getElementType());
1208  for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i)
1209  InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize);
1210  return;
1211  }
1212 
1213  if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(Init)) {
1214  const StructLayout *SL =
1215  getDataLayout().getStructLayout(cast<StructType>(CPS->getType()));
1216  for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i)
1217  InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->getElementOffset(i));
1218  return;
1219  }
1220 
1221  if (const ConstantDataSequential *CDS =
1222  dyn_cast<ConstantDataSequential>(Init)) {
1223  // CDS is already laid out in host memory order.
1224  StringRef Data = CDS->getRawDataValues();
1225  memcpy(Addr, Data.data(), Data.size());
1226  return;
1227  }
1228 
1229  if (Init->getType()->isFirstClassType()) {
1230  GenericValue Val = getConstantValue(Init);
1231  StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType());
1232  return;
1233  }
1234 
1235  LLVM_DEBUG(dbgs() << "Bad Type: " << *Init->getType() << "\n");
1236  llvm_unreachable("Unknown constant type to initialize memory with!");
1237 }
1238 
1239 /// EmitGlobals - Emit all of the global variables to memory, storing their
1240 /// addresses into GlobalAddress. This must make sure to copy the contents of
1241 /// their initializers into the memory.
1243  // Loop over all of the global variables in the program, allocating the memory
1244  // to hold them. If there is more than one module, do a prepass over globals
1245  // to figure out how the different modules should link together.
1246  std::map<std::pair<std::string, Type*>,
1247  const GlobalValue*> LinkedGlobalsMap;
1248 
1249  if (Modules.size() != 1) {
1250  for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
1251  Module &M = *Modules[m];
1252  for (const auto &GV : M.globals()) {
1253  if (GV.hasLocalLinkage() || GV.isDeclaration() ||
1254  GV.hasAppendingLinkage() || !GV.hasName())
1255  continue;// Ignore external globals and globals with internal linkage.
1256 
1257  const GlobalValue *&GVEntry =
1258  LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())];
1259 
1260  // If this is the first time we've seen this global, it is the canonical
1261  // version.
1262  if (!GVEntry) {
1263  GVEntry = &GV;
1264  continue;
1265  }
1266 
1267  // If the existing global is strong, never replace it.
1268  if (GVEntry->hasExternalLinkage())
1269  continue;
1270 
1271  // Otherwise, we know it's linkonce/weak, replace it if this is a strong
1272  // symbol. FIXME is this right for common?
1273  if (GV.hasExternalLinkage() || GVEntry->hasExternalWeakLinkage())
1274  GVEntry = &GV;
1275  }
1276  }
1277  }
1278 
1279  std::vector<const GlobalValue*> NonCanonicalGlobals;
1280  for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
1281  Module &M = *Modules[m];
1282  for (const auto &GV : M.globals()) {
1283  // In the multi-module case, see what this global maps to.
1284  if (!LinkedGlobalsMap.empty()) {
1285  if (const GlobalValue *GVEntry =
1286  LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())]) {
1287  // If something else is the canonical global, ignore this one.
1288  if (GVEntry != &GV) {
1289  NonCanonicalGlobals.push_back(&GV);
1290  continue;
1291  }
1292  }
1293  }
1294 
1295  if (!GV.isDeclaration()) {
1296  addGlobalMapping(&GV, getMemoryForGV(&GV));
1297  } else {
1298  // External variable reference. Try to use the dynamic loader to
1299  // get a pointer to it.
1300  if (void *SymAddr =
1302  addGlobalMapping(&GV, SymAddr);
1303  else {
1304  report_fatal_error("Could not resolve external global address: "
1305  +GV.getName());
1306  }
1307  }
1308  }
1309 
1310  // If there are multiple modules, map the non-canonical globals to their
1311  // canonical location.
1312  if (!NonCanonicalGlobals.empty()) {
1313  for (unsigned i = 0, e = NonCanonicalGlobals.size(); i != e; ++i) {
1314  const GlobalValue *GV = NonCanonicalGlobals[i];
1315  const GlobalValue *CGV =
1316  LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())];
1317  void *Ptr = getPointerToGlobalIfAvailable(CGV);
1318  assert(Ptr && "Canonical global wasn't codegen'd!");
1319  addGlobalMapping(GV, Ptr);
1320  }
1321  }
1322 
1323  // Now that all of the globals are set up in memory, loop through them all
1324  // and initialize their contents.
1325  for (const auto &GV : M.globals()) {
1326  if (!GV.isDeclaration()) {
1327  if (!LinkedGlobalsMap.empty()) {
1328  if (const GlobalValue *GVEntry =
1329  LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())])
1330  if (GVEntry != &GV) // Not the canonical variable.
1331  continue;
1332  }
1333  EmitGlobalVariable(&GV);
1334  }
1335  }
1336  }
1337 }
1338 
1339 // EmitGlobalVariable - This method emits the specified global variable to the
1340 // address specified in GlobalAddresses, or allocates new memory if it's not
1341 // already in the map.
1343  void *GA = getPointerToGlobalIfAvailable(GV);
1344 
1345  if (!GA) {
1346  // If it's not already specified, allocate memory for the global.
1347  GA = getMemoryForGV(GV);
1348 
1349  // If we failed to allocate memory for this global, return.
1350  if (!GA) return;
1351 
1352  addGlobalMapping(GV, GA);
1353  }
1354 
1355  // Don't initialize if it's thread local, let the client do it.
1356  if (!GV->isThreadLocal())
1357  InitializeMemory(GV->getInitializer(), GA);
1358 
1359  Type *ElTy = GV->getValueType();
1360  size_t GVSize = (size_t)getDataLayout().getTypeAllocSize(ElTy);
1361  NumInitBytes += (unsigned)GVSize;
1362  ++NumGlobals;
1363 }
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:748
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:250
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:1547
APInt sext(unsigned width) const
Sign extend to a new width.
Definition: APInt.cpp:840
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:241
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:864
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:388
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:504
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:817
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:882
15: Pointers
Definition: Type.h:75
double roundToDouble(bool isSigned) const
Converts this APInt to a double value.
Definition: APInt.cpp:756
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:1493
iterator_range< global_object_iterator > global_objects()
Definition: Module.h:641
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:4185
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:521
Definition: BitVector.h:921
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:1715
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:237
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:875
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:2333
Value * getOperand(unsigned i) const
Definition: User.h:170
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:629
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:436
EngineBuilder & setMemoryManager(std::unique_ptr< MCJITMemoryManager > MM)
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:1790
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:2661
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:129
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:193
static UndefValue * get(Type *T)
Static factory methods - Return an &#39;undef&#39; object of the specified type.
Definition: Constants.cpp:1382
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:192
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:2592
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:529
bool isDefault() const
Test if the DataLayout was constructed from an empty string.
Definition: DataLayout.h:234
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:133
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:150
unsigned getPreferredAlignment(const GlobalVariable *GV) const
Returns the preferred alignment of the specified global.
Definition: DataLayout.cpp:810
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:2150
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:428
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:543
double getElementAsDouble(unsigned i) const
If this is an sequential container of doubles, return the specified element as a double.
Definition: Constants.cpp:2667
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:1707
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.
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:112
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:566
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:2356
APInt RoundDoubleToAPInt(double Double, unsigned width)
Converts the given double value into a APInt.
Definition: APInt.cpp:713
#define LLVM_DEBUG(X)
Definition: Debug.h:119
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:960
static APInt floatToBits(float V)
Converts a float to APInt bits.
Definition: APInt.h:1723
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:1698
double signedRoundToDouble() const
Converts this signed APInt to a double value.
Definition: APInt.h:1691
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