LLVM API Documentation

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Constants.cpp
Go to the documentation of this file.
1 //===-- Constants.cpp - Implement Constant nodes --------------------------===//
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 implements the Constant* classes.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/IR/Constants.h"
15 #include "ConstantFold.h"
16 #include "LLVMContextImpl.h"
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/ADT/FoldingSet.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/StringMap.h"
23 #include "llvm/IR/DerivedTypes.h"
24 #include "llvm/IR/GlobalValue.h"
25 #include "llvm/IR/Instructions.h"
26 #include "llvm/IR/Module.h"
27 #include "llvm/IR/Operator.h"
28 #include "llvm/Support/Compiler.h"
29 #include "llvm/Support/Debug.h"
35 #include <algorithm>
36 #include <cstdarg>
37 using namespace llvm;
38 
39 //===----------------------------------------------------------------------===//
40 // Constant Class
41 //===----------------------------------------------------------------------===//
42 
43 void Constant::anchor() { }
44 
46  // Floating point values have an explicit -0.0 value.
47  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
48  return CFP->isZero() && CFP->isNegative();
49 
50  // Equivalent for a vector of -0.0's.
51  if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this))
52  if (ConstantFP *SplatCFP = dyn_cast_or_null<ConstantFP>(CV->getSplatValue()))
53  if (SplatCFP && SplatCFP->isZero() && SplatCFP->isNegative())
54  return true;
55 
56  // We've already handled true FP case; any other FP vectors can't represent -0.0.
57  if (getType()->isFPOrFPVectorTy())
58  return false;
59 
60  // Otherwise, just use +0.0.
61  return isNullValue();
62 }
63 
64 // Return true iff this constant is positive zero (floating point), negative
65 // zero (floating point), or a null value.
66 bool Constant::isZeroValue() const {
67  // Floating point values have an explicit -0.0 value.
68  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
69  return CFP->isZero();
70 
71  // Otherwise, just use +0.0.
72  return isNullValue();
73 }
74 
75 bool Constant::isNullValue() const {
76  // 0 is null.
77  if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
78  return CI->isZero();
79 
80  // +0.0 is null.
81  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
82  return CFP->isZero() && !CFP->isNegative();
83 
84  // constant zero is zero for aggregates and cpnull is null for pointers.
85  return isa<ConstantAggregateZero>(this) || isa<ConstantPointerNull>(this);
86 }
87 
89  // Check for -1 integers
90  if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
91  return CI->isMinusOne();
92 
93  // Check for FP which are bitcasted from -1 integers
94  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
95  return CFP->getValueAPF().bitcastToAPInt().isAllOnesValue();
96 
97  // Check for constant vectors which are splats of -1 values.
98  if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
99  if (Constant *Splat = CV->getSplatValue())
100  return Splat->isAllOnesValue();
101 
102  // Check for constant vectors which are splats of -1 values.
103  if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this))
104  if (Constant *Splat = CV->getSplatValue())
105  return Splat->isAllOnesValue();
106 
107  return false;
108 }
109 
110 // Constructor to create a '0' constant of arbitrary type...
112  switch (Ty->getTypeID()) {
113  case Type::IntegerTyID:
114  return ConstantInt::get(Ty, 0);
115  case Type::HalfTyID:
116  return ConstantFP::get(Ty->getContext(),
118  case Type::FloatTyID:
119  return ConstantFP::get(Ty->getContext(),
121  case Type::DoubleTyID:
122  return ConstantFP::get(Ty->getContext(),
124  case Type::X86_FP80TyID:
125  return ConstantFP::get(Ty->getContext(),
127  case Type::FP128TyID:
128  return ConstantFP::get(Ty->getContext(),
130  case Type::PPC_FP128TyID:
131  return ConstantFP::get(Ty->getContext(),
133  APInt::getNullValue(128)));
134  case Type::PointerTyID:
135  return ConstantPointerNull::get(cast<PointerType>(Ty));
136  case Type::StructTyID:
137  case Type::ArrayTyID:
138  case Type::VectorTyID:
139  return ConstantAggregateZero::get(Ty);
140  default:
141  // Function, Label, or Opaque type?
142  llvm_unreachable("Cannot create a null constant of that type!");
143  }
144 }
145 
147  Type *ScalarTy = Ty->getScalarType();
148 
149  // Create the base integer constant.
150  Constant *C = ConstantInt::get(Ty->getContext(), V);
151 
152  // Convert an integer to a pointer, if necessary.
153  if (PointerType *PTy = dyn_cast<PointerType>(ScalarTy))
154  C = ConstantExpr::getIntToPtr(C, PTy);
155 
156  // Broadcast a scalar to a vector, if necessary.
157  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
158  C = ConstantVector::getSplat(VTy->getNumElements(), C);
159 
160  return C;
161 }
162 
164  if (IntegerType *ITy = dyn_cast<IntegerType>(Ty))
165  return ConstantInt::get(Ty->getContext(),
166  APInt::getAllOnesValue(ITy->getBitWidth()));
167 
168  if (Ty->isFloatingPointTy()) {
170  !Ty->isPPC_FP128Ty());
171  return ConstantFP::get(Ty->getContext(), FL);
172  }
173 
174  VectorType *VTy = cast<VectorType>(Ty);
177 }
178 
179 /// getAggregateElement - For aggregates (struct/array/vector) return the
180 /// constant that corresponds to the specified element if possible, or null if
181 /// not. This can return null if the element index is a ConstantExpr, or if
182 /// 'this' is a constant expr.
184  if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(this))
185  return Elt < CS->getNumOperands() ? CS->getOperand(Elt) : 0;
186 
187  if (const ConstantArray *CA = dyn_cast<ConstantArray>(this))
188  return Elt < CA->getNumOperands() ? CA->getOperand(Elt) : 0;
189 
190  if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
191  return Elt < CV->getNumOperands() ? CV->getOperand(Elt) : 0;
192 
193  if (const ConstantAggregateZero *CAZ =dyn_cast<ConstantAggregateZero>(this))
194  return CAZ->getElementValue(Elt);
195 
196  if (const UndefValue *UV = dyn_cast<UndefValue>(this))
197  return UV->getElementValue(Elt);
198 
199  if (const ConstantDataSequential *CDS =dyn_cast<ConstantDataSequential>(this))
200  return Elt < CDS->getNumElements() ? CDS->getElementAsConstant(Elt) : 0;
201  return 0;
202 }
203 
205  assert(isa<IntegerType>(Elt->getType()) && "Index must be an integer");
206  if (ConstantInt *CI = dyn_cast<ConstantInt>(Elt))
207  return getAggregateElement(CI->getZExtValue());
208  return 0;
209 }
210 
211 
213  // When a Constant is destroyed, there may be lingering
214  // references to the constant by other constants in the constant pool. These
215  // constants are implicitly dependent on the module that is being deleted,
216  // but they don't know that. Because we only find out when the CPV is
217  // deleted, we must now notify all of our users (that should only be
218  // Constants) that they are, in fact, invalid now and should be deleted.
219  //
220  while (!use_empty()) {
221  Value *V = use_back();
222 #ifndef NDEBUG // Only in -g mode...
223  if (!isa<Constant>(V)) {
224  dbgs() << "While deleting: " << *this
225  << "\n\nUse still stuck around after Def is destroyed: "
226  << *V << "\n\n";
227  }
228 #endif
229  assert(isa<Constant>(V) && "References remain to Constant being destroyed");
230  cast<Constant>(V)->destroyConstant();
231 
232  // The constant should remove itself from our use list...
233  assert((use_empty() || use_back() != V) && "Constant not removed!");
234  }
235 
236  // Value has no outstanding references it is safe to delete it now...
237  delete this;
238 }
239 
240 static bool canTrapImpl(const Constant *C,
241  SmallPtrSet<const ConstantExpr *, 4> &NonTrappingOps) {
242  assert(C->getType()->isFirstClassType() && "Cannot evaluate aggregate vals!");
243  // The only thing that could possibly trap are constant exprs.
244  const ConstantExpr *CE = dyn_cast<ConstantExpr>(C);
245  if (!CE)
246  return false;
247 
248  // ConstantExpr traps if any operands can trap.
249  for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) {
250  if (ConstantExpr *Op = dyn_cast<ConstantExpr>(CE->getOperand(i))) {
251  if (NonTrappingOps.insert(Op) && canTrapImpl(Op, NonTrappingOps))
252  return true;
253  }
254  }
255 
256  // Otherwise, only specific operations can trap.
257  switch (CE->getOpcode()) {
258  default:
259  return false;
260  case Instruction::UDiv:
261  case Instruction::SDiv:
262  case Instruction::FDiv:
263  case Instruction::URem:
264  case Instruction::SRem:
265  case Instruction::FRem:
266  // Div and rem can trap if the RHS is not known to be non-zero.
267  if (!isa<ConstantInt>(CE->getOperand(1)) ||CE->getOperand(1)->isNullValue())
268  return true;
269  return false;
270  }
271 }
272 
273 /// canTrap - Return true if evaluation of this constant could trap. This is
274 /// true for things like constant expressions that could divide by zero.
275 bool Constant::canTrap() const {
277  return canTrapImpl(this, NonTrappingOps);
278 }
279 
280 /// isThreadDependent - Return true if the value can vary between threads.
284  WorkList.push_back(this);
285  Visited.insert(this);
286 
287  while (!WorkList.empty()) {
288  const Constant *C = WorkList.pop_back_val();
289 
290  if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) {
291  if (GV->isThreadLocal())
292  return true;
293  }
294 
295  for (unsigned I = 0, E = C->getNumOperands(); I != E; ++I) {
296  const Constant *D = dyn_cast<Constant>(C->getOperand(I));
297  if (!D)
298  continue;
299  if (Visited.insert(D))
300  WorkList.push_back(D);
301  }
302  }
303 
304  return false;
305 }
306 
307 /// isConstantUsed - Return true if the constant has users other than constant
308 /// exprs and other dangling things.
310  for (const_use_iterator UI = use_begin(), E = use_end(); UI != E; ++UI) {
311  const Constant *UC = dyn_cast<Constant>(*UI);
312  if (UC == 0 || isa<GlobalValue>(UC))
313  return true;
314 
315  if (UC->isConstantUsed())
316  return true;
317  }
318  return false;
319 }
320 
321 
322 
323 /// getRelocationInfo - This method classifies the entry according to
324 /// whether or not it may generate a relocation entry. This must be
325 /// conservative, so if it might codegen to a relocatable entry, it should say
326 /// so. The return values are:
327 ///
328 /// NoRelocation: This constant pool entry is guaranteed to never have a
329 /// relocation applied to it (because it holds a simple constant like
330 /// '4').
331 /// LocalRelocation: This entry has relocations, but the entries are
332 /// guaranteed to be resolvable by the static linker, so the dynamic
333 /// linker will never see them.
334 /// GlobalRelocations: This entry may have arbitrary relocations.
335 ///
336 /// FIXME: This really should not be in IR.
338  if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
339  if (GV->hasLocalLinkage() || GV->hasHiddenVisibility())
340  return LocalRelocation; // Local to this file/library.
341  return GlobalRelocations; // Global reference.
342  }
343 
344  if (const BlockAddress *BA = dyn_cast<BlockAddress>(this))
345  return BA->getFunction()->getRelocationInfo();
346 
347  // While raw uses of blockaddress need to be relocated, differences between
348  // two of them don't when they are for labels in the same function. This is a
349  // common idiom when creating a table for the indirect goto extension, so we
350  // handle it efficiently here.
351  if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(this))
352  if (CE->getOpcode() == Instruction::Sub) {
353  ConstantExpr *LHS = dyn_cast<ConstantExpr>(CE->getOperand(0));
354  ConstantExpr *RHS = dyn_cast<ConstantExpr>(CE->getOperand(1));
355  if (LHS && RHS &&
356  LHS->getOpcode() == Instruction::PtrToInt &&
357  RHS->getOpcode() == Instruction::PtrToInt &&
358  isa<BlockAddress>(LHS->getOperand(0)) &&
359  isa<BlockAddress>(RHS->getOperand(0)) &&
360  cast<BlockAddress>(LHS->getOperand(0))->getFunction() ==
361  cast<BlockAddress>(RHS->getOperand(0))->getFunction())
362  return NoRelocation;
363  }
364 
366  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
367  Result = std::max(Result,
368  cast<Constant>(getOperand(i))->getRelocationInfo());
369 
370  return Result;
371 }
372 
373 /// removeDeadUsersOfConstant - If the specified constantexpr is dead, remove
374 /// it. This involves recursively eliminating any dead users of the
375 /// constantexpr.
376 static bool removeDeadUsersOfConstant(const Constant *C) {
377  if (isa<GlobalValue>(C)) return false; // Cannot remove this
378 
379  while (!C->use_empty()) {
380  const Constant *User = dyn_cast<Constant>(C->use_back());
381  if (!User) return false; // Non-constant usage;
382  if (!removeDeadUsersOfConstant(User))
383  return false; // Constant wasn't dead
384  }
385 
386  const_cast<Constant*>(C)->destroyConstant();
387  return true;
388 }
389 
390 
391 /// removeDeadConstantUsers - If there are any dead constant users dangling
392 /// off of this constant, remove them. This method is useful for clients
393 /// that want to check to see if a global is unused, but don't want to deal
394 /// with potentially dead constants hanging off of the globals.
397  Value::const_use_iterator LastNonDeadUser = E;
398  while (I != E) {
399  const Constant *User = dyn_cast<Constant>(*I);
400  if (User == 0) {
401  LastNonDeadUser = I;
402  ++I;
403  continue;
404  }
405 
406  if (!removeDeadUsersOfConstant(User)) {
407  // If the constant wasn't dead, remember that this was the last live use
408  // and move on to the next constant.
409  LastNonDeadUser = I;
410  ++I;
411  continue;
412  }
413 
414  // If the constant was dead, then the iterator is invalidated.
415  if (LastNonDeadUser == E) {
416  I = use_begin();
417  if (I == E) break;
418  } else {
419  I = LastNonDeadUser;
420  ++I;
421  }
422  }
423 }
424 
425 
426 
427 //===----------------------------------------------------------------------===//
428 // ConstantInt
429 //===----------------------------------------------------------------------===//
430 
431 void ConstantInt::anchor() { }
432 
433 ConstantInt::ConstantInt(IntegerType *Ty, const APInt& V)
434  : Constant(Ty, ConstantIntVal, 0, 0), Val(V) {
435  assert(V.getBitWidth() == Ty->getBitWidth() && "Invalid constant for type");
436 }
437 
439  LLVMContextImpl *pImpl = Context.pImpl;
440  if (!pImpl->TheTrueVal)
441  pImpl->TheTrueVal = ConstantInt::get(Type::getInt1Ty(Context), 1);
442  return pImpl->TheTrueVal;
443 }
444 
446  LLVMContextImpl *pImpl = Context.pImpl;
447  if (!pImpl->TheFalseVal)
448  pImpl->TheFalseVal = ConstantInt::get(Type::getInt1Ty(Context), 0);
449  return pImpl->TheFalseVal;
450 }
451 
453  VectorType *VTy = dyn_cast<VectorType>(Ty);
454  if (!VTy) {
455  assert(Ty->isIntegerTy(1) && "True must be i1 or vector of i1.");
456  return ConstantInt::getTrue(Ty->getContext());
457  }
458  assert(VTy->getElementType()->isIntegerTy(1) &&
459  "True must be vector of i1 or i1.");
462 }
463 
465  VectorType *VTy = dyn_cast<VectorType>(Ty);
466  if (!VTy) {
467  assert(Ty->isIntegerTy(1) && "False must be i1 or vector of i1.");
468  return ConstantInt::getFalse(Ty->getContext());
469  }
470  assert(VTy->getElementType()->isIntegerTy(1) &&
471  "False must be vector of i1 or i1.");
474 }
475 
476 
477 // Get a ConstantInt from an APInt. Note that the value stored in the DenseMap
478 // as the key, is a DenseMapAPIntKeyInfo::KeyTy which has provided the
479 // operator== and operator!= to ensure that the DenseMap doesn't attempt to
480 // compare APInt's of different widths, which would violate an APInt class
481 // invariant which generates an assertion.
483  // Get the corresponding integer type for the bit width of the value.
484  IntegerType *ITy = IntegerType::get(Context, V.getBitWidth());
485  // get an existing value or the insertion position
486  LLVMContextImpl *pImpl = Context.pImpl;
487  ConstantInt *&Slot = pImpl->IntConstants[DenseMapAPIntKeyInfo::KeyTy(V, ITy)];
488  if (!Slot) Slot = new ConstantInt(ITy, V);
489  return Slot;
490 }
491 
492 Constant *ConstantInt::get(Type *Ty, uint64_t V, bool isSigned) {
493  Constant *C = get(cast<IntegerType>(Ty->getScalarType()), V, isSigned);
494 
495  // For vectors, broadcast the value.
496  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
497  return ConstantVector::getSplat(VTy->getNumElements(), C);
498 
499  return C;
500 }
501 
503  bool isSigned) {
504  return get(Ty->getContext(), APInt(Ty->getBitWidth(), V, isSigned));
505 }
506 
508  return get(Ty, V, true);
509 }
510 
512  return get(Ty, V, true);
513 }
514 
516  ConstantInt *C = get(Ty->getContext(), V);
517  assert(C->getType() == Ty->getScalarType() &&
518  "ConstantInt type doesn't match the type implied by its value!");
519 
520  // For vectors, broadcast the value.
521  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
522  return ConstantVector::getSplat(VTy->getNumElements(), C);
523 
524  return C;
525 }
526 
528  uint8_t radix) {
529  return get(Ty->getContext(), APInt(Ty->getBitWidth(), Str, radix));
530 }
531 
532 //===----------------------------------------------------------------------===//
533 // ConstantFP
534 //===----------------------------------------------------------------------===//
535 
537  if (Ty->isHalfTy())
538  return &APFloat::IEEEhalf;
539  if (Ty->isFloatTy())
540  return &APFloat::IEEEsingle;
541  if (Ty->isDoubleTy())
542  return &APFloat::IEEEdouble;
543  if (Ty->isX86_FP80Ty())
545  else if (Ty->isFP128Ty())
546  return &APFloat::IEEEquad;
547 
548  assert(Ty->isPPC_FP128Ty() && "Unknown FP format");
549  return &APFloat::PPCDoubleDouble;
550 }
551 
552 void ConstantFP::anchor() { }
553 
554 /// get() - This returns a constant fp for the specified value in the
555 /// specified type. This should only be used for simple constant values like
556 /// 2.0/1.0 etc, that are known-valid both as double and as the target format.
557 Constant *ConstantFP::get(Type *Ty, double V) {
558  LLVMContext &Context = Ty->getContext();
559 
560  APFloat FV(V);
561  bool ignored;
563  APFloat::rmNearestTiesToEven, &ignored);
564  Constant *C = get(Context, FV);
565 
566  // For vectors, broadcast the value.
567  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
568  return ConstantVector::getSplat(VTy->getNumElements(), C);
569 
570  return C;
571 }
572 
573 
575  LLVMContext &Context = Ty->getContext();
576 
577  APFloat FV(*TypeToFloatSemantics(Ty->getScalarType()), Str);
578  Constant *C = get(Context, FV);
579 
580  // For vectors, broadcast the value.
581  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
582  return ConstantVector::getSplat(VTy->getNumElements(), C);
583 
584  return C;
585 }
586 
587 
589  LLVMContext &Context = Ty->getContext();
590  APFloat apf = cast<ConstantFP>(Constant::getNullValue(Ty))->getValueAPF();
591  apf.changeSign();
592  return get(Context, apf);
593 }
594 
595 
597  Type *ScalarTy = Ty->getScalarType();
598  if (ScalarTy->isFloatingPointTy()) {
599  Constant *C = getNegativeZero(ScalarTy);
600  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
601  return ConstantVector::getSplat(VTy->getNumElements(), C);
602  return C;
603  }
604 
605  return Constant::getNullValue(Ty);
606 }
607 
608 
609 // ConstantFP accessors.
611  LLVMContextImpl* pImpl = Context.pImpl;
612 
614 
615  if (!Slot) {
616  Type *Ty;
617  if (&V.getSemantics() == &APFloat::IEEEhalf)
618  Ty = Type::getHalfTy(Context);
619  else if (&V.getSemantics() == &APFloat::IEEEsingle)
620  Ty = Type::getFloatTy(Context);
621  else if (&V.getSemantics() == &APFloat::IEEEdouble)
622  Ty = Type::getDoubleTy(Context);
623  else if (&V.getSemantics() == &APFloat::x87DoubleExtended)
624  Ty = Type::getX86_FP80Ty(Context);
625  else if (&V.getSemantics() == &APFloat::IEEEquad)
626  Ty = Type::getFP128Ty(Context);
627  else {
628  assert(&V.getSemantics() == &APFloat::PPCDoubleDouble &&
629  "Unknown FP format");
630  Ty = Type::getPPC_FP128Ty(Context);
631  }
632  Slot = new ConstantFP(Ty, V);
633  }
634 
635  return Slot;
636 }
637 
639  const fltSemantics &Semantics = *TypeToFloatSemantics(Ty);
640  return ConstantFP::get(Ty->getContext(),
641  APFloat::getInf(Semantics, Negative));
642 }
643 
644 ConstantFP::ConstantFP(Type *Ty, const APFloat& V)
645  : Constant(Ty, ConstantFPVal, 0, 0), Val(V) {
646  assert(&V.getSemantics() == TypeToFloatSemantics(Ty) &&
647  "FP type Mismatch");
648 }
649 
650 bool ConstantFP::isExactlyValue(const APFloat &V) const {
651  return Val.bitwiseIsEqual(V);
652 }
653 
654 //===----------------------------------------------------------------------===//
655 // ConstantAggregateZero Implementation
656 //===----------------------------------------------------------------------===//
657 
658 /// getSequentialElement - If this CAZ has array or vector type, return a zero
659 /// with the right element type.
661  return Constant::getNullValue(getType()->getSequentialElementType());
662 }
663 
664 /// getStructElement - If this CAZ has struct type, return a zero with the
665 /// right element type for the specified element.
667  return Constant::getNullValue(getType()->getStructElementType(Elt));
668 }
669 
670 /// getElementValue - Return a zero of the right value for the specified GEP
671 /// index if we can, otherwise return null (e.g. if C is a ConstantExpr).
673  if (isa<SequentialType>(getType()))
674  return getSequentialElement();
675  return getStructElement(cast<ConstantInt>(C)->getZExtValue());
676 }
677 
678 /// getElementValue - Return a zero of the right value for the specified GEP
679 /// index.
681  if (isa<SequentialType>(getType()))
682  return getSequentialElement();
683  return getStructElement(Idx);
684 }
685 
686 
687 //===----------------------------------------------------------------------===//
688 // UndefValue Implementation
689 //===----------------------------------------------------------------------===//
690 
691 /// getSequentialElement - If this undef has array or vector type, return an
692 /// undef with the right element type.
694  return UndefValue::get(getType()->getSequentialElementType());
695 }
696 
697 /// getStructElement - If this undef has struct type, return a zero with the
698 /// right element type for the specified element.
700  return UndefValue::get(getType()->getStructElementType(Elt));
701 }
702 
703 /// getElementValue - Return an undef of the right value for the specified GEP
704 /// index if we can, otherwise return null (e.g. if C is a ConstantExpr).
706  if (isa<SequentialType>(getType()))
707  return getSequentialElement();
708  return getStructElement(cast<ConstantInt>(C)->getZExtValue());
709 }
710 
711 /// getElementValue - Return an undef of the right value for the specified GEP
712 /// index.
714  if (isa<SequentialType>(getType()))
715  return getSequentialElement();
716  return getStructElement(Idx);
717 }
718 
719 
720 
721 //===----------------------------------------------------------------------===//
722 // ConstantXXX Classes
723 //===----------------------------------------------------------------------===//
724 
725 template <typename ItTy, typename EltTy>
726 static bool rangeOnlyContains(ItTy Start, ItTy End, EltTy Elt) {
727  for (; Start != End; ++Start)
728  if (*Start != Elt)
729  return false;
730  return true;
731 }
732 
733 ConstantArray::ConstantArray(ArrayType *T, ArrayRef<Constant *> V)
734  : Constant(T, ConstantArrayVal,
735  OperandTraits<ConstantArray>::op_end(this) - V.size(),
736  V.size()) {
737  assert(V.size() == T->getNumElements() &&
738  "Invalid initializer vector for constant array");
739  for (unsigned i = 0, e = V.size(); i != e; ++i)
740  assert(V[i]->getType() == T->getElementType() &&
741  "Initializer for array element doesn't match array element type!");
742  std::copy(V.begin(), V.end(), op_begin());
743 }
744 
746  // Empty arrays are canonicalized to ConstantAggregateZero.
747  if (V.empty())
748  return ConstantAggregateZero::get(Ty);
749 
750  for (unsigned i = 0, e = V.size(); i != e; ++i) {
751  assert(V[i]->getType() == Ty->getElementType() &&
752  "Wrong type in array element initializer");
753  }
754  LLVMContextImpl *pImpl = Ty->getContext().pImpl;
755 
756  // If this is an all-zero array, return a ConstantAggregateZero object. If
757  // all undef, return an UndefValue, if "all simple", then return a
758  // ConstantDataArray.
759  Constant *C = V[0];
760  if (isa<UndefValue>(C) && rangeOnlyContains(V.begin(), V.end(), C))
761  return UndefValue::get(Ty);
762 
763  if (C->isNullValue() && rangeOnlyContains(V.begin(), V.end(), C))
764  return ConstantAggregateZero::get(Ty);
765 
766  // Check to see if all of the elements are ConstantFP or ConstantInt and if
767  // the element type is compatible with ConstantDataVector. If so, use it.
769  // We speculatively build the elements here even if it turns out that there
770  // is a constantexpr or something else weird in the array, since it is so
771  // uncommon for that to happen.
772  if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
773  if (CI->getType()->isIntegerTy(8)) {
775  for (unsigned i = 0, e = V.size(); i != e; ++i)
776  if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i]))
777  Elts.push_back(CI->getZExtValue());
778  else
779  break;
780  if (Elts.size() == V.size())
781  return ConstantDataArray::get(C->getContext(), Elts);
782  } else if (CI->getType()->isIntegerTy(16)) {
784  for (unsigned i = 0, e = V.size(); i != e; ++i)
785  if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i]))
786  Elts.push_back(CI->getZExtValue());
787  else
788  break;
789  if (Elts.size() == V.size())
790  return ConstantDataArray::get(C->getContext(), Elts);
791  } else if (CI->getType()->isIntegerTy(32)) {
793  for (unsigned i = 0, e = V.size(); i != e; ++i)
794  if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i]))
795  Elts.push_back(CI->getZExtValue());
796  else
797  break;
798  if (Elts.size() == V.size())
799  return ConstantDataArray::get(C->getContext(), Elts);
800  } else if (CI->getType()->isIntegerTy(64)) {
802  for (unsigned i = 0, e = V.size(); i != e; ++i)
803  if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i]))
804  Elts.push_back(CI->getZExtValue());
805  else
806  break;
807  if (Elts.size() == V.size())
808  return ConstantDataArray::get(C->getContext(), Elts);
809  }
810  }
811 
812  if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
813  if (CFP->getType()->isFloatTy()) {
815  for (unsigned i = 0, e = V.size(); i != e; ++i)
816  if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i]))
817  Elts.push_back(CFP->getValueAPF().convertToFloat());
818  else
819  break;
820  if (Elts.size() == V.size())
821  return ConstantDataArray::get(C->getContext(), Elts);
822  } else if (CFP->getType()->isDoubleTy()) {
824  for (unsigned i = 0, e = V.size(); i != e; ++i)
825  if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i]))
826  Elts.push_back(CFP->getValueAPF().convertToDouble());
827  else
828  break;
829  if (Elts.size() == V.size())
830  return ConstantDataArray::get(C->getContext(), Elts);
831  }
832  }
833  }
834 
835  // Otherwise, we really do want to create a ConstantArray.
836  return pImpl->ArrayConstants.getOrCreate(Ty, V);
837 }
838 
839 /// getTypeForElements - Return an anonymous struct type to use for a constant
840 /// with the specified set of elements. The list must not be empty.
843  bool Packed) {
844  unsigned VecSize = V.size();
845  SmallVector<Type*, 16> EltTypes(VecSize);
846  for (unsigned i = 0; i != VecSize; ++i)
847  EltTypes[i] = V[i]->getType();
848 
849  return StructType::get(Context, EltTypes, Packed);
850 }
851 
852 
854  bool Packed) {
855  assert(!V.empty() &&
856  "ConstantStruct::getTypeForElements cannot be called on empty list");
857  return getTypeForElements(V[0]->getContext(), V, Packed);
858 }
859 
860 
861 ConstantStruct::ConstantStruct(StructType *T, ArrayRef<Constant *> V)
862  : Constant(T, ConstantStructVal,
863  OperandTraits<ConstantStruct>::op_end(this) - V.size(),
864  V.size()) {
865  assert(V.size() == T->getNumElements() &&
866  "Invalid initializer vector for constant structure");
867  for (unsigned i = 0, e = V.size(); i != e; ++i)
868  assert((T->isOpaque() || V[i]->getType() == T->getElementType(i)) &&
869  "Initializer for struct element doesn't match struct element type!");
870  std::copy(V.begin(), V.end(), op_begin());
871 }
872 
873 // ConstantStruct accessors.
875  assert((ST->isOpaque() || ST->getNumElements() == V.size()) &&
876  "Incorrect # elements specified to ConstantStruct::get");
877 
878  // Create a ConstantAggregateZero value if all elements are zeros.
879  bool isZero = true;
880  bool isUndef = false;
881 
882  if (!V.empty()) {
883  isUndef = isa<UndefValue>(V[0]);
884  isZero = V[0]->isNullValue();
885  if (isUndef || isZero) {
886  for (unsigned i = 0, e = V.size(); i != e; ++i) {
887  if (!V[i]->isNullValue())
888  isZero = false;
889  if (!isa<UndefValue>(V[i]))
890  isUndef = false;
891  }
892  }
893  }
894  if (isZero)
895  return ConstantAggregateZero::get(ST);
896  if (isUndef)
897  return UndefValue::get(ST);
898 
899  return ST->getContext().pImpl->StructConstants.getOrCreate(ST, V);
900 }
901 
903  va_list ap;
905  va_start(ap, T);
906  while (Constant *Val = va_arg(ap, llvm::Constant*))
907  Values.push_back(Val);
908  va_end(ap);
909  return get(T, Values);
910 }
911 
912 ConstantVector::ConstantVector(VectorType *T, ArrayRef<Constant *> V)
913  : Constant(T, ConstantVectorVal,
914  OperandTraits<ConstantVector>::op_end(this) - V.size(),
915  V.size()) {
916  for (size_t i = 0, e = V.size(); i != e; i++)
917  assert(V[i]->getType() == T->getElementType() &&
918  "Initializer for vector element doesn't match vector element type!");
919  std::copy(V.begin(), V.end(), op_begin());
920 }
921 
922 // ConstantVector accessors.
924  assert(!V.empty() && "Vectors can't be empty");
925  VectorType *T = VectorType::get(V.front()->getType(), V.size());
926  LLVMContextImpl *pImpl = T->getContext().pImpl;
927 
928  // If this is an all-undef or all-zero vector, return a
929  // ConstantAggregateZero or UndefValue.
930  Constant *C = V[0];
931  bool isZero = C->isNullValue();
932  bool isUndef = isa<UndefValue>(C);
933 
934  if (isZero || isUndef) {
935  for (unsigned i = 1, e = V.size(); i != e; ++i)
936  if (V[i] != C) {
937  isZero = isUndef = false;
938  break;
939  }
940  }
941 
942  if (isZero)
943  return ConstantAggregateZero::get(T);
944  if (isUndef)
945  return UndefValue::get(T);
946 
947  // Check to see if all of the elements are ConstantFP or ConstantInt and if
948  // the element type is compatible with ConstantDataVector. If so, use it.
950  // We speculatively build the elements here even if it turns out that there
951  // is a constantexpr or something else weird in the array, since it is so
952  // uncommon for that to happen.
953  if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
954  if (CI->getType()->isIntegerTy(8)) {
956  for (unsigned i = 0, e = V.size(); i != e; ++i)
957  if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i]))
958  Elts.push_back(CI->getZExtValue());
959  else
960  break;
961  if (Elts.size() == V.size())
962  return ConstantDataVector::get(C->getContext(), Elts);
963  } else if (CI->getType()->isIntegerTy(16)) {
965  for (unsigned i = 0, e = V.size(); i != e; ++i)
966  if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i]))
967  Elts.push_back(CI->getZExtValue());
968  else
969  break;
970  if (Elts.size() == V.size())
971  return ConstantDataVector::get(C->getContext(), Elts);
972  } else if (CI->getType()->isIntegerTy(32)) {
974  for (unsigned i = 0, e = V.size(); i != e; ++i)
975  if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i]))
976  Elts.push_back(CI->getZExtValue());
977  else
978  break;
979  if (Elts.size() == V.size())
980  return ConstantDataVector::get(C->getContext(), Elts);
981  } else if (CI->getType()->isIntegerTy(64)) {
983  for (unsigned i = 0, e = V.size(); i != e; ++i)
984  if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i]))
985  Elts.push_back(CI->getZExtValue());
986  else
987  break;
988  if (Elts.size() == V.size())
989  return ConstantDataVector::get(C->getContext(), Elts);
990  }
991  }
992 
993  if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
994  if (CFP->getType()->isFloatTy()) {
996  for (unsigned i = 0, e = V.size(); i != e; ++i)
997  if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i]))
998  Elts.push_back(CFP->getValueAPF().convertToFloat());
999  else
1000  break;
1001  if (Elts.size() == V.size())
1002  return ConstantDataVector::get(C->getContext(), Elts);
1003  } else if (CFP->getType()->isDoubleTy()) {
1005  for (unsigned i = 0, e = V.size(); i != e; ++i)
1006  if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i]))
1007  Elts.push_back(CFP->getValueAPF().convertToDouble());
1008  else
1009  break;
1010  if (Elts.size() == V.size())
1011  return ConstantDataVector::get(C->getContext(), Elts);
1012  }
1013  }
1014  }
1015 
1016  // Otherwise, the element type isn't compatible with ConstantDataVector, or
1017  // the operand list constants a ConstantExpr or something else strange.
1018  return pImpl->VectorConstants.getOrCreate(T, V);
1019 }
1020 
1022  // If this splat is compatible with ConstantDataVector, use it instead of
1023  // ConstantVector.
1024  if ((isa<ConstantFP>(V) || isa<ConstantInt>(V)) &&
1026  return ConstantDataVector::getSplat(NumElts, V);
1027 
1028  SmallVector<Constant*, 32> Elts(NumElts, V);
1029  return get(Elts);
1030 }
1031 
1032 
1033 // Utility function for determining if a ConstantExpr is a CastOp or not. This
1034 // can't be inline because we don't want to #include Instruction.h into
1035 // Constant.h
1036 bool ConstantExpr::isCast() const {
1037  return Instruction::isCast(getOpcode());
1038 }
1039 
1041  return getOpcode() == Instruction::ICmp || getOpcode() == Instruction::FCmp;
1042 }
1043 
1045  if (getOpcode() != Instruction::GetElementPtr) return false;
1046 
1047  gep_type_iterator GEPI = gep_type_begin(this), E = gep_type_end(this);
1049 
1050  // Skip the first index, as it has no static limit.
1051  ++GEPI;
1052  ++OI;
1053 
1054  // The remaining indices must be compile-time known integers within the
1055  // bounds of the corresponding notional static array types.
1056  for (; GEPI != E; ++GEPI, ++OI) {
1057  ConstantInt *CI = dyn_cast<ConstantInt>(*OI);
1058  if (!CI) return false;
1059  if (ArrayType *ATy = dyn_cast<ArrayType>(*GEPI))
1060  if (CI->getValue().getActiveBits() > 64 ||
1061  CI->getZExtValue() >= ATy->getNumElements())
1062  return false;
1063  }
1064 
1065  // All the indices checked out.
1066  return true;
1067 }
1068 
1070  return getOpcode() == Instruction::ExtractValue ||
1071  getOpcode() == Instruction::InsertValue;
1072 }
1073 
1075  if (const ExtractValueConstantExpr *EVCE =
1076  dyn_cast<ExtractValueConstantExpr>(this))
1077  return EVCE->Indices;
1078 
1079  return cast<InsertValueConstantExpr>(this)->Indices;
1080 }
1081 
1082 unsigned ConstantExpr::getPredicate() const {
1083  assert(isCompare());
1084  return ((const CompareConstantExpr*)this)->predicate;
1085 }
1086 
1087 /// getWithOperandReplaced - Return a constant expression identical to this
1088 /// one, but with the specified operand set to the specified value.
1089 Constant *
1091  assert(Op->getType() == getOperand(OpNo)->getType() &&
1092  "Replacing operand with value of different type!");
1093  if (getOperand(OpNo) == Op)
1094  return const_cast<ConstantExpr*>(this);
1095 
1097  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
1098  NewOps.push_back(i == OpNo ? Op : getOperand(i));
1099 
1100  return getWithOperands(NewOps);
1101 }
1102 
1103 /// getWithOperands - This returns the current constant expression with the
1104 /// operands replaced with the specified values. The specified array must
1105 /// have the same number of operands as our current one.
1108  assert(Ops.size() == getNumOperands() && "Operand count mismatch!");
1109  bool AnyChange = Ty != getType();
1110  for (unsigned i = 0; i != Ops.size(); ++i)
1111  AnyChange |= Ops[i] != getOperand(i);
1112 
1113  if (!AnyChange) // No operands changed, return self.
1114  return const_cast<ConstantExpr*>(this);
1115 
1116  switch (getOpcode()) {
1117  case Instruction::Trunc:
1118  case Instruction::ZExt:
1119  case Instruction::SExt:
1120  case Instruction::FPTrunc:
1121  case Instruction::FPExt:
1122  case Instruction::UIToFP:
1123  case Instruction::SIToFP:
1124  case Instruction::FPToUI:
1125  case Instruction::FPToSI:
1126  case Instruction::PtrToInt:
1127  case Instruction::IntToPtr:
1128  case Instruction::BitCast:
1129  case Instruction::AddrSpaceCast:
1130  return ConstantExpr::getCast(getOpcode(), Ops[0], Ty);
1131  case Instruction::Select:
1132  return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2]);
1133  case Instruction::InsertElement:
1134  return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2]);
1136  return ConstantExpr::getExtractElement(Ops[0], Ops[1]);
1137  case Instruction::InsertValue:
1138  return ConstantExpr::getInsertValue(Ops[0], Ops[1], getIndices());
1139  case Instruction::ExtractValue:
1140  return ConstantExpr::getExtractValue(Ops[0], getIndices());
1141  case Instruction::ShuffleVector:
1142  return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]);
1143  case Instruction::GetElementPtr:
1144  return ConstantExpr::getGetElementPtr(Ops[0], Ops.slice(1),
1145  cast<GEPOperator>(this)->isInBounds());
1146  case Instruction::ICmp:
1147  case Instruction::FCmp:
1148  return ConstantExpr::getCompare(getPredicate(), Ops[0], Ops[1]);
1149  default:
1150  assert(getNumOperands() == 2 && "Must be binary operator?");
1151  return ConstantExpr::get(getOpcode(), Ops[0], Ops[1], SubclassOptionalData);
1152  }
1153 }
1154 
1155 
1156 //===----------------------------------------------------------------------===//
1157 // isValueValidForType implementations
1158 
1159 bool ConstantInt::isValueValidForType(Type *Ty, uint64_t Val) {
1160  unsigned NumBits = Ty->getIntegerBitWidth(); // assert okay
1161  if (Ty->isIntegerTy(1))
1162  return Val == 0 || Val == 1;
1163  if (NumBits >= 64)
1164  return true; // always true, has to fit in largest type
1165  uint64_t Max = (1ll << NumBits) - 1;
1166  return Val <= Max;
1167 }
1168 
1169 bool ConstantInt::isValueValidForType(Type *Ty, int64_t Val) {
1170  unsigned NumBits = Ty->getIntegerBitWidth();
1171  if (Ty->isIntegerTy(1))
1172  return Val == 0 || Val == 1 || Val == -1;
1173  if (NumBits >= 64)
1174  return true; // always true, has to fit in largest type
1175  int64_t Min = -(1ll << (NumBits-1));
1176  int64_t Max = (1ll << (NumBits-1)) - 1;
1177  return (Val >= Min && Val <= Max);
1178 }
1179 
1181  // convert modifies in place, so make a copy.
1182  APFloat Val2 = APFloat(Val);
1183  bool losesInfo;
1184  switch (Ty->getTypeID()) {
1185  default:
1186  return false; // These can't be represented as floating point!
1187 
1188  // FIXME rounding mode needs to be more flexible
1189  case Type::HalfTyID: {
1190  if (&Val2.getSemantics() == &APFloat::IEEEhalf)
1191  return true;
1193  return !losesInfo;
1194  }
1195  case Type::FloatTyID: {
1196  if (&Val2.getSemantics() == &APFloat::IEEEsingle)
1197  return true;
1199  return !losesInfo;
1200  }
1201  case Type::DoubleTyID: {
1202  if (&Val2.getSemantics() == &APFloat::IEEEhalf ||
1203  &Val2.getSemantics() == &APFloat::IEEEsingle ||
1204  &Val2.getSemantics() == &APFloat::IEEEdouble)
1205  return true;
1207  return !losesInfo;
1208  }
1209  case Type::X86_FP80TyID:
1210  return &Val2.getSemantics() == &APFloat::IEEEhalf ||
1211  &Val2.getSemantics() == &APFloat::IEEEsingle ||
1212  &Val2.getSemantics() == &APFloat::IEEEdouble ||
1214  case Type::FP128TyID:
1215  return &Val2.getSemantics() == &APFloat::IEEEhalf ||
1216  &Val2.getSemantics() == &APFloat::IEEEsingle ||
1217  &Val2.getSemantics() == &APFloat::IEEEdouble ||
1218  &Val2.getSemantics() == &APFloat::IEEEquad;
1219  case Type::PPC_FP128TyID:
1220  return &Val2.getSemantics() == &APFloat::IEEEhalf ||
1221  &Val2.getSemantics() == &APFloat::IEEEsingle ||
1222  &Val2.getSemantics() == &APFloat::IEEEdouble ||
1224  }
1225 }
1226 
1227 
1228 //===----------------------------------------------------------------------===//
1229 // Factory Function Implementation
1230 
1232  assert((Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()) &&
1233  "Cannot create an aggregate zero of non-aggregate type!");
1234 
1235  ConstantAggregateZero *&Entry = Ty->getContext().pImpl->CAZConstants[Ty];
1236  if (Entry == 0)
1237  Entry = new ConstantAggregateZero(Ty);
1238 
1239  return Entry;
1240 }
1241 
1242 /// destroyConstant - Remove the constant from the constant table.
1243 ///
1245  getContext().pImpl->CAZConstants.erase(getType());
1247 }
1248 
1249 /// destroyConstant - Remove the constant from the constant table...
1250 ///
1254 }
1255 
1256 
1257 //---- ConstantStruct::get() implementation...
1258 //
1259 
1260 // destroyConstant - Remove the constant from the constant table...
1261 //
1265 }
1266 
1267 // destroyConstant - Remove the constant from the constant table...
1268 //
1272 }
1273 
1274 /// getSplatValue - If this is a splat vector constant, meaning that all of
1275 /// the elements have the same value, return that value. Otherwise return 0.
1277  assert(this->getType()->isVectorTy() && "Only valid for vectors!");
1278  if (isa<ConstantAggregateZero>(this))
1279  return getNullValue(this->getType()->getVectorElementType());
1280  if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this))
1281  return CV->getSplatValue();
1282  if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
1283  return CV->getSplatValue();
1284  return 0;
1285 }
1286 
1287 /// getSplatValue - If this is a splat constant, where all of the
1288 /// elements have the same value, return that value. Otherwise return null.
1290  // Check out first element.
1291  Constant *Elt = getOperand(0);
1292  // Then make sure all remaining elements point to the same value.
1293  for (unsigned I = 1, E = getNumOperands(); I < E; ++I)
1294  if (getOperand(I) != Elt)
1295  return 0;
1296  return Elt;
1297 }
1298 
1299 /// If C is a constant integer then return its value, otherwise C must be a
1300 /// vector of constant integers, all equal, and the common value is returned.
1302  if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
1303  return CI->getValue();
1304  assert(this->getSplatValue() && "Doesn't contain a unique integer!");
1305  const Constant *C = this->getAggregateElement(0U);
1306  assert(C && isa<ConstantInt>(C) && "Not a vector of numbers!");
1307  return cast<ConstantInt>(C)->getValue();
1308 }
1309 
1310 
1311 //---- ConstantPointerNull::get() implementation.
1312 //
1313 
1315  ConstantPointerNull *&Entry = Ty->getContext().pImpl->CPNConstants[Ty];
1316  if (Entry == 0)
1317  Entry = new ConstantPointerNull(Ty);
1318 
1319  return Entry;
1320 }
1321 
1322 // destroyConstant - Remove the constant from the constant table...
1323 //
1325  getContext().pImpl->CPNConstants.erase(getType());
1326  // Free the constant and any dangling references to it.
1328 }
1329 
1330 
1331 //---- UndefValue::get() implementation.
1332 //
1333 
1335  UndefValue *&Entry = Ty->getContext().pImpl->UVConstants[Ty];
1336  if (Entry == 0)
1337  Entry = new UndefValue(Ty);
1338 
1339  return Entry;
1340 }
1341 
1342 // destroyConstant - Remove the constant from the constant table.
1343 //
1345  // Free the constant and any dangling references to it.
1346  getContext().pImpl->UVConstants.erase(getType());
1348 }
1349 
1350 //---- BlockAddress::get() implementation.
1351 //
1352 
1354  assert(BB->getParent() != 0 && "Block must have a parent");
1355  return get(BB->getParent(), BB);
1356 }
1357 
1359  BlockAddress *&BA =
1360  F->getContext().pImpl->BlockAddresses[std::make_pair(F, BB)];
1361  if (BA == 0)
1362  BA = new BlockAddress(F, BB);
1363 
1364  assert(BA->getFunction() == F && "Basic block moved between functions");
1365  return BA;
1366 }
1367 
1368 BlockAddress::BlockAddress(Function *F, BasicBlock *BB)
1369 : Constant(Type::getInt8PtrTy(F->getContext()), Value::BlockAddressVal,
1370  &Op<0>(), 2) {
1371  setOperand(0, F);
1372  setOperand(1, BB);
1373  BB->AdjustBlockAddressRefCount(1);
1374 }
1375 
1376 
1377 // destroyConstant - Remove the constant from the constant table.
1378 //
1381  ->BlockAddresses.erase(std::make_pair(getFunction(), getBasicBlock()));
1382  getBasicBlock()->AdjustBlockAddressRefCount(-1);
1384 }
1385 
1387  // This could be replacing either the Basic Block or the Function. In either
1388  // case, we have to remove the map entry.
1389  Function *NewF = getFunction();
1390  BasicBlock *NewBB = getBasicBlock();
1391 
1392  if (U == &Op<0>())
1393  NewF = cast<Function>(To->stripPointerCasts());
1394  else
1395  NewBB = cast<BasicBlock>(To);
1396 
1397  // See if the 'new' entry already exists, if not, just update this in place
1398  // and return early.
1399  BlockAddress *&NewBA =
1400  getContext().pImpl->BlockAddresses[std::make_pair(NewF, NewBB)];
1401  if (NewBA == 0) {
1402  getBasicBlock()->AdjustBlockAddressRefCount(-1);
1403 
1404  // Remove the old entry, this can't cause the map to rehash (just a
1405  // tombstone will get added).
1406  getContext().pImpl->BlockAddresses.erase(std::make_pair(getFunction(),
1407  getBasicBlock()));
1408  NewBA = this;
1409  setOperand(0, NewF);
1410  setOperand(1, NewBB);
1411  getBasicBlock()->AdjustBlockAddressRefCount(1);
1412  return;
1413  }
1414 
1415  // Otherwise, I do need to replace this with an existing value.
1416  assert(NewBA != this && "I didn't contain From!");
1417 
1418  // Everyone using this now uses the replacement.
1419  replaceAllUsesWith(NewBA);
1420 
1421  destroyConstant();
1422 }
1423 
1424 //---- ConstantExpr::get() implementations.
1425 //
1426 
1427 /// This is a utility function to handle folding of casts and lookup of the
1428 /// cast in the ExprConstants map. It is used by the various get* methods below.
1429 static inline Constant *getFoldedCast(
1430  Instruction::CastOps opc, Constant *C, Type *Ty) {
1431  assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
1432  // Fold a few common cases
1433  if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty))
1434  return FC;
1435 
1436  LLVMContextImpl *pImpl = Ty->getContext().pImpl;
1437 
1438  // Look up the constant in the table first to ensure uniqueness.
1439  ExprMapKeyType Key(opc, C);
1440 
1441  return pImpl->ExprConstants.getOrCreate(Ty, Key);
1442 }
1443 
1446  assert(Instruction::isCast(opc) && "opcode out of range");
1447  assert(C && Ty && "Null arguments to getCast");
1448  assert(CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!");
1449 
1450  switch (opc) {
1451  default:
1452  llvm_unreachable("Invalid cast opcode");
1453  case Instruction::Trunc: return getTrunc(C, Ty);
1454  case Instruction::ZExt: return getZExt(C, Ty);
1455  case Instruction::SExt: return getSExt(C, Ty);
1456  case Instruction::FPTrunc: return getFPTrunc(C, Ty);
1457  case Instruction::FPExt: return getFPExtend(C, Ty);
1458  case Instruction::UIToFP: return getUIToFP(C, Ty);
1459  case Instruction::SIToFP: return getSIToFP(C, Ty);
1460  case Instruction::FPToUI: return getFPToUI(C, Ty);
1461  case Instruction::FPToSI: return getFPToSI(C, Ty);
1462  case Instruction::PtrToInt: return getPtrToInt(C, Ty);
1463  case Instruction::IntToPtr: return getIntToPtr(C, Ty);
1464  case Instruction::BitCast: return getBitCast(C, Ty);
1465  case Instruction::AddrSpaceCast: return getAddrSpaceCast(C, Ty);
1466  }
1467 }
1468 
1470  if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
1471  return getBitCast(C, Ty);
1472  return getZExt(C, Ty);
1473 }
1474 
1476  if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
1477  return getBitCast(C, Ty);
1478  return getSExt(C, Ty);
1479 }
1480 
1482  if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
1483  return getBitCast(C, Ty);
1484  return getTrunc(C, Ty);
1485 }
1486 
1488  assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
1489  assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) &&
1490  "Invalid cast");
1491 
1492  if (Ty->isIntOrIntVectorTy())
1493  return getPtrToInt(S, Ty);
1494 
1495  unsigned SrcAS = S->getType()->getPointerAddressSpace();
1496  if (Ty->isPtrOrPtrVectorTy() && SrcAS != Ty->getPointerAddressSpace())
1497  return getAddrSpaceCast(S, Ty);
1498 
1499  return getBitCast(S, Ty);
1500 }
1501 
1503  bool isSigned) {
1504  assert(C->getType()->isIntOrIntVectorTy() &&
1505  Ty->isIntOrIntVectorTy() && "Invalid cast");
1506  unsigned SrcBits = C->getType()->getScalarSizeInBits();
1507  unsigned DstBits = Ty->getScalarSizeInBits();
1508  Instruction::CastOps opcode =
1509  (SrcBits == DstBits ? Instruction::BitCast :
1510  (SrcBits > DstBits ? Instruction::Trunc :
1511  (isSigned ? Instruction::SExt : Instruction::ZExt)));
1512  return getCast(opcode, C, Ty);
1513 }
1514 
1516  assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
1517  "Invalid cast");
1518  unsigned SrcBits = C->getType()->getScalarSizeInBits();
1519  unsigned DstBits = Ty->getScalarSizeInBits();
1520  if (SrcBits == DstBits)
1521  return C; // Avoid a useless cast
1522  Instruction::CastOps opcode =
1523  (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt);
1524  return getCast(opcode, C, Ty);
1525 }
1526 
1528 #ifndef NDEBUG
1529  bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1530  bool toVec = Ty->getTypeID() == Type::VectorTyID;
1531 #endif
1532  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1533  assert(C->getType()->isIntOrIntVectorTy() && "Trunc operand must be integer");
1534  assert(Ty->isIntOrIntVectorTy() && "Trunc produces only integral");
1535  assert(C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
1536  "SrcTy must be larger than DestTy for Trunc!");
1537 
1538  return getFoldedCast(Instruction::Trunc, C, Ty);
1539 }
1540 
1542 #ifndef NDEBUG
1543  bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1544  bool toVec = Ty->getTypeID() == Type::VectorTyID;
1545 #endif
1546  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1547  assert(C->getType()->isIntOrIntVectorTy() && "SExt operand must be integral");
1548  assert(Ty->isIntOrIntVectorTy() && "SExt produces only integer");
1549  assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
1550  "SrcTy must be smaller than DestTy for SExt!");
1551 
1552  return getFoldedCast(Instruction::SExt, C, Ty);
1553 }
1554 
1556 #ifndef NDEBUG
1557  bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1558  bool toVec = Ty->getTypeID() == Type::VectorTyID;
1559 #endif
1560  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1561  assert(C->getType()->isIntOrIntVectorTy() && "ZEXt operand must be integral");
1562  assert(Ty->isIntOrIntVectorTy() && "ZExt produces only integer");
1563  assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
1564  "SrcTy must be smaller than DestTy for ZExt!");
1565 
1566  return getFoldedCast(Instruction::ZExt, C, Ty);
1567 }
1568 
1570 #ifndef NDEBUG
1571  bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1572  bool toVec = Ty->getTypeID() == Type::VectorTyID;
1573 #endif
1574  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1575  assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
1577  "This is an illegal floating point truncation!");
1578  return getFoldedCast(Instruction::FPTrunc, C, Ty);
1579 }
1580 
1582 #ifndef NDEBUG
1583  bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1584  bool toVec = Ty->getTypeID() == Type::VectorTyID;
1585 #endif
1586  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1587  assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
1589  "This is an illegal floating point extension!");
1590  return getFoldedCast(Instruction::FPExt, C, Ty);
1591 }
1592 
1594 #ifndef NDEBUG
1595  bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1596  bool toVec = Ty->getTypeID() == Type::VectorTyID;
1597 #endif
1598  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1599  assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
1600  "This is an illegal uint to floating point cast!");
1601  return getFoldedCast(Instruction::UIToFP, C, Ty);
1602 }
1603 
1605 #ifndef NDEBUG
1606  bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1607  bool toVec = Ty->getTypeID() == Type::VectorTyID;
1608 #endif
1609  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1610  assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
1611  "This is an illegal sint to floating point cast!");
1612  return getFoldedCast(Instruction::SIToFP, C, Ty);
1613 }
1614 
1616 #ifndef NDEBUG
1617  bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1618  bool toVec = Ty->getTypeID() == Type::VectorTyID;
1619 #endif
1620  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1621  assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
1622  "This is an illegal floating point to uint cast!");
1623  return getFoldedCast(Instruction::FPToUI, C, Ty);
1624 }
1625 
1627 #ifndef NDEBUG
1628  bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1629  bool toVec = Ty->getTypeID() == Type::VectorTyID;
1630 #endif
1631  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1632  assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
1633  "This is an illegal floating point to sint cast!");
1634  return getFoldedCast(Instruction::FPToSI, C, Ty);
1635 }
1636 
1638  assert(C->getType()->getScalarType()->isPointerTy() &&
1639  "PtrToInt source must be pointer or pointer vector");
1640  assert(DstTy->getScalarType()->isIntegerTy() &&
1641  "PtrToInt destination must be integer or integer vector");
1642  assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy));
1643  if (isa<VectorType>(C->getType()))
1644  assert(C->getType()->getVectorNumElements()==DstTy->getVectorNumElements()&&
1645  "Invalid cast between a different number of vector elements");
1646  return getFoldedCast(Instruction::PtrToInt, C, DstTy);
1647 }
1648 
1650  assert(C->getType()->getScalarType()->isIntegerTy() &&
1651  "IntToPtr source must be integer or integer vector");
1652  assert(DstTy->getScalarType()->isPointerTy() &&
1653  "IntToPtr destination must be a pointer or pointer vector");
1654  assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy));
1655  if (isa<VectorType>(C->getType()))
1656  assert(C->getType()->getVectorNumElements()==DstTy->getVectorNumElements()&&
1657  "Invalid cast between a different number of vector elements");
1658  return getFoldedCast(Instruction::IntToPtr, C, DstTy);
1659 }
1660 
1662  assert(CastInst::castIsValid(Instruction::BitCast, C, DstTy) &&
1663  "Invalid constantexpr bitcast!");
1664 
1665  // It is common to ask for a bitcast of a value to its own type, handle this
1666  // speedily.
1667  if (C->getType() == DstTy) return C;
1668 
1669  return getFoldedCast(Instruction::BitCast, C, DstTy);
1670 }
1671 
1673  assert(CastInst::castIsValid(Instruction::AddrSpaceCast, C, DstTy) &&
1674  "Invalid constantexpr addrspacecast!");
1675 
1676  return getFoldedCast(Instruction::AddrSpaceCast, C, DstTy);
1677 }
1678 
1679 Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2,
1680  unsigned Flags) {
1681  // Check the operands for consistency first.
1682  assert(Opcode >= Instruction::BinaryOpsBegin &&
1683  Opcode < Instruction::BinaryOpsEnd &&
1684  "Invalid opcode in binary constant expression");
1685  assert(C1->getType() == C2->getType() &&
1686  "Operand types in binary constant expression should match");
1687 
1688 #ifndef NDEBUG
1689  switch (Opcode) {
1690  case Instruction::Add:
1691  case Instruction::Sub:
1692  case Instruction::Mul:
1693  assert(C1->getType() == C2->getType() && "Op types should be identical!");
1694  assert(C1->getType()->isIntOrIntVectorTy() &&
1695  "Tried to create an integer operation on a non-integer type!");
1696  break;
1697  case Instruction::FAdd:
1698  case Instruction::FSub:
1699  case Instruction::FMul:
1700  assert(C1->getType() == C2->getType() && "Op types should be identical!");
1701  assert(C1->getType()->isFPOrFPVectorTy() &&
1702  "Tried to create a floating-point operation on a "
1703  "non-floating-point type!");
1704  break;
1705  case Instruction::UDiv:
1706  case Instruction::SDiv:
1707  assert(C1->getType() == C2->getType() && "Op types should be identical!");
1708  assert(C1->getType()->isIntOrIntVectorTy() &&
1709  "Tried to create an arithmetic operation on a non-arithmetic type!");
1710  break;
1711  case Instruction::FDiv:
1712  assert(C1->getType() == C2->getType() && "Op types should be identical!");
1713  assert(C1->getType()->isFPOrFPVectorTy() &&
1714  "Tried to create an arithmetic operation on a non-arithmetic type!");
1715  break;
1716  case Instruction::URem:
1717  case Instruction::SRem:
1718  assert(C1->getType() == C2->getType() && "Op types should be identical!");
1719  assert(C1->getType()->isIntOrIntVectorTy() &&
1720  "Tried to create an arithmetic operation on a non-arithmetic type!");
1721  break;
1722  case Instruction::FRem:
1723  assert(C1->getType() == C2->getType() && "Op types should be identical!");
1724  assert(C1->getType()->isFPOrFPVectorTy() &&
1725  "Tried to create an arithmetic operation on a non-arithmetic type!");
1726  break;
1727  case Instruction::And:
1728  case Instruction::Or:
1729  case Instruction::Xor:
1730  assert(C1->getType() == C2->getType() && "Op types should be identical!");
1731  assert(C1->getType()->isIntOrIntVectorTy() &&
1732  "Tried to create a logical operation on a non-integral type!");
1733  break;
1734  case Instruction::Shl:
1735  case Instruction::LShr:
1736  case Instruction::AShr:
1737  assert(C1->getType() == C2->getType() && "Op types should be identical!");
1738  assert(C1->getType()->isIntOrIntVectorTy() &&
1739  "Tried to create a shift operation on a non-integer type!");
1740  break;
1741  default:
1742  break;
1743  }
1744 #endif
1745 
1746  if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))
1747  return FC; // Fold a few common cases.
1748 
1749  Constant *ArgVec[] = { C1, C2 };
1750  ExprMapKeyType Key(Opcode, ArgVec, 0, Flags);
1751 
1752  LLVMContextImpl *pImpl = C1->getContext().pImpl;
1753  return pImpl->ExprConstants.getOrCreate(C1->getType(), Key);
1754 }
1755 
1757  // sizeof is implemented as: (i64) gep (Ty*)null, 1
1758  // Note that a non-inbounds gep is used, as null isn't within any object.
1760  Constant *GEP = getGetElementPtr(
1762  return getPtrToInt(GEP,
1763  Type::getInt64Ty(Ty->getContext()));
1764 }
1765 
1767  // alignof is implemented as: (i64) gep ({i1,Ty}*)null, 0, 1
1768  // Note that a non-inbounds gep is used, as null isn't within any object.
1769  Type *AligningTy =
1770  StructType::get(Type::getInt1Ty(Ty->getContext()), Ty, NULL);
1771  Constant *NullPtr = Constant::getNullValue(AligningTy->getPointerTo());
1774  Constant *Indices[2] = { Zero, One };
1775  Constant *GEP = getGetElementPtr(NullPtr, Indices);
1776  return getPtrToInt(GEP,
1777  Type::getInt64Ty(Ty->getContext()));
1778 }
1779 
1782  FieldNo));
1783 }
1784 
1786  // offsetof is implemented as: (i64) gep (Ty*)null, 0, FieldNo
1787  // Note that a non-inbounds gep is used, as null isn't within any object.
1788  Constant *GEPIdx[] = {
1790  FieldNo
1791  };
1792  Constant *GEP = getGetElementPtr(
1794  return getPtrToInt(GEP,
1795  Type::getInt64Ty(Ty->getContext()));
1796 }
1797 
1799  Constant *C1, Constant *C2) {
1800  assert(C1->getType() == C2->getType() && "Op types should be identical!");
1801 
1802  switch (Predicate) {
1803  default: llvm_unreachable("Invalid CmpInst predicate");
1809  case CmpInst::FCMP_TRUE:
1810  return getFCmp(Predicate, C1, C2);
1811 
1815  case CmpInst::ICMP_SLE:
1816  return getICmp(Predicate, C1, C2);
1817  }
1818 }
1819 
1821  assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands");
1822 
1823  if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2))
1824  return SC; // Fold common cases
1825 
1826  Constant *ArgVec[] = { C, V1, V2 };
1827  ExprMapKeyType Key(Instruction::Select, ArgVec);
1828 
1829  LLVMContextImpl *pImpl = C->getContext().pImpl;
1830  return pImpl->ExprConstants.getOrCreate(V1->getType(), Key);
1831 }
1832 
1834  bool InBounds) {
1835  assert(C->getType()->isPtrOrPtrVectorTy() &&
1836  "Non-pointer type for constant GetElementPtr expression");
1837 
1838  if (Constant *FC = ConstantFoldGetElementPtr(C, InBounds, Idxs))
1839  return FC; // Fold a few common cases.
1840 
1841  // Get the result type of the getelementptr!
1843  assert(Ty && "GEP indices invalid!");
1844  unsigned AS = C->getType()->getPointerAddressSpace();
1845  Type *ReqTy = Ty->getPointerTo(AS);
1846  if (VectorType *VecTy = dyn_cast<VectorType>(C->getType()))
1847  ReqTy = VectorType::get(ReqTy, VecTy->getNumElements());
1848 
1849  // Look up the constant in the table first to ensure uniqueness
1850  std::vector<Constant*> ArgVec;
1851  ArgVec.reserve(1 + Idxs.size());
1852  ArgVec.push_back(C);
1853  for (unsigned i = 0, e = Idxs.size(); i != e; ++i) {
1854  assert(Idxs[i]->getType()->isVectorTy() == ReqTy->isVectorTy() &&
1855  "getelementptr index type missmatch");
1856  assert((!Idxs[i]->getType()->isVectorTy() ||
1857  ReqTy->getVectorNumElements() ==
1858  Idxs[i]->getType()->getVectorNumElements()) &&
1859  "getelementptr index type missmatch");
1860  ArgVec.push_back(cast<Constant>(Idxs[i]));
1861  }
1862  const ExprMapKeyType Key(Instruction::GetElementPtr, ArgVec, 0,
1863  InBounds ? GEPOperator::IsInBounds : 0);
1864 
1865  LLVMContextImpl *pImpl = C->getContext().pImpl;
1866  return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
1867 }
1868 
1869 Constant *
1870 ConstantExpr::getICmp(unsigned short pred, Constant *LHS, Constant *RHS) {
1871  assert(LHS->getType() == RHS->getType());
1872  assert(pred >= ICmpInst::FIRST_ICMP_PREDICATE &&
1873  pred <= ICmpInst::LAST_ICMP_PREDICATE && "Invalid ICmp Predicate");
1874 
1875  if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
1876  return FC; // Fold a few common cases...
1877 
1878  // Look up the constant in the table first to ensure uniqueness
1879  Constant *ArgVec[] = { LHS, RHS };
1880  // Get the key type with both the opcode and predicate
1881  const ExprMapKeyType Key(Instruction::ICmp, ArgVec, pred);
1882 
1883  Type *ResultTy = Type::getInt1Ty(LHS->getContext());
1884  if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
1885  ResultTy = VectorType::get(ResultTy, VT->getNumElements());
1886 
1887  LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
1888  return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
1889 }
1890 
1891 Constant *
1892 ConstantExpr::getFCmp(unsigned short pred, Constant *LHS, Constant *RHS) {
1893  assert(LHS->getType() == RHS->getType());
1894  assert(pred <= FCmpInst::LAST_FCMP_PREDICATE && "Invalid FCmp Predicate");
1895 
1896  if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
1897  return FC; // Fold a few common cases...
1898 
1899  // Look up the constant in the table first to ensure uniqueness
1900  Constant *ArgVec[] = { LHS, RHS };
1901  // Get the key type with both the opcode and predicate
1902  const ExprMapKeyType Key(Instruction::FCmp, ArgVec, pred);
1903 
1904  Type *ResultTy = Type::getInt1Ty(LHS->getContext());
1905  if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
1906  ResultTy = VectorType::get(ResultTy, VT->getNumElements());
1907 
1908  LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
1909  return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
1910 }
1911 
1913  assert(Val->getType()->isVectorTy() &&
1914  "Tried to create extractelement operation on non-vector type!");
1915  assert(Idx->getType()->isIntegerTy(32) &&
1916  "Extractelement index must be i32 type!");
1917 
1919  return FC; // Fold a few common cases.
1920 
1921  // Look up the constant in the table first to ensure uniqueness
1922  Constant *ArgVec[] = { Val, Idx };
1923  const ExprMapKeyType Key(Instruction::ExtractElement, ArgVec);
1924 
1925  LLVMContextImpl *pImpl = Val->getContext().pImpl;
1926  Type *ReqTy = Val->getType()->getVectorElementType();
1927  return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
1928 }
1929 
1931  Constant *Idx) {
1932  assert(Val->getType()->isVectorTy() &&
1933  "Tried to create insertelement operation on non-vector type!");
1934  assert(Elt->getType() == Val->getType()->getVectorElementType() &&
1935  "Insertelement types must match!");
1936  assert(Idx->getType()->isIntegerTy(32) &&
1937  "Insertelement index must be i32 type!");
1938 
1939  if (Constant *FC = ConstantFoldInsertElementInstruction(Val, Elt, Idx))
1940  return FC; // Fold a few common cases.
1941  // Look up the constant in the table first to ensure uniqueness
1942  Constant *ArgVec[] = { Val, Elt, Idx };
1943  const ExprMapKeyType Key(Instruction::InsertElement, ArgVec);
1944 
1945  LLVMContextImpl *pImpl = Val->getContext().pImpl;
1946  return pImpl->ExprConstants.getOrCreate(Val->getType(), Key);
1947 }
1948 
1950  Constant *Mask) {
1951  assert(ShuffleVectorInst::isValidOperands(V1, V2, Mask) &&
1952  "Invalid shuffle vector constant expr operands!");
1953 
1954  if (Constant *FC = ConstantFoldShuffleVectorInstruction(V1, V2, Mask))
1955  return FC; // Fold a few common cases.
1956 
1957  unsigned NElts = Mask->getType()->getVectorNumElements();
1958  Type *EltTy = V1->getType()->getVectorElementType();
1959  Type *ShufTy = VectorType::get(EltTy, NElts);
1960 
1961  // Look up the constant in the table first to ensure uniqueness
1962  Constant *ArgVec[] = { V1, V2, Mask };
1963  const ExprMapKeyType Key(Instruction::ShuffleVector, ArgVec);
1964 
1965  LLVMContextImpl *pImpl = ShufTy->getContext().pImpl;
1966  return pImpl->ExprConstants.getOrCreate(ShufTy, Key);
1967 }
1968 
1970  ArrayRef<unsigned> Idxs) {
1971  assert(Agg->getType()->isFirstClassType() &&
1972  "Non-first-class type for constant insertvalue expression");
1973 
1975  Idxs) == Val->getType() &&
1976  "insertvalue indices invalid!");
1977  Type *ReqTy = Val->getType();
1978 
1979  if (Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs))
1980  return FC;
1981 
1982  Constant *ArgVec[] = { Agg, Val };
1983  const ExprMapKeyType Key(Instruction::InsertValue, ArgVec, 0, 0, Idxs);
1984 
1985  LLVMContextImpl *pImpl = Agg->getContext().pImpl;
1986  return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
1987 }
1988 
1990  ArrayRef<unsigned> Idxs) {
1991  assert(Agg->getType()->isFirstClassType() &&
1992  "Tried to create extractelement operation on non-first-class type!");
1993 
1994  Type *ReqTy = ExtractValueInst::getIndexedType(Agg->getType(), Idxs);
1995  (void)ReqTy;
1996  assert(ReqTy && "extractvalue indices invalid!");
1997 
1998  assert(Agg->getType()->isFirstClassType() &&
1999  "Non-first-class type for constant extractvalue expression");
2001  return FC;
2002 
2003  Constant *ArgVec[] = { Agg };
2004  const ExprMapKeyType Key(Instruction::ExtractValue, ArgVec, 0, 0, Idxs);
2005 
2006  LLVMContextImpl *pImpl = Agg->getContext().pImpl;
2007  return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
2008 }
2009 
2010 Constant *ConstantExpr::getNeg(Constant *C, bool HasNUW, bool HasNSW) {
2011  assert(C->getType()->isIntOrIntVectorTy() &&
2012  "Cannot NEG a nonintegral value!");
2014  C, HasNUW, HasNSW);
2015 }
2016 
2018  assert(C->getType()->isFPOrFPVectorTy() &&
2019  "Cannot FNEG a non-floating-point value!");
2021 }
2022 
2024  assert(C->getType()->isIntOrIntVectorTy() &&
2025  "Cannot NOT a nonintegral value!");
2026  return get(Instruction::Xor, C, Constant::getAllOnesValue(C->getType()));
2027 }
2028 
2030  bool HasNUW, bool HasNSW) {
2031  unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2033  return get(Instruction::Add, C1, C2, Flags);
2034 }
2035 
2037  return get(Instruction::FAdd, C1, C2);
2038 }
2039 
2041  bool HasNUW, bool HasNSW) {
2042  unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2044  return get(Instruction::Sub, C1, C2, Flags);
2045 }
2046 
2048  return get(Instruction::FSub, C1, C2);
2049 }
2050 
2052  bool HasNUW, bool HasNSW) {
2053  unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2055  return get(Instruction::Mul, C1, C2, Flags);
2056 }
2057 
2059  return get(Instruction::FMul, C1, C2);
2060 }
2061 
2063  return get(Instruction::UDiv, C1, C2,
2064  isExact ? PossiblyExactOperator::IsExact : 0);
2065 }
2066 
2068  return get(Instruction::SDiv, C1, C2,
2069  isExact ? PossiblyExactOperator::IsExact : 0);
2070 }
2071 
2073  return get(Instruction::FDiv, C1, C2);
2074 }
2075 
2077  return get(Instruction::URem, C1, C2);
2078 }
2079 
2081  return get(Instruction::SRem, C1, C2);
2082 }
2083 
2085  return get(Instruction::FRem, C1, C2);
2086 }
2087 
2089  return get(Instruction::And, C1, C2);
2090 }
2091 
2093  return get(Instruction::Or, C1, C2);
2094 }
2095 
2097  return get(Instruction::Xor, C1, C2);
2098 }
2099 
2101  bool HasNUW, bool HasNSW) {
2102  unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2104  return get(Instruction::Shl, C1, C2, Flags);
2105 }
2106 
2108  return get(Instruction::LShr, C1, C2,
2109  isExact ? PossiblyExactOperator::IsExact : 0);
2110 }
2111 
2113  return get(Instruction::AShr, C1, C2,
2114  isExact ? PossiblyExactOperator::IsExact : 0);
2115 }
2116 
2117 /// getBinOpIdentity - Return the identity for the given binary operation,
2118 /// i.e. a constant C such that X op C = X and C op X = X for every X. It
2119 /// returns null if the operator doesn't have an identity.
2121  switch (Opcode) {
2122  default:
2123  // Doesn't have an identity.
2124  return 0;
2125 
2126  case Instruction::Add:
2127  case Instruction::Or:
2128  case Instruction::Xor:
2129  return Constant::getNullValue(Ty);
2130 
2131  case Instruction::Mul:
2132  return ConstantInt::get(Ty, 1);
2133 
2134  case Instruction::And:
2135  return Constant::getAllOnesValue(Ty);
2136  }
2137 }
2138 
2139 /// getBinOpAbsorber - Return the absorbing element for the given binary
2140 /// operation, i.e. a constant C such that X op C = C and C op X = C for
2141 /// every X. For example, this returns zero for integer multiplication.
2142 /// It returns null if the operator doesn't have an absorbing element.
2144  switch (Opcode) {
2145  default:
2146  // Doesn't have an absorber.
2147  return 0;
2148 
2149  case Instruction::Or:
2150  return Constant::getAllOnesValue(Ty);
2151 
2152  case Instruction::And:
2153  case Instruction::Mul:
2154  return Constant::getNullValue(Ty);
2155  }
2156 }
2157 
2158 // destroyConstant - Remove the constant from the constant table...
2159 //
2161  getType()->getContext().pImpl->ExprConstants.remove(this);
2163 }
2164 
2165 const char *ConstantExpr::getOpcodeName() const {
2167 }
2168 
2169 
2170 
2171 GetElementPtrConstantExpr::
2172 GetElementPtrConstantExpr(Constant *C, ArrayRef<Constant*> IdxList,
2173  Type *DestTy)
2174  : ConstantExpr(DestTy, Instruction::GetElementPtr,
2176  - (IdxList.size()+1), IdxList.size()+1) {
2177  OperandList[0] = C;
2178  for (unsigned i = 0, E = IdxList.size(); i != E; ++i)
2179  OperandList[i+1] = IdxList[i];
2180 }
2181 
2182 //===----------------------------------------------------------------------===//
2183 // ConstantData* implementations
2184 
2185 void ConstantDataArray::anchor() {}
2186 void ConstantDataVector::anchor() {}
2187 
2188 /// getElementType - Return the element type of the array/vector.
2190  return getType()->getElementType();
2191 }
2192 
2194  return StringRef(DataElements, getNumElements()*getElementByteSize());
2195 }
2196 
2197 /// isElementTypeCompatible - Return true if a ConstantDataSequential can be
2198 /// formed with a vector or array of the specified element type.
2199 /// ConstantDataArray only works with normal float and int types that are
2200 /// stored densely in memory, not with things like i42 or x86_f80.
2202  if (Ty->isFloatTy() || Ty->isDoubleTy()) return true;
2203  if (const IntegerType *IT = dyn_cast<IntegerType>(Ty)) {
2204  switch (IT->getBitWidth()) {
2205  case 8:
2206  case 16:
2207  case 32:
2208  case 64:
2209  return true;
2210  default: break;
2211  }
2212  }
2213  return false;
2214 }
2215 
2216 /// getNumElements - Return the number of elements in the array or vector.
2218  if (ArrayType *AT = dyn_cast<ArrayType>(getType()))
2219  return AT->getNumElements();
2220  return getType()->getVectorNumElements();
2221 }
2222 
2223 
2224 /// getElementByteSize - Return the size in bytes of the elements in the data.
2226  return getElementType()->getPrimitiveSizeInBits()/8;
2227 }
2228 
2229 /// getElementPointer - Return the start of the specified element.
2230 const char *ConstantDataSequential::getElementPointer(unsigned Elt) const {
2231  assert(Elt < getNumElements() && "Invalid Elt");
2232  return DataElements+Elt*getElementByteSize();
2233 }
2234 
2235 
2236 /// isAllZeros - return true if the array is empty or all zeros.
2237 static bool isAllZeros(StringRef Arr) {
2238  for (StringRef::iterator I = Arr.begin(), E = Arr.end(); I != E; ++I)
2239  if (*I != 0)
2240  return false;
2241  return true;
2242 }
2243 
2244 /// getImpl - This is the underlying implementation of all of the
2245 /// ConstantDataSequential::get methods. They all thunk down to here, providing
2246 /// the correct element type. We take the bytes in as a StringRef because
2247 /// we *want* an underlying "char*" to avoid TBAA type punning violations.
2250  // If the elements are all zero or there are no elements, return a CAZ, which
2251  // is more dense and canonical.
2252  if (isAllZeros(Elements))
2253  return ConstantAggregateZero::get(Ty);
2254 
2255  // Do a lookup to see if we have already formed one of these.
2257  Ty->getContext().pImpl->CDSConstants.GetOrCreateValue(Elements);
2258 
2259  // The bucket can point to a linked list of different CDS's that have the same
2260  // body but different types. For example, 0,0,0,1 could be a 4 element array
2261  // of i8, or a 1-element array of i32. They'll both end up in the same
2262  /// StringMap bucket, linked up by their Next pointers. Walk the list.
2263  ConstantDataSequential **Entry = &Slot.getValue();
2264  for (ConstantDataSequential *Node = *Entry; Node != 0;
2265  Entry = &Node->Next, Node = *Entry)
2266  if (Node->getType() == Ty)
2267  return Node;
2268 
2269  // Okay, we didn't get a hit. Create a node of the right class, link it in,
2270  // and return it.
2271  if (isa<ArrayType>(Ty))
2272  return *Entry = new ConstantDataArray(Ty, Slot.getKeyData());
2273 
2274  assert(isa<VectorType>(Ty));
2275  return *Entry = new ConstantDataVector(Ty, Slot.getKeyData());
2276 }
2277 
2279  // Remove the constant from the StringMap.
2280  StringMap<ConstantDataSequential*> &CDSConstants =
2282 
2284  CDSConstants.find(getRawDataValues());
2285 
2286  assert(Slot != CDSConstants.end() && "CDS not found in uniquing table");
2287 
2288  ConstantDataSequential **Entry = &Slot->getValue();
2289 
2290  // Remove the entry from the hash table.
2291  if ((*Entry)->Next == 0) {
2292  // If there is only one value in the bucket (common case) it must be this
2293  // entry, and removing the entry should remove the bucket completely.
2294  assert((*Entry) == this && "Hash mismatch in ConstantDataSequential");
2295  getContext().pImpl->CDSConstants.erase(Slot);
2296  } else {
2297  // Otherwise, there are multiple entries linked off the bucket, unlink the
2298  // node we care about but keep the bucket around.
2299  for (ConstantDataSequential *Node = *Entry; ;
2300  Entry = &Node->Next, Node = *Entry) {
2301  assert(Node && "Didn't find entry in its uniquing hash table!");
2302  // If we found our entry, unlink it from the list and we're done.
2303  if (Node == this) {
2304  *Entry = Node->Next;
2305  break;
2306  }
2307  }
2308  }
2309 
2310  // If we were part of a list, make sure that we don't delete the list that is
2311  // still owned by the uniquing map.
2312  Next = 0;
2313 
2314  // Finally, actually delete it.
2316 }
2317 
2318 /// get() constructors - Return a constant with array type with an element
2319 /// count and element type matching the ArrayRef passed in. Note that this
2320 /// can return a ConstantAggregateZero object.
2322  Type *Ty = ArrayType::get(Type::getInt8Ty(Context), Elts.size());
2323  const char *Data = reinterpret_cast<const char *>(Elts.data());
2324  return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*1), Ty);
2325 }
2327  Type *Ty = ArrayType::get(Type::getInt16Ty(Context), Elts.size());
2328  const char *Data = reinterpret_cast<const char *>(Elts.data());
2329  return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*2), Ty);
2330 }
2332  Type *Ty = ArrayType::get(Type::getInt32Ty(Context), Elts.size());
2333  const char *Data = reinterpret_cast<const char *>(Elts.data());
2334  return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty);
2335 }
2337  Type *Ty = ArrayType::get(Type::getInt64Ty(Context), Elts.size());
2338  const char *Data = reinterpret_cast<const char *>(Elts.data());
2339  return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty);
2340 }
2342  Type *Ty = ArrayType::get(Type::getFloatTy(Context), Elts.size());
2343  const char *Data = reinterpret_cast<const char *>(Elts.data());
2344  return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty);
2345 }
2347  Type *Ty = ArrayType::get(Type::getDoubleTy(Context), Elts.size());
2348  const char *Data = reinterpret_cast<const char *>(Elts.data());
2349  return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty);
2350 }
2351 
2352 /// getString - This method constructs a CDS and initializes it with a text
2353 /// string. The default behavior (AddNull==true) causes a null terminator to
2354 /// be placed at the end of the array (increasing the length of the string by
2355 /// one more than the StringRef would normally indicate. Pass AddNull=false
2356 /// to disable this behavior.
2358  StringRef Str, bool AddNull) {
2359  if (!AddNull) {
2360  const uint8_t *Data = reinterpret_cast<const uint8_t *>(Str.data());
2361  return get(Context, ArrayRef<uint8_t>(const_cast<uint8_t *>(Data),
2362  Str.size()));
2363  }
2364 
2365  SmallVector<uint8_t, 64> ElementVals;
2366  ElementVals.append(Str.begin(), Str.end());
2367  ElementVals.push_back(0);
2368  return get(Context, ElementVals);
2369 }
2370 
2371 /// get() constructors - Return a constant with vector type with an element
2372 /// count and element type matching the ArrayRef passed in. Note that this
2373 /// can return a ConstantAggregateZero object.
2375  Type *Ty = VectorType::get(Type::getInt8Ty(Context), Elts.size());
2376  const char *Data = reinterpret_cast<const char *>(Elts.data());
2377  return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*1), Ty);
2378 }
2380  Type *Ty = VectorType::get(Type::getInt16Ty(Context), Elts.size());
2381  const char *Data = reinterpret_cast<const char *>(Elts.data());
2382  return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*2), Ty);
2383 }
2385  Type *Ty = VectorType::get(Type::getInt32Ty(Context), Elts.size());
2386  const char *Data = reinterpret_cast<const char *>(Elts.data());
2387  return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty);
2388 }
2390  Type *Ty = VectorType::get(Type::getInt64Ty(Context), Elts.size());
2391  const char *Data = reinterpret_cast<const char *>(Elts.data());
2392  return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty);
2393 }
2395  Type *Ty = VectorType::get(Type::getFloatTy(Context), Elts.size());
2396  const char *Data = reinterpret_cast<const char *>(Elts.data());
2397  return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty);
2398 }
2400  Type *Ty = VectorType::get(Type::getDoubleTy(Context), Elts.size());
2401  const char *Data = reinterpret_cast<const char *>(Elts.data());
2402  return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty);
2403 }
2404 
2406  assert(isElementTypeCompatible(V->getType()) &&
2407  "Element type not compatible with ConstantData");
2408  if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
2409  if (CI->getType()->isIntegerTy(8)) {
2410  SmallVector<uint8_t, 16> Elts(NumElts, CI->getZExtValue());
2411  return get(V->getContext(), Elts);
2412  }
2413  if (CI->getType()->isIntegerTy(16)) {
2414  SmallVector<uint16_t, 16> Elts(NumElts, CI->getZExtValue());
2415  return get(V->getContext(), Elts);
2416  }
2417  if (CI->getType()->isIntegerTy(32)) {
2418  SmallVector<uint32_t, 16> Elts(NumElts, CI->getZExtValue());
2419  return get(V->getContext(), Elts);
2420  }
2421  assert(CI->getType()->isIntegerTy(64) && "Unsupported ConstantData type");
2422  SmallVector<uint64_t, 16> Elts(NumElts, CI->getZExtValue());
2423  return get(V->getContext(), Elts);
2424  }
2425 
2426  if (ConstantFP *CFP = dyn_cast<ConstantFP>(V)) {
2427  if (CFP->getType()->isFloatTy()) {
2428  SmallVector<float, 16> Elts(NumElts, CFP->getValueAPF().convertToFloat());
2429  return get(V->getContext(), Elts);
2430  }
2431  if (CFP->getType()->isDoubleTy()) {
2432  SmallVector<double, 16> Elts(NumElts,
2433  CFP->getValueAPF().convertToDouble());
2434  return get(V->getContext(), Elts);
2435  }
2436  }
2437  return ConstantVector::getSplat(NumElts, V);
2438 }
2439 
2440 
2441 /// getElementAsInteger - If this is a sequential container of integers (of
2442 /// any size), return the specified element in the low bits of a uint64_t.
2443 uint64_t ConstantDataSequential::getElementAsInteger(unsigned Elt) const {
2444  assert(isa<IntegerType>(getElementType()) &&
2445  "Accessor can only be used when element is an integer");
2446  const char *EltPtr = getElementPointer(Elt);
2447 
2448  // The data is stored in host byte order, make sure to cast back to the right
2449  // type to load with the right endianness.
2450  switch (getElementType()->getIntegerBitWidth()) {
2451  default: llvm_unreachable("Invalid bitwidth for CDS");
2452  case 8:
2453  return *const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(EltPtr));
2454  case 16:
2455  return *const_cast<uint16_t *>(reinterpret_cast<const uint16_t *>(EltPtr));
2456  case 32:
2457  return *const_cast<uint32_t *>(reinterpret_cast<const uint32_t *>(EltPtr));
2458  case 64:
2459  return *const_cast<uint64_t *>(reinterpret_cast<const uint64_t *>(EltPtr));
2460  }
2461 }
2462 
2463 /// getElementAsAPFloat - If this is a sequential container of floating point
2464 /// type, return the specified element as an APFloat.
2466  const char *EltPtr = getElementPointer(Elt);
2467 
2468  switch (getElementType()->getTypeID()) {
2469  default:
2470  llvm_unreachable("Accessor can only be used when element is float/double!");
2471  case Type::FloatTyID: {
2472  const float *FloatPrt = reinterpret_cast<const float *>(EltPtr);
2473  return APFloat(*const_cast<float *>(FloatPrt));
2474  }
2475  case Type::DoubleTyID: {
2476  const double *DoublePtr = reinterpret_cast<const double *>(EltPtr);
2477  return APFloat(*const_cast<double *>(DoublePtr));
2478  }
2479  }
2480 }
2481 
2482 /// getElementAsFloat - If this is an sequential container of floats, return
2483 /// the specified element as a float.
2485  assert(getElementType()->isFloatTy() &&
2486  "Accessor can only be used when element is a 'float'");
2487  const float *EltPtr = reinterpret_cast<const float *>(getElementPointer(Elt));
2488  return *const_cast<float *>(EltPtr);
2489 }
2490 
2491 /// getElementAsDouble - If this is an sequential container of doubles, return
2492 /// the specified element as a float.
2494  assert(getElementType()->isDoubleTy() &&
2495  "Accessor can only be used when element is a 'float'");
2496  const double *EltPtr =
2497  reinterpret_cast<const double *>(getElementPointer(Elt));
2498  return *const_cast<double *>(EltPtr);
2499 }
2500 
2501 /// getElementAsConstant - Return a Constant for a specified index's element.
2502 /// Note that this has to compute a new constant to return, so it isn't as
2503 /// efficient as getElementAsInteger/Float/Double.
2505  if (getElementType()->isFloatTy() || getElementType()->isDoubleTy())
2507 
2509 }
2510 
2511 /// isString - This method returns true if this is an array of i8.
2513  return isa<ArrayType>(getType()) && getElementType()->isIntegerTy(8);
2514 }
2515 
2516 /// isCString - This method returns true if the array "isString", ends with a
2517 /// nul byte, and does not contains any other nul bytes.
2519  if (!isString())
2520  return false;
2521 
2522  StringRef Str = getAsString();
2523 
2524  // The last value must be nul.
2525  if (Str.back() != 0) return false;
2526 
2527  // Other elements must be non-nul.
2528  return Str.drop_back().find(0) == StringRef::npos;
2529 }
2530 
2531 /// getSplatValue - If this is a splat constant, meaning that all of the
2532 /// elements have the same value, return that value. Otherwise return NULL.
2534  const char *Base = getRawDataValues().data();
2535 
2536  // Compare elements 1+ to the 0'th element.
2537  unsigned EltSize = getElementByteSize();
2538  for (unsigned i = 1, e = getNumElements(); i != e; ++i)
2539  if (memcmp(Base, Base+i*EltSize, EltSize))
2540  return 0;
2541 
2542  // If they're all the same, return the 0th one as a representative.
2543  return getElementAsConstant(0);
2544 }
2545 
2546 //===----------------------------------------------------------------------===//
2547 // replaceUsesOfWithOnConstant implementations
2548 
2549 /// replaceUsesOfWithOnConstant - Update this constant array to change uses of
2550 /// 'From' to be uses of 'To'. This must update the uniquing data structures
2551 /// etc.
2552 ///
2553 /// Note that we intentionally replace all uses of From with To here. Consider
2554 /// a large array that uses 'From' 1000 times. By handling this case all here,
2555 /// ConstantArray::replaceUsesOfWithOnConstant is only invoked once, and that
2556 /// single invocation handles all 1000 uses. Handling them one at a time would
2557 /// work, but would be really slow because it would have to unique each updated
2558 /// array instance.
2559 ///
2561  Use *U) {
2562  assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
2563  Constant *ToC = cast<Constant>(To);
2564 
2565  LLVMContextImpl *pImpl = getType()->getContext().pImpl;
2566 
2569  Lookup.first = cast<ArrayType>(getType());
2570  Values.reserve(getNumOperands()); // Build replacement array.
2571 
2572  // Fill values with the modified operands of the constant array. Also,
2573  // compute whether this turns into an all-zeros array.
2574  unsigned NumUpdated = 0;
2575 
2576  // Keep track of whether all the values in the array are "ToC".
2577  bool AllSame = true;
2578  for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
2579  Constant *Val = cast<Constant>(O->get());
2580  if (Val == From) {
2581  Val = ToC;
2582  ++NumUpdated;
2583  }
2584  Values.push_back(Val);
2585  AllSame &= Val == ToC;
2586  }
2587 
2588  Constant *Replacement = 0;
2589  if (AllSame && ToC->isNullValue()) {
2590  Replacement = ConstantAggregateZero::get(getType());
2591  } else if (AllSame && isa<UndefValue>(ToC)) {
2592  Replacement = UndefValue::get(getType());
2593  } else {
2594  // Check to see if we have this array type already.
2595  Lookup.second = makeArrayRef(Values);
2597  pImpl->ArrayConstants.find(Lookup);
2598 
2599  if (I != pImpl->ArrayConstants.map_end()) {
2600  Replacement = I->first;
2601  } else {
2602  // Okay, the new shape doesn't exist in the system yet. Instead of
2603  // creating a new constant array, inserting it, replaceallusesof'ing the
2604  // old with the new, then deleting the old... just update the current one
2605  // in place!
2606  pImpl->ArrayConstants.remove(this);
2607 
2608  // Update to the new value. Optimize for the case when we have a single
2609  // operand that we're changing, but handle bulk updates efficiently.
2610  if (NumUpdated == 1) {
2611  unsigned OperandToUpdate = U - OperandList;
2612  assert(getOperand(OperandToUpdate) == From &&
2613  "ReplaceAllUsesWith broken!");
2614  setOperand(OperandToUpdate, ToC);
2615  } else {
2616  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
2617  if (getOperand(i) == From)
2618  setOperand(i, ToC);
2619  }
2620  pImpl->ArrayConstants.insert(this);
2621  return;
2622  }
2623  }
2624 
2625  // Otherwise, I do need to replace this with an existing value.
2626  assert(Replacement != this && "I didn't contain From!");
2627 
2628  // Everyone using this now uses the replacement.
2629  replaceAllUsesWith(Replacement);
2630 
2631  // Delete the old constant!
2632  destroyConstant();
2633 }
2634 
2636  Use *U) {
2637  assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
2638  Constant *ToC = cast<Constant>(To);
2639 
2640  unsigned OperandToUpdate = U-OperandList;
2641  assert(getOperand(OperandToUpdate) == From && "ReplaceAllUsesWith broken!");
2642 
2645  Lookup.first = cast<StructType>(getType());
2646  Values.reserve(getNumOperands()); // Build replacement struct.
2647 
2648  // Fill values with the modified operands of the constant struct. Also,
2649  // compute whether this turns into an all-zeros struct.
2650  bool isAllZeros = false;
2651  bool isAllUndef = false;
2652  if (ToC->isNullValue()) {
2653  isAllZeros = true;
2654  for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
2655  Constant *Val = cast<Constant>(O->get());
2656  Values.push_back(Val);
2657  if (isAllZeros) isAllZeros = Val->isNullValue();
2658  }
2659  } else if (isa<UndefValue>(ToC)) {
2660  isAllUndef = true;
2661  for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
2662  Constant *Val = cast<Constant>(O->get());
2663  Values.push_back(Val);
2664  if (isAllUndef) isAllUndef = isa<UndefValue>(Val);
2665  }
2666  } else {
2667  for (Use *O = OperandList, *E = OperandList + getNumOperands(); O != E; ++O)
2668  Values.push_back(cast<Constant>(O->get()));
2669  }
2670  Values[OperandToUpdate] = ToC;
2671 
2672  LLVMContextImpl *pImpl = getContext().pImpl;
2673 
2674  Constant *Replacement = 0;
2675  if (isAllZeros) {
2676  Replacement = ConstantAggregateZero::get(getType());
2677  } else if (isAllUndef) {
2678  Replacement = UndefValue::get(getType());
2679  } else {
2680  // Check to see if we have this struct type already.
2681  Lookup.second = makeArrayRef(Values);
2683  pImpl->StructConstants.find(Lookup);
2684 
2685  if (I != pImpl->StructConstants.map_end()) {
2686  Replacement = I->first;
2687  } else {
2688  // Okay, the new shape doesn't exist in the system yet. Instead of
2689  // creating a new constant struct, inserting it, replaceallusesof'ing the
2690  // old with the new, then deleting the old... just update the current one
2691  // in place!
2692  pImpl->StructConstants.remove(this);
2693 
2694  // Update to the new value.
2695  setOperand(OperandToUpdate, ToC);
2696  pImpl->StructConstants.insert(this);
2697  return;
2698  }
2699  }
2700 
2701  assert(Replacement != this && "I didn't contain From!");
2702 
2703  // Everyone using this now uses the replacement.
2704  replaceAllUsesWith(Replacement);
2705 
2706  // Delete the old constant!
2707  destroyConstant();
2708 }
2709 
2711  Use *U) {
2712  assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
2713 
2715  Values.reserve(getNumOperands()); // Build replacement array...
2716  for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
2717  Constant *Val = getOperand(i);
2718  if (Val == From) Val = cast<Constant>(To);
2719  Values.push_back(Val);
2720  }
2721 
2722  Constant *Replacement = get(Values);
2723  assert(Replacement != this && "I didn't contain From!");
2724 
2725  // Everyone using this now uses the replacement.
2726  replaceAllUsesWith(Replacement);
2727 
2728  // Delete the old constant!
2729  destroyConstant();
2730 }
2731 
2733  Use *U) {
2734  assert(isa<Constant>(ToV) && "Cannot make Constant refer to non-constant!");
2735  Constant *To = cast<Constant>(ToV);
2736 
2738  for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
2739  Constant *Op = getOperand(i);
2740  NewOps.push_back(Op == From ? To : Op);
2741  }
2742 
2743  Constant *Replacement = getWithOperands(NewOps);
2744  assert(Replacement != this && "I didn't contain From!");
2745 
2746  // Everyone using this now uses the replacement.
2747  replaceAllUsesWith(Replacement);
2748 
2749  // Delete the old constant!
2750  destroyConstant();
2751 }
2752 
2754  SmallVector<Value*,4> ValueOperands;
2755  for (op_iterator I = op_begin(), E = op_end(); I != E; ++I)
2756  ValueOperands.push_back(cast<Value>(I));
2757 
2758  ArrayRef<Value*> Ops(ValueOperands);
2759 
2760  switch (getOpcode()) {
2761  case Instruction::Trunc:
2762  case Instruction::ZExt:
2763  case Instruction::SExt:
2764  case Instruction::FPTrunc:
2765  case Instruction::FPExt:
2766  case Instruction::UIToFP:
2767  case Instruction::SIToFP:
2768  case Instruction::FPToUI:
2769  case Instruction::FPToSI:
2770  case Instruction::PtrToInt:
2771  case Instruction::IntToPtr:
2772  case Instruction::BitCast:
2774  Ops[0], getType());
2775  case Instruction::Select:
2776  return SelectInst::Create(Ops[0], Ops[1], Ops[2]);
2777  case Instruction::InsertElement:
2778  return InsertElementInst::Create(Ops[0], Ops[1], Ops[2]);
2780  return ExtractElementInst::Create(Ops[0], Ops[1]);
2781  case Instruction::InsertValue:
2782  return InsertValueInst::Create(Ops[0], Ops[1], getIndices());
2783  case Instruction::ExtractValue:
2784  return ExtractValueInst::Create(Ops[0], getIndices());
2785  case Instruction::ShuffleVector:
2786  return new ShuffleVectorInst(Ops[0], Ops[1], Ops[2]);
2787 
2788  case Instruction::GetElementPtr:
2789  if (cast<GEPOperator>(this)->isInBounds())
2790  return GetElementPtrInst::CreateInBounds(Ops[0], Ops.slice(1));
2791  else
2792  return GetElementPtrInst::Create(Ops[0], Ops.slice(1));
2793 
2794  case Instruction::ICmp:
2795  case Instruction::FCmp:
2797  getPredicate(), Ops[0], Ops[1]);
2798 
2799  default:
2800  assert(getNumOperands() == 2 && "Must be binary operator?");
2801  BinaryOperator *BO =
2803  Ops[0], Ops[1]);
2804  if (isa<OverflowingBinaryOperator>(BO)) {
2809  }
2810  if (isa<PossiblyExactOperator>(BO))
2812  return BO;
2813  }
2814 }
void destroyConstantImpl()
Definition: Constants.cpp:212
static bool isValueValidForType(Type *Ty, uint64_t V)
Determine if the value is in range for the given type.
Definition: Constants.cpp:1159
use_iterator use_end()
Definition: Value.h:152
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:445
IntegerType * getType() const
Definition: Constants.h:139
void setHasNoSignedWrap(bool b=true)
static Constant * getString(LLVMContext &Context, StringRef Initializer, bool AddNull=true)
Definition: Constants.cpp:2357
static Constant * getSIToFP(Constant *C, Type *Ty)
Definition: Constants.cpp:1604
static bool rangeOnlyContains(ItTy Start, ItTy End, EltTy Elt)
Definition: Constants.cpp:726
const ValueTy & getValue() const
Definition: StringMap.h:132
static Type * getDoubleTy(LLVMContext &C)
Definition: Type.cpp:231
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:238
void reserve(unsigned N)
Definition: SmallVector.h:425
static Constant * getFAdd(Constant *C1, Constant *C2)
Definition: Constants.cpp:2036
static Constant * getShuffleVector(Constant *V1, Constant *V2, Constant *Mask)
Definition: Constants.cpp:1949
LLVMContext & getContext() const
Definition: Function.cpp:167
APFloat getElementAsAPFloat(unsigned i) const
Definition: Constants.cpp:2465
static APInt getAllOnesValue(unsigned numBits)
Get the all-ones value.
Definition: APInt.h:450
Type * getSequentialElementType() const
Definition: Type.cpp:206
size_t size() const
size - Get the string size.
Definition: StringRef.h:113
static Constant * getFoldedCast(Instruction::CastOps opc, Constant *C, Type *Ty)
Definition: Constants.cpp:1429
bool isOpaque() const
Definition: DerivedTypes.h:249
unsigned getScalarSizeInBits()
Definition: Type.cpp:135
static const fltSemantics IEEEdouble
Definition: APFloat.h:133
2: 32-bit floating point type
Definition: Type.h:57
Constant * getSplatValue() const
Definition: Constants.cpp:1276
static Constant * getSelect(Constant *C, Constant *V1, Constant *V2)
Definition: Constants.cpp:1820
const T & front() const
front - Get the first element.
Definition: ArrayRef.h:112
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", Instruction *InsertBefore=0)
enable_if_c<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:266
unsigned getNumOperands() const
Definition: User.h:108
size_t find(char C, size_t From=0) const
Definition: StringRef.h:233
static ConstantAggregateZero * get(Type *Ty)
Definition: Constants.cpp:1231
static Constant * getFPToUI(Constant *C, Type *Ty)
Definition: Constants.cpp:1615
static Constant * getGetElementPtr(Constant *C, ArrayRef< Constant * > IdxList, bool InBounds=false)
Definition: Constants.h:1004
iterator end() const
Definition: ArrayRef.h:98
Constant * ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx)
Constant * getElementAsConstant(unsigned i) const
Definition: Constants.cpp:2504
static Constant * getBinOpIdentity(unsigned Opcode, Type *Ty)
Definition: Constants.cpp:2120
Constant * getSplatValue() const
Definition: Constants.cpp:2533
gep_type_iterator gep_type_end(const User *GEP)
unsigned less or equal
Definition: InstrTypes.h:677
unsigned less than
Definition: InstrTypes.h:676
bool insert(PtrType Ptr)
Definition: SmallPtrSet.h:253
Constant * ConstantFoldCastInstruction(unsigned opcode, Constant *V, Type *DestTy)
static Constant * getExtractElement(Constant *Vec, Constant *Idx)
Definition: Constants.cpp:1912
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:657
iterator find(StringRef Key)
Definition: StringMap.h:291
bool isDoubleTy() const
isDoubleTy - Return true if this is 'double', a 64-bit IEEE fp type.
Definition: Type.h:149
ConstantInt * TheFalseVal
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:667
bool isPtrOrPtrVectorTy() const
Definition: Type.h:225
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:116
12: Structures
Definition: Type.h:70
static Constant * getUIToFP(Constant *C, Type *Ty)
Definition: Constants.cpp:1593
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U)
Definition: Constants.cpp:1386
F(f)
4: 80-bit floating point type (X87)
Definition: Type.h:59
const APInt & getUniqueInteger() const
Definition: Constants.cpp:1301
static ExtractValueInst * Create(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=0)
static APFloat getZero(const fltSemantics &Sem, bool Negative=false)
Definition: APFloat.h:212
1: 16-bit floating point type
Definition: Type.h:56
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:61
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:242
static Constant * getFCmp(unsigned short pred, Constant *LHS, Constant *RHS)
Definition: Constants.cpp:1892
static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2040
StringRef drop_back(size_t N=1) const
Definition: StringRef.h:406
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: Type.cpp:218
14: Pointers
Definition: Type.h:72
static IntegerType * getInt16Ty(LLVMContext &C)
Definition: Type.cpp:240
unsigned getOpcode() const
getOpcode - Return the opcode at the root of this constant expression
Definition: Constants.h:1049
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U)
Definition: Constants.cpp:2635
op_iterator op_begin()
Definition: User.h:116
static Type * getX86_FP80Ty(LLVMContext &C)
Definition: Type.cpp:233
bool bitwiseIsEqual(const APFloat &) const
Bitwise comparison for equality (QNaNs compare equal, 0!=-0).
Definition: APFloat.cpp:755
static Constant * getNullValue(Type *Ty)
Definition: Constants.cpp:111
ConstantInt * TheTrueVal
static Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2029
static Constant * getFMul(Constant *C1, Constant *C2)
Definition: Constants.cpp:2058
bool isCast() const
Definition: Instruction.h:89
bool isNegativeZeroValue() const
Definition: Constants.cpp:45
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:662
static const fltSemantics x87DoubleExtended
Definition: APFloat.h:136
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:661
static Constant * getIntegerCast(Constant *C, Type *Ty, bool isSigned)
Create a ZExt, Bitcast or Trunc for integer -> integer casts.
Definition: Constants.cpp:1502
static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy)
Determine if a cast is valid without creating one.
static Type * getIndexedType(Type *Agg, ArrayRef< unsigned > Idxs)
static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::ZeroOrMore, cl::values(clEnumValN(DefaultIT,"arm-default-it","Generate IT block based on arch"), clEnumValN(RestrictedIT,"arm-restrict-it","Disallow deprecated IT based on ARMv8"), clEnumValN(NoRestrictedIT,"arm-no-restrict-it","Allow IT blocks based on ARMv7"), clEnumValEnd))
static Constant * get(unsigned Opcode, Constant *C1, Constant *C2, unsigned Flags=0)
Definition: Constants.cpp:1679
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:230
const APInt & getValue() const
Return the constant's value.
Definition: Constants.h:105
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:261
Constant * getSequentialElement() const
Definition: Constants.cpp:660
static Constant * get(LLVMContext &Context, ArrayRef< uint8_t > Elts)
Definition: Constants.cpp:2321
T LLVM_ATTRIBUTE_UNUSED_RESULT pop_back_val()
Definition: SmallVector.h:430
#define llvm_unreachable(msg)
Definition: Use.h:60
static Constant * getLShr(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2107
void setHasNoUnsignedWrap(bool b=true)
static Constant * get(ArrayRef< Constant * > V)
Definition: Constants.cpp:923
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:658
double getElementAsDouble(unsigned i) const
Definition: Constants.cpp:2493
static Constant * getExtractValue(Constant *Agg, ArrayRef< unsigned > Idxs)
Definition: Constants.cpp:1989
static const fltSemantics IEEEquad
Definition: APFloat.h:134
Instruction * getAsInstruction()
Definition: Constants.cpp:2753
static ConstantInt * ExtractElement(Constant *V, Constant *Idx)
Type * getVectorElementType() const
Definition: Type.h:371
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U)
Definition: Constants.cpp:2710
static Type * getPPC_FP128Ty(LLVMContext &C)
Definition: Type.cpp:235
uint64_t getZExtValue() const
Return the zero extended value.
Definition: Constants.h:116
virtual void destroyConstant()
Definition: Constants.cpp:2160
static bool isValidOperands(const Value *V1, const Value *V2, const Value *Mask)
static Constant * getSizeOf(Type *Ty)
Definition: Constants.cpp:1756
static StructType * getTypeForElements(ArrayRef< Constant * > V, bool Packed=false)
Definition: Constants.cpp:853
UndefValue * getElementValue(Constant *C) const
Definition: Constants.cpp:705
LLVMContext & getContext() const
getContext - Return the LLVMContext in which this type was uniqued.
Definition: Type.h:128
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: SmallVector.h:56
static Constant * getFPCast(Constant *C, Type *Ty)
Create a FPExt, Bitcast or FPTrunc for fp -> fp casts.
Definition: Constants.cpp:1515
const char * data() const
Definition: StringRef.h:107
bool isHalfTy() const
isHalfTy - Return true if this is 'half', a 16-bit IEEE fp type.
Definition: Type.h:143
ArrayRef< T > slice(unsigned N) const
slice(n) - Chop off the first N elements of the array.
Definition: ArrayRef.h:134
#define T
static Constant * getAShr(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2112
bool isConstantUsed() const
Definition: Constants.cpp:309
static Constant * getICmp(unsigned short pred, Constant *LHS, Constant *RHS)
Definition: Constants.cpp:1870
UndefValue * getStructElement(unsigned Elt) const
Definition: Constants.cpp:699
static Constant * getAddrSpaceCast(Constant *C, Type *Ty)
Definition: Constants.cpp:1672
bool isFirstClassType() const
Definition: Type.h:251
static Constant * getPtrToInt(Constant *C, Type *Ty)
Definition: Constants.cpp:1637
unsigned getActiveBits() const
Compute the number of active bits in the value.
Definition: APInt.h:1276
TypeID getTypeID() const
Definition: Type.h:137
bool isFloatingPointTy() const
Definition: Type.h:162
ArrayConstantsTy ArrayConstants
DenseMap< PointerType *, ConstantPointerNull * > CPNConstants
SequentialType * getType() const
Definition: Constants.h:581
Constant * ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs)
void replaceAllUsesWith(Value *V)
Definition: Value.cpp:303
bool isArrayTy() const
Definition: Type.h:216
static Constant * getUDiv(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2062
unsigned getNumElements() const
Return the number of elements in the Vector type.
Definition: DerivedTypes.h:408
Constant * getWithOperandReplaced(unsigned OpNo, Constant *Op) const
Definition: Constants.cpp:1090
static Constant * getIntToPtr(Constant *C, Type *Ty)
Definition: Constants.cpp:1649
const char * getOpcodeName() const
Definition: Instruction.h:85
bool isPPC_FP128Ty() const
isPPC_FP128Ty - Return true if this is powerpc long double.
Definition: Type.h:158
Type * getElementType() const
Definition: DerivedTypes.h:319
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:109
static Constant * getFDiv(Constant *C1, Constant *C2)
Definition: Constants.cpp:2072
static APFloat getInf(const fltSemantics &Sem, bool Negative=false)
Definition: APFloat.h:221
iterator begin() const
Definition: StringRef.h:97
static CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=0)
Construct any of the CastInst subclasses.
virtual void destroyConstant()
Definition: Constants.cpp:1251
10: Arbitrary bit width integers
Definition: Type.h:68
static bool removeDeadUsersOfConstant(const Constant *C)
Definition: Constants.cpp:376
DenseMap< Type *, ConstantAggregateZero * > CAZConstants
A self-contained host- and target-independent arbitrary-precision floating-point software implementat...
Definition: APFloat.h:122
int memcmp(const void *s1, const void *s2, size_t n);
bool isIntOrIntVectorTy() const
Definition: Type.h:204
Constant * ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2, Constant *Mask)
static Constant * getFNeg(Constant *C)
Definition: Constants.cpp:2017
static Constant * getFRem(Constant *C1, Constant *C2)
Definition: Constants.cpp:2084
static Constant * getImpl(StringRef Bytes, Type *Ty)
Definition: Constants.cpp:2248
static ConstantPointerNull * get(PointerType *T)
get() - Static factory methods - Return objects of the specified value
Definition: Constants.cpp:1314
static InsertElementInst * Create(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=0)
LLVM Basic Block Representation.
Definition: BasicBlock.h:72
bool canTrap() const
Definition: Constants.cpp:275
bool isVectorTy() const
Definition: Type.h:229
static BlockAddress * get(Function *F, BasicBlock *BB)
get - Return a BlockAddress for the specified function and basic block.
Definition: Constants.cpp:1358
Type * getElementType(unsigned N) const
Definition: DerivedTypes.h:287
LLVM Constant Representation.
Definition: Constant.h:41
uint64_t getElementByteSize() const
getElementByteSize - Return the size in bytes of the elements in the data.
Definition: Constants.cpp:2225
bool hasIndices() const
Return true if this is an insertvalue or extractvalue expression, and the getIndices() method may be ...
Definition: Constants.cpp:1069
StringRef getAsString() const
Definition: Constants.h:607
char back() const
back - Get the last character in the string.
Definition: StringRef.h:122
StringRef getRawDataValues() const
Definition: Constants.cpp:2193
bool isFloatTy() const
isFloatTy - Return true if this is 'float', a 32-bit IEEE fp type.
Definition: Type.h:146
static Constant * getAnd(Constant *C1, Constant *C2)
Definition: Constants.cpp:2088
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
Definition: APInt.h:1845
static Constant * get(ArrayType *T, ArrayRef< Constant * > V)
Definition: Constants.cpp:745
APInt Xor(const APInt &LHS, const APInt &RHS)
Bitwise XOR function for APInt.
Definition: APInt.h:1850
static ExtractElementInst * Create(Value *Vec, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=0)
bool isZeroValue() const
Return true if the value is negative zero or null value.
Definition: Constants.cpp:66
static Constant * getSExtOrBitCast(Constant *C, Type *Ty)
Definition: Constants.cpp:1475
static int Lookup(const TableEntry *Table, unsigned N, unsigned Opcode)
op_iterator op_end()
Definition: User.h:118
ItTy next(ItTy it, Dist n)
Definition: STLExtras.h:154
UndefValue * getSequentialElement() const
Definition: Constants.cpp:693
uint64_t getNumElements() const
Definition: DerivedTypes.h:348
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1252
iterator begin() const
Definition: ArrayRef.h:97
opStatus convert(const fltSemantics &, roundingMode, bool *)
Definition: APFloat.cpp:1938
6: 128-bit floating point type (two 64-bits, PowerPC)
Definition: Type.h:61
Value * getOperand(unsigned i) const
Definition: User.h:88
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:660
static bool isValueValidForType(Type *Ty, const APFloat &V)
isValueValidForType - return true if Ty is big enough to represent V.
Definition: Constants.cpp:1180
void changeSign()
Definition: APFloat.cpp:1589
Integer representation type.
Definition: DerivedTypes.h:37
static Constant * getFPTrunc(Constant *C, Type *Ty)
Definition: Constants.cpp:1569
static Constant * get(StructType *T, ArrayRef< Constant * > V)
Definition: Constants.cpp:874
static Constant * getSplat(unsigned NumElts, Constant *Elt)
Definition: Constants.cpp:2405
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:104
static Constant * getNot(Constant *C)
Definition: Constants.cpp:2023
Constant * getAggregateElement(unsigned Elt) const
Definition: Constants.cpp:183
static Constant * getAllOnesValue(Type *Ty)
Get the all ones value.
Definition: Constants.cpp:163
unsigned getPredicate() const
Definition: Constants.cpp:1082
1 1 1 1 Always true (always folded)
Definition: InstrTypes.h:668
ArrayRef< unsigned > getIndices() const
Definition: Constants.cpp:1074
uint64_t getElementAsInteger(unsigned i) const
Definition: Constants.cpp:2443
void append(in_iter in_start, in_iter in_end)
Definition: SmallVector.h:445
static const fltSemantics * TypeToFloatSemantics(Type *Ty)
Definition: Constants.cpp:536
virtual void destroyConstant()
Definition: Constants.cpp:1344
bool isFP128Ty() const
isFP128Ty - Return true if this is 'fp128'.
Definition: Type.h:155
bool isPointerTy() const
Definition: Type.h:220
static UndefValue * get(Type *T)
Definition: Constants.cpp:1334
static Constant * getFPExtend(Constant *C, Type *Ty)
Definition: Constants.cpp:1581
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:517
bool isFPOrFPVectorTy() const
Definition: Type.h:186
PointerType * getPointerTo(unsigned AddrSpace=0)
Definition: Type.cpp:756
Constant * ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1, Constant *V2)
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:666
static const fltSemantics IEEEhalf
Definition: APFloat.h:131
ConstantUniqueMap< ExprMapKeyType, const ExprMapKeyType &, Type, ConstantExpr > ExprConstants
VectorConstantsTy VectorConstants
unsigned char SubclassOptionalData
Definition: Value.h:74
LLVMContextImpl *const pImpl
Definition: LLVMContext.h:39
signed greater than
Definition: InstrTypes.h:678
static Type * getFP128Ty(LLVMContext &C)
Definition: Type.cpp:234
Constant * ConstantFoldGetElementPtr(Constant *C, bool inBounds, ArrayRef< Constant * > Idxs)
static Constant * getIntegerValue(Type *Ty, const APInt &V)
Definition: Constants.cpp:146
void setIsExact(bool b=true)
virtual void destroyConstant()
Definition: Constants.cpp:1262
bool isCompare() const
Return true if this is a compare constant expression.
Definition: Constants.cpp:1040
13: Arrays
Definition: Type.h:71
static bool isZero(Value *V, DataLayout *DL)
Definition: Lint.cpp:507
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:655
static Constant * getPointerCast(Constant *C, Type *Ty)
Create a BitCast or a PtrToInt cast constant expression.
Definition: Constants.cpp:1487
virtual void destroyConstant()
Definition: Constants.cpp:1244
static Type * getHalfTy(LLVMContext &C)
Definition: Type.cpp:229
const char * iterator
Definition: StringRef.h:43
static Constant * getSplat(unsigned NumElts, Constant *Elt)
Definition: Constants.cpp:1021
static IntegerType * get(LLVMContext &C, unsigned NumBits)
Get or create an IntegerType instance.
Definition: Type.cpp:305
static bool isAllZeros(StringRef Arr)
isAllZeros - return true if the array is empty or all zeros.
Definition: Constants.cpp:2237
static Constant * getBitCast(Constant *C, Type *Ty)
Definition: Constants.cpp:1661
PossibleRelocationsTy getRelocationInfo() const
Definition: Constants.cpp:337
static const fltSemantics PPCDoubleDouble
Definition: APFloat.h:135
ArrayType * getType() const
Definition: Constants.h:355
unsigned getIntegerBitWidth() const
Definition: Type.cpp:178
static PointerType * getUnqual(Type *ElementType)
Definition: DerivedTypes.h:436
Class for constant integers.
Definition: Constants.h:51
15: SIMD 'packed' format, or other vector type
Definition: Type.h:73
unsigned getVectorNumElements() const
Definition: Type.cpp:214
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
Definition: Type.cpp:405
static Constant * getSDiv(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2067
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:665
Type * getType() const
Definition: Value.h:111
const char * getOpcodeName() const
getOpcodeName - Return a string representation for an opcode.
Definition: Constants.cpp:2165
signed less than
Definition: InstrTypes.h:680
static APFloat getAllOnesValue(unsigned BitWidth, bool isIEEE=false)
Definition: APFloat.cpp:3320
BasicBlock * getBasicBlock() const
Definition: Constants.h:764
Value * stripPointerCasts()
Strips off any unneeded pointer casts, all-zero GEPs and aliases from the specified value...
Definition: Value.cpp:385
const char * getKeyData() const
Definition: StringMap.h:140
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
Definition: Constants.cpp:492
static ConstantInt * getSigned(IntegerType *Ty, int64_t V)
Get a ConstantInt for a specific signed value.
Definition: Constants.cpp:507
static GetElementPtrInst * Create(Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=0)
Definition: Instructions.h:726
static Constant * getTrunc(Constant *C, Type *Ty)
Definition: Constants.cpp:1527
static Constant * get(Type *Ty, double V)
Definition: Constants.cpp:557
bool isNullValue() const
Definition: Constants.cpp:75
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:438
static Constant * getFPToSI(Constant *C, Type *Ty)
Definition: Constants.cpp:1626
void setOperand(unsigned i, Value *Val)
Definition: User.h:92
raw_ostream & dbgs()
dbgs - Return a circular-buffered debug stream.
Definition: Debug.cpp:101
bool isAllOnesValue() const
Definition: Constants.cpp:88
ConstantClass * getOrCreate(TypeClass *Ty, Operands V)
signed less or equal
Definition: InstrTypes.h:681
Class for arbitrary precision integers.
Definition: APInt.h:75
bool isCast() const
Return true if this is a convert constant expression.
Definition: Constants.cpp:1036
static ConstantFP * getNegativeZero(Type *Ty)
Definition: Constants.cpp:588
virtual void destroyConstant()
Definition: Constant.h:122
static bool canTrapImpl(const Constant *C, SmallPtrSet< const ConstantExpr *, 4 > &NonTrappingOps)
Definition: Constants.cpp:240
bool isIntegerTy() const
Definition: Type.h:196
StructType * getType() const
Definition: Constants.h:413
static char getTypeID(Type *Ty)
static bool isElementTypeCompatible(const Type *Ty)
Definition: Constants.cpp:2201
DenseMap< Type *, UndefValue * > UVConstants
static Constant * getZExtOrBitCast(Constant *C, Type *Ty)
Definition: Constants.cpp:1469
APInt And(const APInt &LHS, const APInt &RHS)
Bitwise AND function for APInt.
Definition: APInt.h:1840
bool isStructTy() const
Definition: Type.h:212
static Constant * getFSub(Constant *C1, Constant *C2)
Definition: Constants.cpp:2047
bool isGEPWithNoNotionalOverIndexing() const
Return true if this is a getelementptr expression and all the index operands are compile-time known i...
Definition: Constants.cpp:1044
static Constant * getTruncOrBitCast(Constant *C, Type *Ty)
Definition: Constants.cpp:1481
DenseMapIterator< KeyT, ValueT, KeyInfoT > iterator
Definition: DenseMap.h:50
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=0)
static Constant * getNeg(Constant *C, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2010
use_iterator use_begin()
Definition: Value.h:150
Constant * ConstantFoldCompareInstruction(unsigned short predicate, Constant *C1, Constant *C2)
static CmpInst * Create(OtherOps Op, unsigned short predicate, Value *S1, Value *S2, const Twine &Name="", Instruction *InsertBefore=0)
Create a CmpInst.
virtual void destroyConstant()
Definition: Constants.cpp:1269
Constant * getElementValue(Constant *C) const
Definition: Constants.cpp:672
PointerType * getType() const
getType - Global values are always pointers.
Definition: GlobalValue.h:107
static const fltSemantics IEEEsingle
Definition: APFloat.h:132
Constant * ConstantFoldSelectInstruction(Constant *Cond, Constant *V1, Constant *V2)
bool isX86_FP80Ty() const
isX86_FP80Ty - Return true if this is x86 long double.
Definition: Type.h:152
static Constant * getSExt(Constant *C, Type *Ty)
Definition: Constants.cpp:1541
static const size_t npos
Definition: StringRef.h:45
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:241
static Constant * getZExt(Constant *C, Type *Ty)
Definition: Constants.cpp:1555
float getElementAsFloat(unsigned i) const
Definition: Constants.cpp:2484
User * use_back()
Definition: Value.h:154
static Constant * getOffsetOf(StructType *STy, unsigned FieldNo)
Definition: Constants.cpp:1780
unsigned greater or equal
Definition: InstrTypes.h:675
Use * OperandList
Definition: User.h:45
#define I(x, y, z)
Definition: MD5.cpp:54
static Constant * getOr(Constant *C1, Constant *C2)
Definition: Constants.cpp:2092
static Constant * getZeroValueForNegation(Type *Ty)
Definition: Constants.cpp:596
unsigned getNumElements() const
getNumElements - Return the number of elements in the array or vector.
Definition: Constants.cpp:2217
Constant * ConstantFoldInsertElementInstruction(Constant *Val, Constant *Elt, Constant *Idx)
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:659
static ArrayType * get(Type *ElementType, uint64_t NumElements)
Definition: Type.cpp:679
MapTy::iterator find(LookupKey Lookup)
Find the constant by lookup key.
bool isString() const
isString - This method returns true if this is an array of i8.
Definition: Constants.cpp:2512
static Constant * getShl(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2100
const Type * getScalarType() const
Definition: Type.cpp:51
PointerType * getType() const
Definition: Constants.h:505
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), Instruction *InsertBefore=0)
unsigned getPrimitiveSizeInBits() const
Definition: Type.cpp:117
static Constant * getInsertValue(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs)
Definition: Constants.cpp:1969
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:663
virtual void destroyConstant()
Definition: Constants.cpp:1379
void insert(ConstantClass *CP)
Insert the constant into its proper slot.
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U)
Definition: Constants.cpp:2560
const APFloat & getValueAPF() const
Definition: Constants.h:263
VectorType * getType() const
Definition: Constants.h:456
DenseMap< std::pair< Function *, BasicBlock * >, BlockAddress * > BlockAddresses
bool isExactlyValue(const APFloat &V) const
Definition: Constants.cpp:650
Type * getElementType() const
getElementType - Return the element type of the array/vector.
Definition: Constants.cpp:2189
virtual void destroyConstant()
Definition: Constants.cpp:2278
3: 64-bit floating point type
Definition: Type.h:58
bool use_empty() const
Definition: Value.h:149
static Type * getIndexedType(Type *Ptr, ArrayRef< Value * > IdxList)
Function * getFunction() const
Definition: Constants.h:763
static Constant * getSRem(Constant *C1, Constant *C2)
Definition: Constants.cpp:2080
void removeDeadConstantUsers() const
Definition: Constants.cpp:395
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:654
StructConstantsTy StructConstants
LLVM Value Representation.
Definition: Value.h:66
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:664
static Constant * getURem(Constant *C1, Constant *C2)
Definition: Constants.cpp:2076
static VectorType * get(Type *ElementType, unsigned NumElements)
Definition: Type.cpp:706
Constant * getStructElement(unsigned Elt) const
Definition: Constants.cpp:666
iterator end() const
Definition: StringRef.h:99
unsigned greater than
Definition: InstrTypes.h:674
Constant * ConstantFoldExtractValueInstruction(Constant *Agg, ArrayRef< unsigned > Idxs)
Use & Op()
Definition: User.h:81
static Constant * getCompare(unsigned short pred, Constant *C1, Constant *C2)
Return an ICmp or FCmp comparison operator constant expression.
Definition: Constants.cpp:1798
static GetElementPtrInst * CreateInBounds(Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=0)
Definition: Instructions.h:743
static APInt getNullValue(unsigned numBits)
Get the '0' value.
Definition: APInt.h:457
static Constant * getAlignOf(Type *Ty)
Definition: Constants.cpp:1766
static Constant * getMul(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2051
static Constant * get(LLVMContext &Context, ArrayRef< uint8_t > Elts)
Definition: Constants.cpp:2374
unsigned getNumElements() const
Random access to the elements.
Definition: DerivedTypes.h:286
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:656
static Constant * getCast(unsigned ops, Constant *C, Type *Ty)
Definition: Constants.cpp:1444
StringMap< ConstantDataSequential * > CDSConstants
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U)
Definition: Constants.cpp:2732
const T * data() const
Definition: ArrayRef.h:106
bool isThreadDependent() const
isThreadDependent - Return true if the value can vary between threads.
Definition: Constants.cpp:281
Constant * getWithOperands(ArrayRef< Constant * > Ops) const
Definition: Constants.h:1069
static Constant * getBinOpAbsorber(unsigned Opcode, Type *Ty)
Definition: Constants.cpp:2143
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:239
const fltSemantics & getSemantics() const
Definition: APFloat.h:397
iterator end()
Definition: StringMap.h:281
virtual void destroyConstant()
Definition: Constants.cpp:1324
static Constant * getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx)
Definition: Constants.cpp:1930
Constant * getSplatValue() const
Definition: Constants.cpp:1289
void remove(ConstantClass *CP)
Remove this constant from the map.
static ConstantFP * getInfinity(Type *Ty, bool Negative=false)
Definition: Constants.cpp:638
0 0 0 0 Always false (always folded)
Definition: InstrTypes.h:653
signed greater or equal
Definition: InstrTypes.h:679
static Constant * getXor(Constant *C1, Constant *C2)
Definition: Constants.cpp:2096
5: 128-bit floating point type (112-bit mantissa)
Definition: Type.h:60
gep_type_iterator gep_type_begin(const User *GEP)
static const char * areInvalidOperands(Value *Cond, Value *True, Value *False)