LLVM  6.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 
53  std::shared_ptr<JITSymbolResolver> Resolver,
54  std::unique_ptr<TargetMachine> TM) = nullptr;
55 
56 ExecutionEngine *(*ExecutionEngine::OrcMCJITReplacementCtor)(
57  std::string *ErrorStr, std::shared_ptr<MCJITMemoryManager> MemMgr,
58  std::shared_ptr<JITSymbolResolver> Resolver,
59  std::unique_ptr<TargetMachine> TM) = nullptr;
60 
61 ExecutionEngine *(*ExecutionEngine::InterpCtor)(std::unique_ptr<Module> M,
62  std::string *ErrorStr) =nullptr;
63 
64 void JITEventListener::anchor() {}
65 
66 void ObjectCache::anchor() {}
67 
68 void ExecutionEngine::Init(std::unique_ptr<Module> M) {
69  CompilingLazily = false;
70  GVCompilationDisabled = false;
71  SymbolSearchingDisabled = false;
72 
73  // IR module verification is enabled by default in debug builds, and disabled
74  // by default in release builds.
75 #ifndef NDEBUG
76  VerifyModules = true;
77 #else
78  VerifyModules = false;
79 #endif
80 
81  assert(M && "Module is null?");
82  Modules.push_back(std::move(M));
83 }
84 
85 ExecutionEngine::ExecutionEngine(std::unique_ptr<Module> M)
86  : DL(M->getDataLayout()), LazyFunctionCreator(nullptr) {
87  Init(std::move(M));
88 }
89 
90 ExecutionEngine::ExecutionEngine(DataLayout DL, std::unique_ptr<Module> M)
91  : DL(std::move(DL)), LazyFunctionCreator(nullptr) {
92  Init(std::move(M));
93 }
94 
97 }
98 
99 namespace {
100 /// \brief Helper class which uses a value handler to automatically deletes the
101 /// memory block when the GlobalVariable is destroyed.
102 class GVMemoryBlock final : public CallbackVH {
103  GVMemoryBlock(const GlobalVariable *GV)
104  : CallbackVH(const_cast<GlobalVariable*>(GV)) {}
105 
106 public:
107  /// \brief Returns the address the GlobalVariable should be written into. The
108  /// GVMemoryBlock object prefixes that.
109  static char *Create(const GlobalVariable *GV, const DataLayout& TD) {
110  Type *ElTy = GV->getValueType();
111  size_t GVSize = (size_t)TD.getTypeAllocSize(ElTy);
112  void *RawMemory = ::operator new(
113  alignTo(sizeof(GVMemoryBlock), TD.getPreferredAlignment(GV)) + GVSize);
114  new(RawMemory) GVMemoryBlock(GV);
115  return static_cast<char*>(RawMemory) + sizeof(GVMemoryBlock);
116  }
117 
118  void deleted() override {
119  // We allocated with operator new and with some extra memory hanging off the
120  // end, so don't just delete this. I'm not sure if this is actually
121  // required.
122  this->~GVMemoryBlock();
123  ::operator delete(this);
124  }
125 };
126 } // anonymous namespace
127 
129  return GVMemoryBlock::Create(GV, getDataLayout());
130 }
131 
132 void ExecutionEngine::addObjectFile(std::unique_ptr<object::ObjectFile> O) {
133  llvm_unreachable("ExecutionEngine subclass doesn't implement addObjectFile.");
134 }
135 
136 void
138  llvm_unreachable("ExecutionEngine subclass doesn't implement addObjectFile.");
139 }
140 
142  llvm_unreachable("ExecutionEngine subclass doesn't implement addArchive.");
143 }
144 
146  for (auto I = Modules.begin(), E = Modules.end(); I != E; ++I) {
147  Module *Found = I->get();
148  if (Found == M) {
149  I->release();
150  Modules.erase(I);
152  return true;
153  }
154  }
155  return false;
156 }
157 
159  for (unsigned i = 0, e = Modules.size(); i != e; ++i) {
160  Function *F = Modules[i]->getFunction(FnName);
161  if (F && !F->isDeclaration())
162  return F;
163  }
164  return nullptr;
165 }
166 
168  for (unsigned i = 0, e = Modules.size(); i != e; ++i) {
169  GlobalVariable *GV = Modules[i]->getGlobalVariable(Name,AllowInternal);
170  if (GV && !GV->isDeclaration())
171  return GV;
172  }
173  return nullptr;
174 }
175 
177  GlobalAddressMapTy::iterator I = GlobalAddressMap.find(Name);
178  uint64_t OldVal;
179 
180  // FIXME: This is silly, we shouldn't end up with a mapping -> 0 in the
181  // GlobalAddressMap.
182  if (I == GlobalAddressMap.end())
183  OldVal = 0;
184  else {
185  GlobalAddressReverseMap.erase(I->second);
186  OldVal = I->second;
187  GlobalAddressMap.erase(I);
188  }
189 
190  return OldVal;
191 }
192 
194  assert(GV->hasName() && "Global must have name.");
195 
196  MutexGuard locked(lock);
197  SmallString<128> FullName;
198 
199  const DataLayout &DL =
201  ? getDataLayout()
202  : GV->getParent()->getDataLayout();
203 
204  Mangler::getNameWithPrefix(FullName, GV->getName(), DL);
205  return FullName.str();
206 }
207 
208 void ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) {
209  MutexGuard locked(lock);
210  addGlobalMapping(getMangledName(GV), (uint64_t) Addr);
211 }
212 
214  MutexGuard locked(lock);
215 
216  assert(!Name.empty() && "Empty GlobalMapping symbol name!");
217 
218  DEBUG(dbgs() << "JIT: Map \'" << Name << "\' to [" << Addr << "]\n";);
219  uint64_t &CurVal = EEState.getGlobalAddressMap()[Name];
220  assert((!CurVal || !Addr) && "GlobalMapping already established!");
221  CurVal = Addr;
222 
223  // If we are using the reverse mapping, add it too.
224  if (!EEState.getGlobalAddressReverseMap().empty()) {
225  std::string &V = EEState.getGlobalAddressReverseMap()[CurVal];
226  assert((!V.empty() || !Name.empty()) &&
227  "GlobalMapping already established!");
228  V = Name;
229  }
230 }
231 
233  MutexGuard locked(lock);
234 
235  EEState.getGlobalAddressMap().clear();
236  EEState.getGlobalAddressReverseMap().clear();
237 }
238 
240  MutexGuard locked(lock);
241 
242  for (GlobalObject &GO : M->global_objects())
243  EEState.RemoveMapping(getMangledName(&GO));
244 }
245 
247  void *Addr) {
248  MutexGuard locked(lock);
249  return updateGlobalMapping(getMangledName(GV), (uint64_t) Addr);
250 }
251 
253  MutexGuard locked(lock);
254 
256  EEState.getGlobalAddressMap();
257 
258  // Deleting from the mapping?
259  if (!Addr)
260  return EEState.RemoveMapping(Name);
261 
262  uint64_t &CurVal = Map[Name];
263  uint64_t OldVal = CurVal;
264 
265  if (CurVal && !EEState.getGlobalAddressReverseMap().empty())
266  EEState.getGlobalAddressReverseMap().erase(CurVal);
267  CurVal = Addr;
268 
269  // If we are using the reverse mapping, add it too.
270  if (!EEState.getGlobalAddressReverseMap().empty()) {
271  std::string &V = EEState.getGlobalAddressReverseMap()[CurVal];
272  assert((!V.empty() || !Name.empty()) &&
273  "GlobalMapping already established!");
274  V = Name;
275  }
276  return OldVal;
277 }
278 
280  MutexGuard locked(lock);
281  uint64_t Address = 0;
283  EEState.getGlobalAddressMap().find(S);
284  if (I != EEState.getGlobalAddressMap().end())
285  Address = I->second;
286  return Address;
287 }
288 
289 
291  MutexGuard locked(lock);
292  if (void* Address = (void *) getAddressToGlobalIfAvailable(S))
293  return Address;
294  return nullptr;
295 }
296 
298  MutexGuard locked(lock);
300 }
301 
303  MutexGuard locked(lock);
304 
305  // If we haven't computed the reverse mapping yet, do so first.
306  if (EEState.getGlobalAddressReverseMap().empty()) {
308  I = EEState.getGlobalAddressMap().begin(),
309  E = EEState.getGlobalAddressMap().end(); I != E; ++I) {
310  StringRef Name = I->first();
311  uint64_t Addr = I->second;
312  EEState.getGlobalAddressReverseMap().insert(std::make_pair(
313  Addr, Name));
314  }
315  }
316 
317  std::map<uint64_t, std::string>::iterator I =
318  EEState.getGlobalAddressReverseMap().find((uint64_t) Addr);
319 
320  if (I != EEState.getGlobalAddressReverseMap().end()) {
321  StringRef Name = I->second;
322  for (unsigned i = 0, e = Modules.size(); i != e; ++i)
323  if (GlobalValue *GV = Modules[i]->getNamedValue(Name))
324  return GV;
325  }
326  return nullptr;
327 }
328 
329 namespace {
330 class ArgvArray {
331  std::unique_ptr<char[]> Array;
332  std::vector<std::unique_ptr<char[]>> Values;
333 public:
334  /// Turn a vector of strings into a nice argv style array of pointers to null
335  /// terminated strings.
336  void *reset(LLVMContext &C, ExecutionEngine *EE,
337  const std::vector<std::string> &InputArgv);
338 };
339 } // anonymous namespace
340 void *ArgvArray::reset(LLVMContext &C, ExecutionEngine *EE,
341  const std::vector<std::string> &InputArgv) {
342  Values.clear(); // Free the old contents.
343  Values.reserve(InputArgv.size());
344  unsigned PtrSize = EE->getDataLayout().getPointerSize();
345  Array = make_unique<char[]>((InputArgv.size()+1)*PtrSize);
346 
347  DEBUG(dbgs() << "JIT: ARGV = " << (void*)Array.get() << "\n");
348  Type *SBytePtr = Type::getInt8PtrTy(C);
349 
350  for (unsigned i = 0; i != InputArgv.size(); ++i) {
351  unsigned Size = InputArgv[i].size()+1;
352  auto Dest = make_unique<char[]>(Size);
353  DEBUG(dbgs() << "JIT: ARGV[" << i << "] = " << (void*)Dest.get() << "\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  CMModel(CodeModel::JITDefault), 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<JITSymbolResolver> SR) {
507  Resolver = std::shared_ptr<JITSymbolResolver>(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  Triple TT(M->getTargetTriple());
536  if (!TM->getTarget().hasJIT()) {
537  errs() << "WARNING: This target JIT is not designed for the host"
538  << " you are running. If bad things happen, please choose"
539  << " a different -march switch.\n";
540  }
541 
542  ExecutionEngine *EE = nullptr;
543  if (ExecutionEngine::OrcMCJITReplacementCtor && UseOrcMCJITReplacement) {
544  EE = ExecutionEngine::OrcMCJITReplacementCtor(ErrorStr, std::move(MemMgr),
545  std::move(Resolver),
546  std::move(TheTM));
547  EE->addModule(std::move(M));
548  } else if (ExecutionEngine::MCJITCtor)
549  EE = ExecutionEngine::MCJITCtor(std::move(M), ErrorStr, std::move(MemMgr),
550  std::move(Resolver), std::move(TheTM));
551 
552  if (EE) {
553  EE->setVerifyModules(VerifyModules);
554  return EE;
555  }
556  }
557 
558  // If we can't make a JIT and we didn't request one specifically, try making
559  // an interpreter instead.
560  if (WhichEngine & EngineKind::Interpreter) {
562  return ExecutionEngine::InterpCtor(std::move(M), ErrorStr);
563  if (ErrorStr)
564  *ErrorStr = "Interpreter has not been linked in.";
565  return nullptr;
566  }
567 
568  if ((WhichEngine & EngineKind::JIT) && !ExecutionEngine::MCJITCtor) {
569  if (ErrorStr)
570  *ErrorStr = "JIT has not been linked in.";
571  }
572 
573  return nullptr;
574 }
575 
577  if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV)))
578  return getPointerToFunction(F);
579 
580  MutexGuard locked(lock);
581  if (void* P = getPointerToGlobalIfAvailable(GV))
582  return P;
583 
584  // Global variable might have been added since interpreter started.
585  if (GlobalVariable *GVar =
586  const_cast<GlobalVariable *>(dyn_cast<GlobalVariable>(GV)))
587  EmitGlobalVariable(GVar);
588  else
589  llvm_unreachable("Global hasn't had an address allocated yet!");
590 
591  return getPointerToGlobalIfAvailable(GV);
592 }
593 
594 /// \brief Converts a Constant* into a GenericValue, including handling of
595 /// ConstantExpr values.
597  // If its undefined, return the garbage.
598  if (isa<UndefValue>(C)) {
599  GenericValue Result;
600  switch (C->getType()->getTypeID()) {
601  default:
602  break;
603  case Type::IntegerTyID:
604  case Type::X86_FP80TyID:
605  case Type::FP128TyID:
606  case Type::PPC_FP128TyID:
607  // Although the value is undefined, we still have to construct an APInt
608  // with the correct bit width.
609  Result.IntVal = APInt(C->getType()->getPrimitiveSizeInBits(), 0);
610  break;
611  case Type::StructTyID: {
612  // if the whole struct is 'undef' just reserve memory for the value.
613  if(StructType *STy = dyn_cast<StructType>(C->getType())) {
614  unsigned int elemNum = STy->getNumElements();
615  Result.AggregateVal.resize(elemNum);
616  for (unsigned int i = 0; i < elemNum; ++i) {
617  Type *ElemTy = STy->getElementType(i);
618  if (ElemTy->isIntegerTy())
619  Result.AggregateVal[i].IntVal =
620  APInt(ElemTy->getPrimitiveSizeInBits(), 0);
621  else if (ElemTy->isAggregateType()) {
622  const Constant *ElemUndef = UndefValue::get(ElemTy);
623  Result.AggregateVal[i] = getConstantValue(ElemUndef);
624  }
625  }
626  }
627  }
628  break;
629  case Type::VectorTyID:
630  // if the whole vector is 'undef' just reserve memory for the value.
631  auto* VTy = dyn_cast<VectorType>(C->getType());
632  Type *ElemTy = VTy->getElementType();
633  unsigned int elemNum = VTy->getNumElements();
634  Result.AggregateVal.resize(elemNum);
635  if (ElemTy->isIntegerTy())
636  for (unsigned int i = 0; i < elemNum; ++i)
637  Result.AggregateVal[i].IntVal =
638  APInt(ElemTy->getPrimitiveSizeInBits(), 0);
639  break;
640  }
641  return Result;
642  }
643 
644  // Otherwise, if the value is a ConstantExpr...
645  if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
646  Constant *Op0 = CE->getOperand(0);
647  switch (CE->getOpcode()) {
648  case Instruction::GetElementPtr: {
649  // Compute the index
650  GenericValue Result = getConstantValue(Op0);
651  APInt Offset(DL.getPointerSizeInBits(), 0);
652  cast<GEPOperator>(CE)->accumulateConstantOffset(DL, Offset);
653 
654  char* tmp = (char*) Result.PointerVal;
655  Result = PTOGV(tmp + Offset.getSExtValue());
656  return Result;
657  }
658  case Instruction::Trunc: {
659  GenericValue GV = getConstantValue(Op0);
660  uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
661  GV.IntVal = GV.IntVal.trunc(BitWidth);
662  return GV;
663  }
664  case Instruction::ZExt: {
665  GenericValue GV = getConstantValue(Op0);
666  uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
667  GV.IntVal = GV.IntVal.zext(BitWidth);
668  return GV;
669  }
670  case Instruction::SExt: {
671  GenericValue GV = getConstantValue(Op0);
672  uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
673  GV.IntVal = GV.IntVal.sext(BitWidth);
674  return GV;
675  }
676  case Instruction::FPTrunc: {
677  // FIXME long double
678  GenericValue GV = getConstantValue(Op0);
679  GV.FloatVal = float(GV.DoubleVal);
680  return GV;
681  }
682  case Instruction::FPExt:{
683  // FIXME long double
684  GenericValue GV = getConstantValue(Op0);
685  GV.DoubleVal = double(GV.FloatVal);
686  return GV;
687  }
688  case Instruction::UIToFP: {
689  GenericValue GV = getConstantValue(Op0);
690  if (CE->getType()->isFloatTy())
691  GV.FloatVal = float(GV.IntVal.roundToDouble());
692  else if (CE->getType()->isDoubleTy())
693  GV.DoubleVal = GV.IntVal.roundToDouble();
694  else if (CE->getType()->isX86_FP80Ty()) {
696  (void)apf.convertFromAPInt(GV.IntVal,
697  false,
699  GV.IntVal = apf.bitcastToAPInt();
700  }
701  return GV;
702  }
703  case Instruction::SIToFP: {
704  GenericValue GV = getConstantValue(Op0);
705  if (CE->getType()->isFloatTy())
706  GV.FloatVal = float(GV.IntVal.signedRoundToDouble());
707  else if (CE->getType()->isDoubleTy())
709  else if (CE->getType()->isX86_FP80Ty()) {
711  (void)apf.convertFromAPInt(GV.IntVal,
712  true,
714  GV.IntVal = apf.bitcastToAPInt();
715  }
716  return GV;
717  }
718  case Instruction::FPToUI: // double->APInt conversion handles sign
719  case Instruction::FPToSI: {
720  GenericValue GV = getConstantValue(Op0);
721  uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
722  if (Op0->getType()->isFloatTy())
723  GV.IntVal = APIntOps::RoundFloatToAPInt(GV.FloatVal, BitWidth);
724  else if (Op0->getType()->isDoubleTy())
725  GV.IntVal = APIntOps::RoundDoubleToAPInt(GV.DoubleVal, BitWidth);
726  else if (Op0->getType()->isX86_FP80Ty()) {
728  uint64_t v;
729  bool ignored;
730  (void)apf.convertToInteger(makeMutableArrayRef(v), BitWidth,
731  CE->getOpcode()==Instruction::FPToSI,
732  APFloat::rmTowardZero, &ignored);
733  GV.IntVal = v; // endian?
734  }
735  return GV;
736  }
737  case Instruction::PtrToInt: {
738  GenericValue GV = getConstantValue(Op0);
739  uint32_t PtrWidth = DL.getTypeSizeInBits(Op0->getType());
740  assert(PtrWidth <= 64 && "Bad pointer width");
741  GV.IntVal = APInt(PtrWidth, uintptr_t(GV.PointerVal));
742  uint32_t IntWidth = DL.getTypeSizeInBits(CE->getType());
743  GV.IntVal = GV.IntVal.zextOrTrunc(IntWidth);
744  return GV;
745  }
746  case Instruction::IntToPtr: {
747  GenericValue GV = getConstantValue(Op0);
748  uint32_t PtrWidth = DL.getTypeSizeInBits(CE->getType());
749  GV.IntVal = GV.IntVal.zextOrTrunc(PtrWidth);
750  assert(GV.IntVal.getBitWidth() <= 64 && "Bad pointer width");
751  GV.PointerVal = PointerTy(uintptr_t(GV.IntVal.getZExtValue()));
752  return GV;
753  }
754  case Instruction::BitCast: {
755  GenericValue GV = getConstantValue(Op0);
756  Type* DestTy = CE->getType();
757  switch (Op0->getType()->getTypeID()) {
758  default: llvm_unreachable("Invalid bitcast operand");
759  case Type::IntegerTyID:
760  assert(DestTy->isFloatingPointTy() && "invalid bitcast");
761  if (DestTy->isFloatTy())
762  GV.FloatVal = GV.IntVal.bitsToFloat();
763  else if (DestTy->isDoubleTy())
764  GV.DoubleVal = GV.IntVal.bitsToDouble();
765  break;
766  case Type::FloatTyID:
767  assert(DestTy->isIntegerTy(32) && "Invalid bitcast");
769  break;
770  case Type::DoubleTyID:
771  assert(DestTy->isIntegerTy(64) && "Invalid bitcast");
773  break;
774  case Type::PointerTyID:
775  assert(DestTy->isPointerTy() && "Invalid bitcast");
776  break; // getConstantValue(Op0) above already converted it
777  }
778  return GV;
779  }
780  case Instruction::Add:
781  case Instruction::FAdd:
782  case Instruction::Sub:
783  case Instruction::FSub:
784  case Instruction::Mul:
785  case Instruction::FMul:
786  case Instruction::UDiv:
787  case Instruction::SDiv:
788  case Instruction::URem:
789  case Instruction::SRem:
790  case Instruction::And:
791  case Instruction::Or:
792  case Instruction::Xor: {
793  GenericValue LHS = getConstantValue(Op0);
794  GenericValue RHS = getConstantValue(CE->getOperand(1));
795  GenericValue GV;
796  switch (CE->getOperand(0)->getType()->getTypeID()) {
797  default: llvm_unreachable("Bad add type!");
798  case Type::IntegerTyID:
799  switch (CE->getOpcode()) {
800  default: llvm_unreachable("Invalid integer opcode");
801  case Instruction::Add: GV.IntVal = LHS.IntVal + RHS.IntVal; break;
802  case Instruction::Sub: GV.IntVal = LHS.IntVal - RHS.IntVal; break;
803  case Instruction::Mul: GV.IntVal = LHS.IntVal * RHS.IntVal; break;
804  case Instruction::UDiv:GV.IntVal = LHS.IntVal.udiv(RHS.IntVal); break;
805  case Instruction::SDiv:GV.IntVal = LHS.IntVal.sdiv(RHS.IntVal); break;
806  case Instruction::URem:GV.IntVal = LHS.IntVal.urem(RHS.IntVal); break;
807  case Instruction::SRem:GV.IntVal = LHS.IntVal.srem(RHS.IntVal); break;
808  case Instruction::And: GV.IntVal = LHS.IntVal & RHS.IntVal; break;
809  case Instruction::Or: GV.IntVal = LHS.IntVal | RHS.IntVal; break;
810  case Instruction::Xor: GV.IntVal = LHS.IntVal ^ RHS.IntVal; break;
811  }
812  break;
813  case Type::FloatTyID:
814  switch (CE->getOpcode()) {
815  default: llvm_unreachable("Invalid float opcode");
816  case Instruction::FAdd:
817  GV.FloatVal = LHS.FloatVal + RHS.FloatVal; break;
818  case Instruction::FSub:
819  GV.FloatVal = LHS.FloatVal - RHS.FloatVal; break;
820  case Instruction::FMul:
821  GV.FloatVal = LHS.FloatVal * RHS.FloatVal; break;
822  case Instruction::FDiv:
823  GV.FloatVal = LHS.FloatVal / RHS.FloatVal; break;
824  case Instruction::FRem:
825  GV.FloatVal = std::fmod(LHS.FloatVal,RHS.FloatVal); break;
826  }
827  break;
828  case Type::DoubleTyID:
829  switch (CE->getOpcode()) {
830  default: llvm_unreachable("Invalid double opcode");
831  case Instruction::FAdd:
832  GV.DoubleVal = LHS.DoubleVal + RHS.DoubleVal; break;
833  case Instruction::FSub:
834  GV.DoubleVal = LHS.DoubleVal - RHS.DoubleVal; break;
835  case Instruction::FMul:
836  GV.DoubleVal = LHS.DoubleVal * RHS.DoubleVal; break;
837  case Instruction::FDiv:
838  GV.DoubleVal = LHS.DoubleVal / RHS.DoubleVal; break;
839  case Instruction::FRem:
840  GV.DoubleVal = std::fmod(LHS.DoubleVal,RHS.DoubleVal); break;
841  }
842  break;
843  case Type::X86_FP80TyID:
844  case Type::PPC_FP128TyID:
845  case Type::FP128TyID: {
846  const fltSemantics &Sem = CE->getOperand(0)->getType()->getFltSemantics();
847  APFloat apfLHS = APFloat(Sem, LHS.IntVal);
848  switch (CE->getOpcode()) {
849  default: llvm_unreachable("Invalid long double opcode");
850  case Instruction::FAdd:
851  apfLHS.add(APFloat(Sem, RHS.IntVal), APFloat::rmNearestTiesToEven);
852  GV.IntVal = apfLHS.bitcastToAPInt();
853  break;
854  case Instruction::FSub:
855  apfLHS.subtract(APFloat(Sem, RHS.IntVal),
857  GV.IntVal = apfLHS.bitcastToAPInt();
858  break;
859  case Instruction::FMul:
860  apfLHS.multiply(APFloat(Sem, RHS.IntVal),
862  GV.IntVal = apfLHS.bitcastToAPInt();
863  break;
864  case Instruction::FDiv:
865  apfLHS.divide(APFloat(Sem, RHS.IntVal),
867  GV.IntVal = apfLHS.bitcastToAPInt();
868  break;
869  case Instruction::FRem:
870  apfLHS.mod(APFloat(Sem, RHS.IntVal));
871  GV.IntVal = apfLHS.bitcastToAPInt();
872  break;
873  }
874  }
875  break;
876  }
877  return GV;
878  }
879  default:
880  break;
881  }
882 
883  SmallString<256> Msg;
884  raw_svector_ostream OS(Msg);
885  OS << "ConstantExpr not handled: " << *CE;
886  report_fatal_error(OS.str());
887  }
888 
889  // Otherwise, we have a simple constant.
890  GenericValue Result;
891  switch (C->getType()->getTypeID()) {
892  case Type::FloatTyID:
893  Result.FloatVal = cast<ConstantFP>(C)->getValueAPF().convertToFloat();
894  break;
895  case Type::DoubleTyID:
896  Result.DoubleVal = cast<ConstantFP>(C)->getValueAPF().convertToDouble();
897  break;
898  case Type::X86_FP80TyID:
899  case Type::FP128TyID:
900  case Type::PPC_FP128TyID:
901  Result.IntVal = cast <ConstantFP>(C)->getValueAPF().bitcastToAPInt();
902  break;
903  case Type::IntegerTyID:
904  Result.IntVal = cast<ConstantInt>(C)->getValue();
905  break;
906  case Type::PointerTyID:
907  if (isa<ConstantPointerNull>(C))
908  Result.PointerVal = nullptr;
909  else if (const Function *F = dyn_cast<Function>(C))
910  Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F)));
911  else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C))
912  Result = PTOGV(getOrEmitGlobalVariable(const_cast<GlobalVariable*>(GV)));
913  else
914  llvm_unreachable("Unknown constant pointer type!");
915  break;
916  case Type::VectorTyID: {
917  unsigned elemNum;
918  Type* ElemTy;
920  const ConstantVector *CV = dyn_cast<ConstantVector>(C);
922 
923  if (CDV) {
924  elemNum = CDV->getNumElements();
925  ElemTy = CDV->getElementType();
926  } else if (CV || CAZ) {
927  VectorType* VTy = dyn_cast<VectorType>(C->getType());
928  elemNum = VTy->getNumElements();
929  ElemTy = VTy->getElementType();
930  } else {
931  llvm_unreachable("Unknown constant vector type!");
932  }
933 
934  Result.AggregateVal.resize(elemNum);
935  // Check if vector holds floats.
936  if(ElemTy->isFloatTy()) {
937  if (CAZ) {
938  GenericValue floatZero;
939  floatZero.FloatVal = 0.f;
940  std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
941  floatZero);
942  break;
943  }
944  if(CV) {
945  for (unsigned i = 0; i < elemNum; ++i)
946  if (!isa<UndefValue>(CV->getOperand(i)))
947  Result.AggregateVal[i].FloatVal = cast<ConstantFP>(
948  CV->getOperand(i))->getValueAPF().convertToFloat();
949  break;
950  }
951  if(CDV)
952  for (unsigned i = 0; i < elemNum; ++i)
953  Result.AggregateVal[i].FloatVal = CDV->getElementAsFloat(i);
954 
955  break;
956  }
957  // Check if vector holds doubles.
958  if (ElemTy->isDoubleTy()) {
959  if (CAZ) {
960  GenericValue doubleZero;
961  doubleZero.DoubleVal = 0.0;
962  std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
963  doubleZero);
964  break;
965  }
966  if(CV) {
967  for (unsigned i = 0; i < elemNum; ++i)
968  if (!isa<UndefValue>(CV->getOperand(i)))
969  Result.AggregateVal[i].DoubleVal = cast<ConstantFP>(
970  CV->getOperand(i))->getValueAPF().convertToDouble();
971  break;
972  }
973  if(CDV)
974  for (unsigned i = 0; i < elemNum; ++i)
975  Result.AggregateVal[i].DoubleVal = CDV->getElementAsDouble(i);
976 
977  break;
978  }
979  // Check if vector holds integers.
980  if (ElemTy->isIntegerTy()) {
981  if (CAZ) {
982  GenericValue intZero;
983  intZero.IntVal = APInt(ElemTy->getScalarSizeInBits(), 0ull);
984  std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
985  intZero);
986  break;
987  }
988  if(CV) {
989  for (unsigned i = 0; i < elemNum; ++i)
990  if (!isa<UndefValue>(CV->getOperand(i)))
991  Result.AggregateVal[i].IntVal = cast<ConstantInt>(
992  CV->getOperand(i))->getValue();
993  else {
994  Result.AggregateVal[i].IntVal =
995  APInt(CV->getOperand(i)->getType()->getPrimitiveSizeInBits(), 0);
996  }
997  break;
998  }
999  if(CDV)
1000  for (unsigned i = 0; i < elemNum; ++i)
1001  Result.AggregateVal[i].IntVal = APInt(
1003  CDV->getElementAsInteger(i));
1004 
1005  break;
1006  }
1007  llvm_unreachable("Unknown constant pointer type!");
1008  }
1009  break;
1010 
1011  default:
1012  SmallString<256> Msg;
1013  raw_svector_ostream OS(Msg);
1014  OS << "ERROR: Constant unimplemented for type: " << *C->getType();
1015  report_fatal_error(OS.str());
1016  }
1017 
1018  return Result;
1019 }
1020 
1021 /// StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst
1022 /// with the integer held in IntVal.
1023 static void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst,
1024  unsigned StoreBytes) {
1025  assert((IntVal.getBitWidth()+7)/8 >= StoreBytes && "Integer too small!");
1026  const uint8_t *Src = (const uint8_t *)IntVal.getRawData();
1027 
1029  // Little-endian host - the source is ordered from LSB to MSB. Order the
1030  // destination from LSB to MSB: Do a straight copy.
1031  memcpy(Dst, Src, StoreBytes);
1032  } else {
1033  // Big-endian host - the source is an array of 64 bit words ordered from
1034  // LSW to MSW. Each word is ordered from MSB to LSB. Order the destination
1035  // from MSB to LSB: Reverse the word order, but not the bytes in a word.
1036  while (StoreBytes > sizeof(uint64_t)) {
1037  StoreBytes -= sizeof(uint64_t);
1038  // May not be aligned so use memcpy.
1039  memcpy(Dst + StoreBytes, Src, sizeof(uint64_t));
1040  Src += sizeof(uint64_t);
1041  }
1042 
1043  memcpy(Dst, Src + sizeof(uint64_t) - StoreBytes, StoreBytes);
1044  }
1045 }
1046 
1048  GenericValue *Ptr, Type *Ty) {
1049  const unsigned StoreBytes = getDataLayout().getTypeStoreSize(Ty);
1050 
1051  switch (Ty->getTypeID()) {
1052  default:
1053  dbgs() << "Cannot store value of type " << *Ty << "!\n";
1054  break;
1055  case Type::IntegerTyID:
1056  StoreIntToMemory(Val.IntVal, (uint8_t*)Ptr, StoreBytes);
1057  break;
1058  case Type::FloatTyID:
1059  *((float*)Ptr) = Val.FloatVal;
1060  break;
1061  case Type::DoubleTyID:
1062  *((double*)Ptr) = Val.DoubleVal;
1063  break;
1064  case Type::X86_FP80TyID:
1065  memcpy(Ptr, Val.IntVal.getRawData(), 10);
1066  break;
1067  case Type::PointerTyID:
1068  // Ensure 64 bit target pointers are fully initialized on 32 bit hosts.
1069  if (StoreBytes != sizeof(PointerTy))
1070  memset(&(Ptr->PointerVal), 0, StoreBytes);
1071 
1072  *((PointerTy*)Ptr) = Val.PointerVal;
1073  break;
1074  case Type::VectorTyID:
1075  for (unsigned i = 0; i < Val.AggregateVal.size(); ++i) {
1076  if (cast<VectorType>(Ty)->getElementType()->isDoubleTy())
1077  *(((double*)Ptr)+i) = Val.AggregateVal[i].DoubleVal;
1078  if (cast<VectorType>(Ty)->getElementType()->isFloatTy())
1079  *(((float*)Ptr)+i) = Val.AggregateVal[i].FloatVal;
1080  if (cast<VectorType>(Ty)->getElementType()->isIntegerTy()) {
1081  unsigned numOfBytes =(Val.AggregateVal[i].IntVal.getBitWidth()+7)/8;
1082  StoreIntToMemory(Val.AggregateVal[i].IntVal,
1083  (uint8_t*)Ptr + numOfBytes*i, numOfBytes);
1084  }
1085  }
1086  break;
1087  }
1088 
1089  if (sys::IsLittleEndianHost != getDataLayout().isLittleEndian())
1090  // Host and target are different endian - reverse the stored bytes.
1091  std::reverse((uint8_t*)Ptr, StoreBytes + (uint8_t*)Ptr);
1092 }
1093 
1094 /// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting
1095 /// from Src into IntVal, which is assumed to be wide enough and to hold zero.
1096 static void LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes) {
1097  assert((IntVal.getBitWidth()+7)/8 >= LoadBytes && "Integer too small!");
1098  uint8_t *Dst = reinterpret_cast<uint8_t *>(
1099  const_cast<uint64_t *>(IntVal.getRawData()));
1100 
1102  // Little-endian host - the destination must be ordered from LSB to MSB.
1103  // The source is ordered from LSB to MSB: Do a straight copy.
1104  memcpy(Dst, Src, LoadBytes);
1105  else {
1106  // Big-endian - the destination is an array of 64 bit words ordered from
1107  // LSW to MSW. Each word must be ordered from MSB to LSB. The source is
1108  // ordered from MSB to LSB: Reverse the word order, but not the bytes in
1109  // a word.
1110  while (LoadBytes > sizeof(uint64_t)) {
1111  LoadBytes -= sizeof(uint64_t);
1112  // May not be aligned so use memcpy.
1113  memcpy(Dst, Src + LoadBytes, sizeof(uint64_t));
1114  Dst += sizeof(uint64_t);
1115  }
1116 
1117  memcpy(Dst + sizeof(uint64_t) - LoadBytes, Src, LoadBytes);
1118  }
1119 }
1120 
1121 /// FIXME: document
1122 ///
1124  GenericValue *Ptr,
1125  Type *Ty) {
1126  const unsigned LoadBytes = getDataLayout().getTypeStoreSize(Ty);
1127 
1128  switch (Ty->getTypeID()) {
1129  case Type::IntegerTyID:
1130  // An APInt with all words initially zero.
1131  Result.IntVal = APInt(cast<IntegerType>(Ty)->getBitWidth(), 0);
1132  LoadIntFromMemory(Result.IntVal, (uint8_t*)Ptr, LoadBytes);
1133  break;
1134  case Type::FloatTyID:
1135  Result.FloatVal = *((float*)Ptr);
1136  break;
1137  case Type::DoubleTyID:
1138  Result.DoubleVal = *((double*)Ptr);
1139  break;
1140  case Type::PointerTyID:
1141  Result.PointerVal = *((PointerTy*)Ptr);
1142  break;
1143  case Type::X86_FP80TyID: {
1144  // This is endian dependent, but it will only work on x86 anyway.
1145  // FIXME: Will not trap if loading a signaling NaN.
1146  uint64_t y[2];
1147  memcpy(y, Ptr, 10);
1148  Result.IntVal = APInt(80, y);
1149  break;
1150  }
1151  case Type::VectorTyID: {
1152  auto *VT = cast<VectorType>(Ty);
1153  Type *ElemT = VT->getElementType();
1154  const unsigned numElems = VT->getNumElements();
1155  if (ElemT->isFloatTy()) {
1156  Result.AggregateVal.resize(numElems);
1157  for (unsigned i = 0; i < numElems; ++i)
1158  Result.AggregateVal[i].FloatVal = *((float*)Ptr+i);
1159  }
1160  if (ElemT->isDoubleTy()) {
1161  Result.AggregateVal.resize(numElems);
1162  for (unsigned i = 0; i < numElems; ++i)
1163  Result.AggregateVal[i].DoubleVal = *((double*)Ptr+i);
1164  }
1165  if (ElemT->isIntegerTy()) {
1166  GenericValue intZero;
1167  const unsigned elemBitWidth = cast<IntegerType>(ElemT)->getBitWidth();
1168  intZero.IntVal = APInt(elemBitWidth, 0);
1169  Result.AggregateVal.resize(numElems, intZero);
1170  for (unsigned i = 0; i < numElems; ++i)
1171  LoadIntFromMemory(Result.AggregateVal[i].IntVal,
1172  (uint8_t*)Ptr+((elemBitWidth+7)/8)*i, (elemBitWidth+7)/8);
1173  }
1174  break;
1175  }
1176  default:
1177  SmallString<256> Msg;
1178  raw_svector_ostream OS(Msg);
1179  OS << "Cannot load value of type " << *Ty << "!";
1180  report_fatal_error(OS.str());
1181  }
1182 }
1183 
1185  DEBUG(dbgs() << "JIT: Initializing " << Addr << " ");
1186  DEBUG(Init->dump());
1187  if (isa<UndefValue>(Init))
1188  return;
1189 
1190  if (const ConstantVector *CP = dyn_cast<ConstantVector>(Init)) {
1191  unsigned ElementSize =
1192  getDataLayout().getTypeAllocSize(CP->getType()->getElementType());
1193  for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
1194  InitializeMemory(CP->getOperand(i), (char*)Addr+i*ElementSize);
1195  return;
1196  }
1197 
1198  if (isa<ConstantAggregateZero>(Init)) {
1199  memset(Addr, 0, (size_t)getDataLayout().getTypeAllocSize(Init->getType()));
1200  return;
1201  }
1202 
1203  if (const ConstantArray *CPA = dyn_cast<ConstantArray>(Init)) {
1204  unsigned ElementSize =
1205  getDataLayout().getTypeAllocSize(CPA->getType()->getElementType());
1206  for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i)
1207  InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize);
1208  return;
1209  }
1210 
1211  if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(Init)) {
1212  const StructLayout *SL =
1213  getDataLayout().getStructLayout(cast<StructType>(CPS->getType()));
1214  for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i)
1215  InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->getElementOffset(i));
1216  return;
1217  }
1218 
1219  if (const ConstantDataSequential *CDS =
1220  dyn_cast<ConstantDataSequential>(Init)) {
1221  // CDS is already laid out in host memory order.
1222  StringRef Data = CDS->getRawDataValues();
1223  memcpy(Addr, Data.data(), Data.size());
1224  return;
1225  }
1226 
1227  if (Init->getType()->isFirstClassType()) {
1228  GenericValue Val = getConstantValue(Init);
1229  StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType());
1230  return;
1231  }
1232 
1233  DEBUG(dbgs() << "Bad Type: " << *Init->getType() << "\n");
1234  llvm_unreachable("Unknown constant type to initialize memory with!");
1235 }
1236 
1237 /// EmitGlobals - Emit all of the global variables to memory, storing their
1238 /// addresses into GlobalAddress. This must make sure to copy the contents of
1239 /// their initializers into the memory.
1241  // Loop over all of the global variables in the program, allocating the memory
1242  // to hold them. If there is more than one module, do a prepass over globals
1243  // to figure out how the different modules should link together.
1244  std::map<std::pair<std::string, Type*>,
1245  const GlobalValue*> LinkedGlobalsMap;
1246 
1247  if (Modules.size() != 1) {
1248  for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
1249  Module &M = *Modules[m];
1250  for (const auto &GV : M.globals()) {
1251  if (GV.hasLocalLinkage() || GV.isDeclaration() ||
1252  GV.hasAppendingLinkage() || !GV.hasName())
1253  continue;// Ignore external globals and globals with internal linkage.
1254 
1255  const GlobalValue *&GVEntry =
1256  LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())];
1257 
1258  // If this is the first time we've seen this global, it is the canonical
1259  // version.
1260  if (!GVEntry) {
1261  GVEntry = &GV;
1262  continue;
1263  }
1264 
1265  // If the existing global is strong, never replace it.
1266  if (GVEntry->hasExternalLinkage())
1267  continue;
1268 
1269  // Otherwise, we know it's linkonce/weak, replace it if this is a strong
1270  // symbol. FIXME is this right for common?
1271  if (GV.hasExternalLinkage() || GVEntry->hasExternalWeakLinkage())
1272  GVEntry = &GV;
1273  }
1274  }
1275  }
1276 
1277  std::vector<const GlobalValue*> NonCanonicalGlobals;
1278  for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
1279  Module &M = *Modules[m];
1280  for (const auto &GV : M.globals()) {
1281  // In the multi-module case, see what this global maps to.
1282  if (!LinkedGlobalsMap.empty()) {
1283  if (const GlobalValue *GVEntry =
1284  LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())]) {
1285  // If something else is the canonical global, ignore this one.
1286  if (GVEntry != &GV) {
1287  NonCanonicalGlobals.push_back(&GV);
1288  continue;
1289  }
1290  }
1291  }
1292 
1293  if (!GV.isDeclaration()) {
1294  addGlobalMapping(&GV, getMemoryForGV(&GV));
1295  } else {
1296  // External variable reference. Try to use the dynamic loader to
1297  // get a pointer to it.
1298  if (void *SymAddr =
1300  addGlobalMapping(&GV, SymAddr);
1301  else {
1302  report_fatal_error("Could not resolve external global address: "
1303  +GV.getName());
1304  }
1305  }
1306  }
1307 
1308  // If there are multiple modules, map the non-canonical globals to their
1309  // canonical location.
1310  if (!NonCanonicalGlobals.empty()) {
1311  for (unsigned i = 0, e = NonCanonicalGlobals.size(); i != e; ++i) {
1312  const GlobalValue *GV = NonCanonicalGlobals[i];
1313  const GlobalValue *CGV =
1314  LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())];
1315  void *Ptr = getPointerToGlobalIfAvailable(CGV);
1316  assert(Ptr && "Canonical global wasn't codegen'd!");
1317  addGlobalMapping(GV, Ptr);
1318  }
1319  }
1320 
1321  // Now that all of the globals are set up in memory, loop through them all
1322  // and initialize their contents.
1323  for (const auto &GV : M.globals()) {
1324  if (!GV.isDeclaration()) {
1325  if (!LinkedGlobalsMap.empty()) {
1326  if (const GlobalValue *GVEntry =
1327  LinkedGlobalsMap[std::make_pair(GV.getName(), GV.getType())])
1328  if (GVEntry != &GV) // Not the canonical variable.
1329  continue;
1330  }
1331  EmitGlobalVariable(&GV);
1332  }
1333  }
1334  }
1335 }
1336 
1337 // EmitGlobalVariable - This method emits the specified global variable to the
1338 // address specified in GlobalAddresses, or allocates new memory if it's not
1339 // already in the map.
1341  void *GA = getPointerToGlobalIfAvailable(GV);
1342 
1343  if (!GA) {
1344  // If it's not already specified, allocate memory for the global.
1345  GA = getMemoryForGV(GV);
1346 
1347  // If we failed to allocate memory for this global, return.
1348  if (!GA) return;
1349 
1350  addGlobalMapping(GV, GA);
1351  }
1352 
1353  // Don't initialize if it's thread local, let the client do it.
1354  if (!GV->isThreadLocal())
1355  InitializeMemory(GV->getInitializer(), GA);
1356 
1357  Type *ElTy = GV->getValueType();
1358  size_t GVSize = (size_t)getDataLayout().getTypeAllocSize(ElTy);
1359  NumInitBytes += (unsigned)GVSize;
1360  ++NumGlobals;
1361 }
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:735
uint64_t CallInst * C
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:109
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:243
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:416
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:841
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:234
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:103
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
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:1590
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:865
APInt udiv(const APInt &RHS) const
Unsigned division operation.
Definition: APInt.cpp:1519
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:490
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:818
13: Structures
Definition: Type.h:73
STATISTIC(NumFunctions, "Total number of functions")
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:417
const DataLayout & getDataLayout() const
APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
Definition: APInt.cpp:883
15: Pointers
Definition: Type.h:75
double roundToDouble(bool isSigned) const
Converts this APInt to a double value.
Definition: APInt.cpp:757
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
EngineBuilder & setSymbolResolver(std::unique_ptr< JITSymbolResolver > SR)
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:3606
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:493
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:332
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:250
bool hasExternalLinkage() const
Definition: GlobalValue.h:402
static const bool IsLittleEndianHost
Definition: Host.h:51
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:86
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:862
#define F(x, y, z)
Definition: MD5.cpp:55
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:565
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.
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:2271
const char * Name
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)
static ExecutionEngine *(* OrcMCJITReplacementCtor)(std::string *ErrorStr, std::shared_ptr< MCJITMemoryManager > MM, std::shared_ptr< JITSymbolResolver > SR, std::unique_ptr< TargetMachine > TM)
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
APInt urem(const APInt &RHS) const
Unsigned remainder operation.
Definition: APInt.cpp:1612
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:68
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:605
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:440
EngineBuilder & setMemoryManager(std::unique_ptr< MCJITMemoryManager > MM)
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:139
#define A
Definition: LargeTest.cpp:12
virtual void addObjectFile(std::unique_ptr< object::ObjectFile > O)
addObjectFile - Add an ObjectFile to the execution engine.
static ExecutionEngine *(* MCJITCtor)(std::unique_ptr< Module > M, std::string *ErrorStr, std::shared_ptr< MCJITMemoryManager > MM, std::shared_ptr< JITSymbolResolver > SR, std::unique_ptr< TargetMachine > TM)
float getElementAsFloat(unsigned i) const
If this is an sequential container of floats, return the specified element as a float.
Definition: Constants.cpp:2633
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:491
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:1320
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...
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
void * GVTOP(const GenericValue &GV)
Definition: GenericValue.h:51
unsigned getNumOperands() const
Definition: User.h:176
ExecutionEngine(DataLayout DL)
#define E
Definition: LargeTest.cpp:27
char *** argv
Definition: afl_driver.cpp:92
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:2564
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:515
bool isDefault() const
Test if the DataLayout was constructed from an empty string.
Definition: DataLayout.h:229
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:137
unsigned getPreferredAlignment(const GlobalVariable *GV) const
Returns the preferred alignment of the specified global.
Definition: DataLayout.cpp:760
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:405
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
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
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:405
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:515
double getElementAsDouble(unsigned i) const
If this is an sequential container of doubles, return the specified element as a double.
Definition: Constants.cpp:2639
APInt srem(const APInt &RHS) const
Function for signed remainder operation.
Definition: APInt.cpp:1682
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:218
#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:262
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:200
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:545
bool hasJIT() const
hasJIT - Check if this targets supports the just-in-time compilation.
#define DEBUG(X)
Definition: Debug.h:118
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:56
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:233
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:2294
int * Ptr
APInt RoundDoubleToAPInt(double Double, unsigned width)
Converts the given double value into a APInt.
Definition: APInt.cpp:714
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:260
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