LCOV - code coverage report
Current view: top level - lib/IR - Constants.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 1019 1172 86.9 %
Date: 2018-07-13 00:08:38 Functions: 208 226 92.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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/STLExtras.h"
      18             : #include "llvm/ADT/SmallVector.h"
      19             : #include "llvm/ADT/StringMap.h"
      20             : #include "llvm/IR/DerivedTypes.h"
      21             : #include "llvm/IR/GetElementPtrTypeIterator.h"
      22             : #include "llvm/IR/GlobalValue.h"
      23             : #include "llvm/IR/Instructions.h"
      24             : #include "llvm/IR/Module.h"
      25             : #include "llvm/IR/Operator.h"
      26             : #include "llvm/Support/Debug.h"
      27             : #include "llvm/Support/ErrorHandling.h"
      28             : #include "llvm/Support/ManagedStatic.h"
      29             : #include "llvm/Support/MathExtras.h"
      30             : #include "llvm/Support/raw_ostream.h"
      31             : #include <algorithm>
      32             : 
      33             : using namespace llvm;
      34             : 
      35             : //===----------------------------------------------------------------------===//
      36             : //                              Constant Class
      37             : //===----------------------------------------------------------------------===//
      38             : 
      39        4600 : bool Constant::isNegativeZeroValue() const {
      40             :   // Floating point values have an explicit -0.0 value.
      41             :   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
      42         104 :     return CFP->isZero() && CFP->isNegative();
      43             : 
      44             :   // Equivalent for a vector of -0.0's.
      45             :   if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this))
      46         119 :     if (CV->getElementType()->isFloatingPointTy() && CV->isSplat())
      47          98 :       if (CV->getElementAsAPFloat(0).isNegZero())
      48             :         return true;
      49             : 
      50             :   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
      51          16 :     if (ConstantFP *SplatCFP = dyn_cast_or_null<ConstantFP>(CV->getSplatValue()))
      52           0 :       if (SplatCFP && SplatCFP->isZero() && SplatCFP->isNegative())
      53             :         return true;
      54             : 
      55             :   // We've already handled true FP case; any other FP vectors can't represent -0.0.
      56        4490 :   if (getType()->isFPOrFPVectorTy())
      57             :     return false;
      58             : 
      59             :   // Otherwise, just use +0.0.
      60        4469 :   return isNullValue();
      61             : }
      62             : 
      63             : // Return true iff this constant is positive zero (floating point), negative
      64             : // zero (floating point), or a null value.
      65     1283990 : bool Constant::isZeroValue() const {
      66             :   // Floating point values have an explicit -0.0 value.
      67             :   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
      68         506 :     return CFP->isZero();
      69             : 
      70             :   // Equivalent for a vector of -0.0's.
      71             :   if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this))
      72         953 :     if (CV->getElementType()->isFloatingPointTy() && CV->isSplat())
      73         162 :       if (CV->getElementAsAPFloat(0).isZero())
      74             :         return true;
      75             : 
      76             :   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
      77         117 :     if (ConstantFP *SplatCFP = dyn_cast_or_null<ConstantFP>(CV->getSplatValue()))
      78           0 :       if (SplatCFP && SplatCFP->isZero())
      79             :         return true;
      80             : 
      81             :   // Otherwise, just use +0.0.
      82     1283453 :   return isNullValue();
      83             : }
      84             : 
      85    41880166 : bool Constant::isNullValue() const {
      86             :   // 0 is null.
      87             :   if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
      88             :     return CI->isZero();
      89             : 
      90             :   // +0.0 is null.
      91             :   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
      92       33037 :     return CFP->isZero() && !CFP->isNegative();
      93             : 
      94             :   // constant zero is zero for aggregates, cpnull is null for pointers, none for
      95             :   // tokens.
      96    28346430 :   return isa<ConstantAggregateZero>(this) || isa<ConstantPointerNull>(this) ||
      97             :          isa<ConstantTokenNone>(this);
      98             : }
      99             : 
     100     1418848 : bool Constant::isAllOnesValue() const {
     101             :   // Check for -1 integers
     102             :   if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
     103             :     return CI->isMinusOne();
     104             : 
     105             :   // Check for FP which are bitcasted from -1 integers
     106             :   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
     107         160 :     return CFP->getValueAPF().bitcastToAPInt().isAllOnesValue();
     108             : 
     109             :   // Check for constant vectors which are splats of -1 values.
     110             :   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
     111         485 :     if (Constant *Splat = CV->getSplatValue())
     112         126 :       return Splat->isAllOnesValue();
     113             : 
     114             :   // Check for constant vectors which are splats of -1 values.
     115             :   if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this)) {
     116        8617 :     if (CV->isSplat()) {
     117        6527 :       if (CV->getElementType()->isFloatingPointTy())
     118         624 :         return CV->getElementAsAPFloat(0).bitcastToAPInt().isAllOnesValue();
     119       12638 :       return CV->getElementAsAPInt(0).isAllOnesValue();
     120             :     }
     121             :   }
     122             : 
     123             :   return false;
     124             : }
     125             : 
     126         502 : bool Constant::isOneValue() const {
     127             :   // Check for 1 integers
     128             :   if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
     129             :     return CI->isOne();
     130             : 
     131             :   // Check for FP which are bitcasted from 1 integers
     132             :   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
     133           0 :     return CFP->getValueAPF().bitcastToAPInt().isOneValue();
     134             : 
     135             :   // Check for constant vectors which are splats of 1 values.
     136             :   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
     137           0 :     if (Constant *Splat = CV->getSplatValue())
     138           0 :       return Splat->isOneValue();
     139             : 
     140             :   // Check for constant vectors which are splats of 1 values.
     141             :   if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this)) {
     142           0 :     if (CV->isSplat()) {
     143           0 :       if (CV->getElementType()->isFloatingPointTy())
     144           0 :         return CV->getElementAsAPFloat(0).bitcastToAPInt().isOneValue();
     145           0 :       return CV->getElementAsAPInt(0).isOneValue();
     146             :     }
     147             :   }
     148             : 
     149             :   return false;
     150             : }
     151             : 
     152        3661 : bool Constant::isMinSignedValue() const {
     153             :   // Check for INT_MIN integers
     154             :   if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
     155        3560 :     return CI->isMinValue(/*isSigned=*/true);
     156             : 
     157             :   // Check for FP which are bitcasted from INT_MIN integers
     158             :   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
     159           0 :     return CFP->getValueAPF().bitcastToAPInt().isMinSignedValue();
     160             : 
     161             :   // Check for constant vectors which are splats of INT_MIN values.
     162             :   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
     163           0 :     if (Constant *Splat = CV->getSplatValue())
     164           0 :       return Splat->isMinSignedValue();
     165             : 
     166             :   // Check for constant vectors which are splats of INT_MIN values.
     167             :   if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this)) {
     168         101 :     if (CV->isSplat()) {
     169          13 :       if (CV->getElementType()->isFloatingPointTy())
     170           0 :         return CV->getElementAsAPFloat(0).bitcastToAPInt().isMinSignedValue();
     171          26 :       return CV->getElementAsAPInt(0).isMinSignedValue();
     172             :     }
     173             :   }
     174             : 
     175             :   return false;
     176             : }
     177             : 
     178        1002 : bool Constant::isNotMinSignedValue() const {
     179             :   // Check for INT_MIN integers
     180             :   if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
     181         990 :     return !CI->isMinValue(/*isSigned=*/true);
     182             : 
     183             :   // Check for FP which are bitcasted from INT_MIN integers
     184             :   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
     185           0 :     return !CFP->getValueAPF().bitcastToAPInt().isMinSignedValue();
     186             : 
     187             :   // Check for constant vectors which are splats of INT_MIN values.
     188             :   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
     189           3 :     if (Constant *Splat = CV->getSplatValue())
     190           1 :       return Splat->isNotMinSignedValue();
     191             : 
     192             :   // Check for constant vectors which are splats of INT_MIN values.
     193             :   if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this)) {
     194           9 :     if (CV->isSplat()) {
     195           7 :       if (CV->getElementType()->isFloatingPointTy())
     196           0 :         return !CV->getElementAsAPFloat(0).bitcastToAPInt().isMinSignedValue();
     197          14 :       return !CV->getElementAsAPInt(0).isMinSignedValue();
     198             :     }
     199             :   }
     200             : 
     201             :   // It *may* contain INT_MIN, we can't tell.
     202             :   return false;
     203             : }
     204             : 
     205         331 : bool Constant::isFiniteNonZeroFP() const {
     206             :   if (auto *CFP = dyn_cast<ConstantFP>(this))
     207         286 :     return CFP->getValueAPF().isFiniteNonZero();
     208          90 :   if (!getType()->isVectorTy())
     209             :     return false;
     210         233 :   for (unsigned i = 0, e = getType()->getVectorNumElements(); i != e; ++i) {
     211         112 :     auto *CFP = dyn_cast_or_null<ConstantFP>(this->getAggregateElement(i));
     212         112 :     if (!CFP || !CFP->getValueAPF().isFiniteNonZero())
     213             :       return false;
     214             :   }
     215             :   return true;
     216             : }
     217             : 
     218          52 : bool Constant::isNormalFP() const {
     219             :   if (auto *CFP = dyn_cast<ConstantFP>(this))
     220          32 :     return CFP->getValueAPF().isNormal();
     221          40 :   if (!getType()->isVectorTy())
     222             :     return false;
     223         124 :   for (unsigned i = 0, e = getType()->getVectorNumElements(); i != e; ++i) {
     224          53 :     auto *CFP = dyn_cast_or_null<ConstantFP>(this->getAggregateElement(i));
     225          52 :     if (!CFP || !CFP->getValueAPF().isNormal())
     226             :       return false;
     227             :   }
     228             :   return true;
     229             : }
     230             : 
     231          77 : bool Constant::hasExactInverseFP() const {
     232             :   if (auto *CFP = dyn_cast<ConstantFP>(this))
     233          49 :     return CFP->getValueAPF().getExactInverse(nullptr);
     234          56 :   if (!getType()->isVectorTy())
     235             :     return false;
     236          82 :   for (unsigned i = 0, e = getType()->getVectorNumElements(); i != e; ++i) {
     237          48 :     auto *CFP = dyn_cast_or_null<ConstantFP>(this->getAggregateElement(i));
     238          45 :     if (!CFP || !CFP->getValueAPF().getExactInverse(nullptr))
     239             :       return false;
     240             :   }
     241             :   return true;
     242             : }
     243             : 
     244          98 : bool Constant::isNaN() const {
     245             :   if (auto *CFP = dyn_cast<ConstantFP>(this))
     246          92 :     return CFP->isNaN();
     247          12 :   if (!getType()->isVectorTy())
     248             :     return false;
     249          32 :   for (unsigned i = 0, e = getType()->getVectorNumElements(); i != e; ++i) {
     250          14 :     auto *CFP = dyn_cast_or_null<ConstantFP>(this->getAggregateElement(i));
     251          13 :     if (!CFP || !CFP->isNaN())
     252             :       return false;
     253             :   }
     254             :   return true;
     255             : }
     256             : 
     257         202 : bool Constant::containsUndefElement() const {
     258         404 :   if (!getType()->isVectorTy())
     259             :     return false;
     260        1268 :   for (unsigned i = 0, e = getType()->getVectorNumElements(); i != e; ++i)
     261        1228 :     if (isa<UndefValue>(getAggregateElement(i)))
     262             :       return true;
     263             : 
     264             :   return false;
     265             : }
     266             : 
     267             : /// Constructor to create a '0' constant of arbitrary type.
     268     3518202 : Constant *Constant::getNullValue(Type *Ty) {
     269     3518202 :   switch (Ty->getTypeID()) {
     270     3397688 :   case Type::IntegerTyID:
     271     3397688 :     return ConstantInt::get(Ty, 0);
     272         239 :   case Type::HalfTyID:
     273         239 :     return ConstantFP::get(Ty->getContext(),
     274         717 :                            APFloat::getZero(APFloat::IEEEhalf()));
     275        2454 :   case Type::FloatTyID:
     276        2454 :     return ConstantFP::get(Ty->getContext(),
     277        7362 :                            APFloat::getZero(APFloat::IEEEsingle()));
     278        1096 :   case Type::DoubleTyID:
     279        1096 :     return ConstantFP::get(Ty->getContext(),
     280        3288 :                            APFloat::getZero(APFloat::IEEEdouble()));
     281         190 :   case Type::X86_FP80TyID:
     282         190 :     return ConstantFP::get(Ty->getContext(),
     283         570 :                            APFloat::getZero(APFloat::x87DoubleExtended()));
     284          57 :   case Type::FP128TyID:
     285          57 :     return ConstantFP::get(Ty->getContext(),
     286         171 :                            APFloat::getZero(APFloat::IEEEquad()));
     287             :   case Type::PPC_FP128TyID:
     288          15 :     return ConstantFP::get(Ty->getContext(),
     289          30 :                            APFloat(APFloat::PPCDoubleDouble(),
     290          30 :                                    APInt::getNullValue(128)));
     291             :   case Type::PointerTyID:
     292       26251 :     return ConstantPointerNull::get(cast<PointerType>(Ty));
     293       89681 :   case Type::StructTyID:
     294             :   case Type::ArrayTyID:
     295             :   case Type::VectorTyID:
     296       89681 :     return ConstantAggregateZero::get(Ty);
     297         531 :   case Type::TokenTyID:
     298         531 :     return ConstantTokenNone::get(Ty->getContext());
     299           0 :   default:
     300             :     // Function, Label, or Opaque type?
     301           0 :     llvm_unreachable("Cannot create a null constant of that type!");
     302             :   }
     303             : }
     304             : 
     305       11019 : Constant *Constant::getIntegerValue(Type *Ty, const APInt &V) {
     306             :   Type *ScalarTy = Ty->getScalarType();
     307             : 
     308             :   // Create the base integer constant.
     309       11019 :   Constant *C = ConstantInt::get(Ty->getContext(), V);
     310             : 
     311             :   // Convert an integer to a pointer, if necessary.
     312             :   if (PointerType *PTy = dyn_cast<PointerType>(ScalarTy))
     313           1 :     C = ConstantExpr::getIntToPtr(C, PTy);
     314             : 
     315             :   // Broadcast a scalar to a vector, if necessary.
     316             :   if (VectorType *VTy = dyn_cast<VectorType>(Ty))
     317           1 :     C = ConstantVector::getSplat(VTy->getNumElements(), C);
     318             : 
     319       11019 :   return C;
     320             : }
     321             : 
     322      513861 : Constant *Constant::getAllOnesValue(Type *Ty) {
     323             :   if (IntegerType *ITy = dyn_cast<IntegerType>(Ty))
     324      507657 :     return ConstantInt::get(Ty->getContext(),
     325     1522971 :                             APInt::getAllOnesValue(ITy->getBitWidth()));
     326             : 
     327             :   if (Ty->isFloatingPointTy()) {
     328             :     APFloat FL = APFloat::getAllOnesValue(Ty->getPrimitiveSizeInBits(),
     329          11 :                                           !Ty->isPPC_FP128Ty());
     330          11 :     return ConstantFP::get(Ty->getContext(), FL);
     331             :   }
     332             : 
     333             :   VectorType *VTy = cast<VectorType>(Ty);
     334        6193 :   return ConstantVector::getSplat(VTy->getNumElements(),
     335        6193 :                                   getAllOnesValue(VTy->getElementType()));
     336             : }
     337             : 
     338     3036675 : Constant *Constant::getAggregateElement(unsigned Elt) const {
     339             :   if (const ConstantAggregate *CC = dyn_cast<ConstantAggregate>(this))
     340     1374302 :     return Elt < CC->getNumOperands() ? CC->getOperand(Elt) : nullptr;
     341             : 
     342             :   if (const ConstantAggregateZero *CAZ = dyn_cast<ConstantAggregateZero>(this))
     343      341746 :     return Elt < CAZ->getNumElements() ? CAZ->getElementValue(Elt) : nullptr;
     344             : 
     345             :   if (const UndefValue *UV = dyn_cast<UndefValue>(this))
     346        4721 :     return Elt < UV->getNumElements() ? UV->getElementValue(Elt) : nullptr;
     347             : 
     348             :   if (const ConstantDataSequential *CDS =dyn_cast<ConstantDataSequential>(this))
     349     1315781 :     return Elt < CDS->getNumElements() ? CDS->getElementAsConstant(Elt)
     350             :                                        : nullptr;
     351             :   return nullptr;
     352             : }
     353             : 
     354        4787 : Constant *Constant::getAggregateElement(Constant *Elt) const {
     355             :   assert(isa<IntegerType>(Elt->getType()) && "Index must be an integer");
     356             :   if (ConstantInt *CI = dyn_cast<ConstantInt>(Elt))
     357        4787 :     return getAggregateElement(CI->getZExtValue());
     358             :   return nullptr;
     359             : }
     360             : 
     361      345611 : void Constant::destroyConstant() {
     362             :   /// First call destroyConstantImpl on the subclass.  This gives the subclass
     363             :   /// a chance to remove the constant from any maps/pools it's contained in.
     364      691222 :   switch (getValueID()) {
     365           0 :   default:
     366           0 :     llvm_unreachable("Not a constant!");
     367             : #define HANDLE_CONSTANT(Name)                                                  \
     368             :   case Value::Name##Val:                                                       \
     369             :     cast<Name>(this)->destroyConstantImpl();                                   \
     370             :     break;
     371             : #include "llvm/IR/Value.def"
     372             :   }
     373             : 
     374             :   // When a Constant is destroyed, there may be lingering
     375             :   // references to the constant by other constants in the constant pool.  These
     376             :   // constants are implicitly dependent on the module that is being deleted,
     377             :   // but they don't know that.  Because we only find out when the CPV is
     378             :   // deleted, we must now notify all of our users (that should only be
     379             :   // Constants) that they are, in fact, invalid now and should be deleted.
     380             :   //
     381           0 :   while (!use_empty()) {
     382             :     Value *V = user_back();
     383             : #ifndef NDEBUG // Only in -g mode...
     384             :     if (!isa<Constant>(V)) {
     385             :       dbgs() << "While deleting: " << *this
     386             :              << "\n\nUse still stuck around after Def is destroyed: " << *V
     387             :              << "\n\n";
     388             :     }
     389             : #endif
     390             :     assert(isa<Constant>(V) && "References remain to Constant being destroyed");
     391           0 :     cast<Constant>(V)->destroyConstant();
     392             : 
     393             :     // The constant should remove itself from our use list...
     394             :     assert((use_empty() || user_back() != V) && "Constant not removed!");
     395             :   }
     396             : 
     397             :   // Value has no outstanding references it is safe to delete it now...
     398      345611 :   delete this;
     399      345611 : }
     400             : 
     401     1410895 : static bool canTrapImpl(const Constant *C,
     402             :                         SmallPtrSetImpl<const ConstantExpr *> &NonTrappingOps) {
     403             :   assert(C->getType()->isFirstClassType() && "Cannot evaluate aggregate vals!");
     404             :   // The only thing that could possibly trap are constant exprs.
     405             :   const ConstantExpr *CE = dyn_cast<ConstantExpr>(C);
     406             :   if (!CE)
     407             :     return false;
     408             : 
     409             :   // ConstantExpr traps if any operands can trap.
     410      458051 :   for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) {
     411             :     if (ConstantExpr *Op = dyn_cast<ConstantExpr>(CE->getOperand(i))) {
     412        1229 :       if (NonTrappingOps.insert(Op).second && canTrapImpl(Op, NonTrappingOps))
     413             :         return true;
     414             :     }
     415             :   }
     416             : 
     417             :   // Otherwise, only specific operations can trap.
     418             :   switch (CE->getOpcode()) {
     419             :   default:
     420             :     return false;
     421             :   case Instruction::UDiv:
     422             :   case Instruction::SDiv:
     423             :   case Instruction::URem:
     424             :   case Instruction::SRem:
     425             :     // Div and rem can trap if the RHS is not known to be non-zero.
     426          24 :     if (!isa<ConstantInt>(CE->getOperand(1)) ||CE->getOperand(1)->isNullValue())
     427             :       return true;
     428             :     return false;
     429             :   }
     430             : }
     431             : 
     432     1410040 : bool Constant::canTrap() const {
     433             :   SmallPtrSet<const ConstantExpr *, 4> NonTrappingOps;
     434     2820080 :   return canTrapImpl(this, NonTrappingOps);
     435             : }
     436             : 
     437             : /// Check if C contains a GlobalValue for which Predicate is true.
     438             : static bool
     439       54696 : ConstHasGlobalValuePredicate(const Constant *C,
     440             :                              bool (*Predicate)(const GlobalValue *)) {
     441             :   SmallPtrSet<const Constant *, 8> Visited;
     442             :   SmallVector<const Constant *, 8> WorkList;
     443       54696 :   WorkList.push_back(C);
     444       54696 :   Visited.insert(C);
     445             : 
     446      109910 :   while (!WorkList.empty()) {
     447             :     const Constant *WorkItem = WorkList.pop_back_val();
     448             :     if (const auto *GV = dyn_cast<GlobalValue>(WorkItem))
     449         264 :       if (Predicate(GV))
     450             :         return true;
     451      112196 :     for (const Value *Op : WorkItem->operands()) {
     452         884 :       const Constant *ConstOp = dyn_cast<Constant>(Op);
     453         884 :       if (!ConstOp)
     454           1 :         continue;
     455         883 :       if (Visited.insert(ConstOp).second)
     456         530 :         WorkList.push_back(ConstOp);
     457             :     }
     458             :   }
     459             :   return false;
     460             : }
     461             : 
     462       53588 : bool Constant::isThreadDependent() const {
     463         168 :   auto DLLImportPredicate = [](const GlobalValue *GV) {
     464             :     return GV->isThreadLocal();
     465         168 :   };
     466       53588 :   return ConstHasGlobalValuePredicate(this, DLLImportPredicate);
     467             : }
     468             : 
     469        1108 : bool Constant::isDLLImportDependent() const {
     470          96 :   auto DLLImportPredicate = [](const GlobalValue *GV) {
     471             :     return GV->hasDLLImportStorageClass();
     472          96 :   };
     473        1108 :   return ConstHasGlobalValuePredicate(this, DLLImportPredicate);
     474             : }
     475             : 
     476      143716 : bool Constant::isConstantUsed() const {
     477      143831 :   for (const User *U : users()) {
     478             :     const Constant *UC = dyn_cast<Constant>(U);
     479             :     if (!UC || isa<GlobalValue>(UC))
     480             :       return true;
     481             : 
     482       71594 :     if (UC->isConstantUsed())
     483             :       return true;
     484             :   }
     485             :   return false;
     486             : }
     487             : 
     488     2825329 : bool Constant::needsRelocation() const {
     489             :   if (isa<GlobalValue>(this))
     490             :     return true; // Global reference.
     491             : 
     492             :   if (const BlockAddress *BA = dyn_cast<BlockAddress>(this))
     493         220 :     return BA->getFunction()->needsRelocation();
     494             : 
     495             :   // While raw uses of blockaddress need to be relocated, differences between
     496             :   // two of them don't when they are for labels in the same function.  This is a
     497             :   // common idiom when creating a table for the indirect goto extension, so we
     498             :   // handle it efficiently here.
     499             :   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(this))
     500      101746 :     if (CE->getOpcode() == Instruction::Sub) {
     501             :       ConstantExpr *LHS = dyn_cast<ConstantExpr>(CE->getOperand(0));
     502             :       ConstantExpr *RHS = dyn_cast<ConstantExpr>(CE->getOperand(1));
     503         297 :       if (LHS && RHS && LHS->getOpcode() == Instruction::PtrToInt &&
     504          99 :           RHS->getOpcode() == Instruction::PtrToInt &&
     505           6 :           isa<BlockAddress>(LHS->getOperand(0)) &&
     506         105 :           isa<BlockAddress>(RHS->getOperand(0)) &&
     507             :           cast<BlockAddress>(LHS->getOperand(0))->getFunction() ==
     508             :               cast<BlockAddress>(RHS->getOperand(0))->getFunction())
     509             :         return false;
     510             :     }
     511             : 
     512             :   bool Result = false;
     513     8239351 :   for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
     514     5515332 :     Result |= cast<Constant>(getOperand(i))->needsRelocation();
     515             : 
     516             :   return Result;
     517             : }
     518             : 
     519             : /// If the specified constantexpr is dead, remove it. This involves recursively
     520             : /// eliminating any dead users of the constantexpr.
     521     5425538 : static bool removeDeadUsersOfConstant(const Constant *C) {
     522             :   if (isa<GlobalValue>(C)) return false; // Cannot remove this
     523             : 
     524     4448489 :   while (!C->use_empty()) {
     525             :     const Constant *User = dyn_cast<Constant>(C->user_back());
     526             :     if (!User) return false; // Non-constant usage;
     527     2547162 :     if (!removeDeadUsersOfConstant(User))
     528             :       return false; // Constant wasn't dead
     529             :   }
     530             : 
     531      343182 :   const_cast<Constant*>(C)->destroyConstant();
     532      343182 :   return true;
     533             : }
     534             : 
     535             : 
     536     1582015 : void Constant::removeDeadConstantUsers() const {
     537             :   Value::const_user_iterator I = user_begin(), E = user_end();
     538             :   Value::const_user_iterator LastNonDeadUser = E;
     539     7724172 :   while (I != E) {
     540             :     const Constant *User = dyn_cast<Constant>(*I);
     541     3356579 :     if (!User) {
     542             :       LastNonDeadUser = I;
     543             :       ++I;
     544     3356579 :       continue;
     545             :     }
     546             : 
     547     5451313 :     if (!removeDeadUsersOfConstant(User)) {
     548             :       // If the constant wasn't dead, remember that this was the last live use
     549             :       // and move on to the next constant.
     550             :       LastNonDeadUser = I;
     551             :       ++I;
     552     2572937 :       continue;
     553             :     }
     554             : 
     555             :     // If the constant was dead, then the iterator is invalidated.
     556      305439 :     if (LastNonDeadUser == E) {
     557             :       I = user_begin();
     558      146520 :       if (I == E) break;
     559             :     } else {
     560             :       I = LastNonDeadUser;
     561             :       ++I;
     562             :     }
     563             :   }
     564     1582015 : }
     565             : 
     566             : 
     567             : 
     568             : //===----------------------------------------------------------------------===//
     569             : //                                ConstantInt
     570             : //===----------------------------------------------------------------------===//
     571             : 
     572      800492 : ConstantInt::ConstantInt(IntegerType *Ty, const APInt &V)
     573      800492 :     : ConstantData(Ty, ConstantIntVal), Val(V) {
     574             :   assert(V.getBitWidth() == Ty->getBitWidth() && "Invalid constant for type");
     575      800492 : }
     576             : 
     577      290820 : ConstantInt *ConstantInt::getTrue(LLVMContext &Context) {
     578      290820 :   LLVMContextImpl *pImpl = Context.pImpl;
     579      290820 :   if (!pImpl->TheTrueVal)
     580        8895 :     pImpl->TheTrueVal = ConstantInt::get(Type::getInt1Ty(Context), 1);
     581      290820 :   return pImpl->TheTrueVal;
     582             : }
     583             : 
     584      153659 : ConstantInt *ConstantInt::getFalse(LLVMContext &Context) {
     585      153659 :   LLVMContextImpl *pImpl = Context.pImpl;
     586      153659 :   if (!pImpl->TheFalseVal)
     587        6074 :     pImpl->TheFalseVal = ConstantInt::get(Type::getInt1Ty(Context), 0);
     588      153659 :   return pImpl->TheFalseVal;
     589             : }
     590             : 
     591       35065 : Constant *ConstantInt::getTrue(Type *Ty) {
     592             :   assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1.");
     593       35065 :   ConstantInt *TrueC = ConstantInt::getTrue(Ty->getContext());
     594             :   if (auto *VTy = dyn_cast<VectorType>(Ty))
     595          48 :     return ConstantVector::getSplat(VTy->getNumElements(), TrueC);
     596             :   return TrueC;
     597             : }
     598             : 
     599        4429 : Constant *ConstantInt::getFalse(Type *Ty) {
     600             :   assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1.");
     601        4429 :   ConstantInt *FalseC = ConstantInt::getFalse(Ty->getContext());
     602             :   if (auto *VTy = dyn_cast<VectorType>(Ty))
     603          59 :     return ConstantVector::getSplat(VTy->getNumElements(), FalseC);
     604             :   return FalseC;
     605             : }
     606             : 
     607             : // Get a ConstantInt from an APInt.
     608    47774104 : ConstantInt *ConstantInt::get(LLVMContext &Context, const APInt &V) {
     609             :   // get an existing value or the insertion position
     610    47774104 :   LLVMContextImpl *pImpl = Context.pImpl;
     611    47774104 :   std::unique_ptr<ConstantInt> &Slot = pImpl->IntConstants[V];
     612    47774104 :   if (!Slot) {
     613             :     // Get the corresponding integer type for the bit width of the value.
     614      800492 :     IntegerType *ITy = IntegerType::get(Context, V.getBitWidth());
     615      800492 :     Slot.reset(new ConstantInt(ITy, V));
     616             :   }
     617             :   assert(Slot->getType() == IntegerType::get(Context, V.getBitWidth()));
     618    47774104 :   return Slot.get();
     619             : }
     620             : 
     621     7057849 : Constant *ConstantInt::get(Type *Ty, uint64_t V, bool isSigned) {
     622    14115698 :   Constant *C = get(cast<IntegerType>(Ty->getScalarType()), V, isSigned);
     623             : 
     624             :   // For vectors, broadcast the value.
     625             :   if (VectorType *VTy = dyn_cast<VectorType>(Ty))
     626        1585 :     return ConstantVector::getSplat(VTy->getNumElements(), C);
     627             : 
     628             :   return C;
     629             : }
     630             : 
     631    11473480 : ConstantInt *ConstantInt::get(IntegerType *Ty, uint64_t V, bool isSigned) {
     632    34420440 :   return get(Ty->getContext(), APInt(Ty->getBitWidth(), V, isSigned));
     633             : }
     634             : 
     635        4141 : ConstantInt *ConstantInt::getSigned(IntegerType *Ty, int64_t V) {
     636        4141 :   return get(Ty, V, true);
     637             : }
     638             : 
     639        7343 : Constant *ConstantInt::getSigned(Type *Ty, int64_t V) {
     640        7343 :   return get(Ty, V, true);
     641             : }
     642             : 
     643    21556860 : Constant *ConstantInt::get(Type *Ty, const APInt& V) {
     644    21556860 :   ConstantInt *C = get(Ty->getContext(), V);
     645             :   assert(C->getType() == Ty->getScalarType() &&
     646             :          "ConstantInt type doesn't match the type implied by its value!");
     647             : 
     648             :   // For vectors, broadcast the value.
     649             :   if (VectorType *VTy = dyn_cast<VectorType>(Ty))
     650         504 :     return ConstantVector::getSplat(VTy->getNumElements(), C);
     651             : 
     652             :   return C;
     653             : }
     654             : 
     655         297 : ConstantInt *ConstantInt::get(IntegerType* Ty, StringRef Str, uint8_t radix) {
     656         891 :   return get(Ty->getContext(), APInt(Ty->getBitWidth(), Str, radix));
     657             : }
     658             : 
     659             : /// Remove the constant from the constant table.
     660           0 : void ConstantInt::destroyConstantImpl() {
     661           0 :   llvm_unreachable("You can't ConstantInt->destroyConstantImpl()!");
     662             : }
     663             : 
     664             : //===----------------------------------------------------------------------===//
     665             : //                                ConstantFP
     666             : //===----------------------------------------------------------------------===//
     667             : 
     668        7684 : static const fltSemantics *TypeToFloatSemantics(Type *Ty) {
     669        7684 :   if (Ty->isHalfTy())
     670         392 :     return &APFloat::IEEEhalf();
     671        7292 :   if (Ty->isFloatTy())
     672        4604 :     return &APFloat::IEEEsingle();
     673        2688 :   if (Ty->isDoubleTy())
     674        2614 :     return &APFloat::IEEEdouble();
     675          74 :   if (Ty->isX86_FP80Ty())
     676          16 :     return &APFloat::x87DoubleExtended();
     677          58 :   else if (Ty->isFP128Ty())
     678          48 :     return &APFloat::IEEEquad();
     679             : 
     680             :   assert(Ty->isPPC_FP128Ty() && "Unknown FP format");
     681          10 :   return &APFloat::PPCDoubleDouble();
     682             : }
     683             : 
     684         923 : Constant *ConstantFP::get(Type *Ty, double V) {
     685         923 :   LLVMContext &Context = Ty->getContext();
     686             : 
     687         923 :   APFloat FV(V);
     688             :   bool ignored;
     689         923 :   FV.convert(*TypeToFloatSemantics(Ty->getScalarType()),
     690             :              APFloat::rmNearestTiesToEven, &ignored);
     691         923 :   Constant *C = get(Context, FV);
     692             : 
     693             :   // For vectors, broadcast the value.
     694             :   if (VectorType *VTy = dyn_cast<VectorType>(Ty))
     695          43 :     return ConstantVector::getSplat(VTy->getNumElements(), C);
     696             : 
     697             :   return C;
     698             : }
     699             : 
     700           0 : Constant *ConstantFP::get(Type *Ty, const APFloat &V) {
     701           0 :   ConstantFP *C = get(Ty->getContext(), V);
     702             :   assert(C->getType() == Ty->getScalarType() &&
     703             :          "ConstantFP type doesn't match the type implied by its value!");
     704             : 
     705             :   // For vectors, broadcast the value.
     706             :   if (auto *VTy = dyn_cast<VectorType>(Ty))
     707           0 :     return ConstantVector::getSplat(VTy->getNumElements(), C);
     708             : 
     709             :   return C;
     710             : }
     711             : 
     712           0 : Constant *ConstantFP::get(Type *Ty, StringRef Str) {
     713           0 :   LLVMContext &Context = Ty->getContext();
     714             : 
     715           0 :   APFloat FV(*TypeToFloatSemantics(Ty->getScalarType()), Str);
     716           0 :   Constant *C = get(Context, FV);
     717             : 
     718             :   // For vectors, broadcast the value.
     719             :   if (VectorType *VTy = dyn_cast<VectorType>(Ty))
     720           0 :     return ConstantVector::getSplat(VTy->getNumElements(), C);
     721             : 
     722             :   return C;
     723             : }
     724             : 
     725         516 : Constant *ConstantFP::getNaN(Type *Ty, bool Negative, unsigned Type) {
     726         516 :   const fltSemantics &Semantics = *TypeToFloatSemantics(Ty->getScalarType());
     727         516 :   APFloat NaN = APFloat::getNaN(Semantics, Negative, Type);
     728         516 :   Constant *C = get(Ty->getContext(), NaN);
     729             : 
     730             :   if (VectorType *VTy = dyn_cast<VectorType>(Ty))
     731          12 :     return ConstantVector::getSplat(VTy->getNumElements(), C);
     732             : 
     733             :   return C;
     734             : }
     735             : 
     736        6170 : Constant *ConstantFP::getNegativeZero(Type *Ty) {
     737        6170 :   const fltSemantics &Semantics = *TypeToFloatSemantics(Ty->getScalarType());
     738             :   APFloat NegZero = APFloat::getZero(Semantics, /*Negative=*/true);
     739        6170 :   Constant *C = get(Ty->getContext(), NegZero);
     740             : 
     741             :   if (VectorType *VTy = dyn_cast<VectorType>(Ty))
     742        3287 :     return ConstantVector::getSplat(VTy->getNumElements(), C);
     743             : 
     744             :   return C;
     745             : }
     746             : 
     747             : 
     748      395841 : Constant *ConstantFP::getZeroValueForNegation(Type *Ty) {
     749             :   if (Ty->isFPOrFPVectorTy())
     750        6107 :     return getNegativeZero(Ty);
     751             : 
     752      389734 :   return Constant::getNullValue(Ty);
     753             : }
     754             : 
     755             : 
     756             : // ConstantFP accessors.
     757      125151 : ConstantFP* ConstantFP::get(LLVMContext &Context, const APFloat& V) {
     758      125151 :   LLVMContextImpl* pImpl = Context.pImpl;
     759             : 
     760      125151 :   std::unique_ptr<ConstantFP> &Slot = pImpl->FPConstants[V];
     761             : 
     762      125151 :   if (!Slot) {
     763             :     Type *Ty;
     764       24382 :     if (&V.getSemantics() == &APFloat::IEEEhalf())
     765        1060 :       Ty = Type::getHalfTy(Context);
     766       23322 :     else if (&V.getSemantics() == &APFloat::IEEEsingle())
     767       13708 :       Ty = Type::getFloatTy(Context);
     768        9614 :     else if (&V.getSemantics() == &APFloat::IEEEdouble())
     769        8878 :       Ty = Type::getDoubleTy(Context);
     770         736 :     else if (&V.getSemantics() == &APFloat::x87DoubleExtended())
     771         304 :       Ty = Type::getX86_FP80Ty(Context);
     772         432 :     else if (&V.getSemantics() == &APFloat::IEEEquad())
     773         351 :       Ty = Type::getFP128Ty(Context);
     774             :     else {
     775             :       assert(&V.getSemantics() == &APFloat::PPCDoubleDouble() &&
     776             :              "Unknown FP format");
     777          81 :       Ty = Type::getPPC_FP128Ty(Context);
     778             :     }
     779       24382 :     Slot.reset(new ConstantFP(Ty, V));
     780             :   }
     781             : 
     782      125151 :   return Slot.get();
     783             : }
     784             : 
     785          75 : Constant *ConstantFP::getInfinity(Type *Ty, bool Negative) {
     786          75 :   const fltSemantics &Semantics = *TypeToFloatSemantics(Ty->getScalarType());
     787         225 :   Constant *C = get(Ty->getContext(), APFloat::getInf(Semantics, Negative));
     788             : 
     789             :   if (VectorType *VTy = dyn_cast<VectorType>(Ty))
     790           0 :     return ConstantVector::getSplat(VTy->getNumElements(), C);
     791             : 
     792             :   return C;
     793             : }
     794             : 
     795       24382 : ConstantFP::ConstantFP(Type *Ty, const APFloat &V)
     796             :     : ConstantData(Ty, ConstantFPVal), Val(V) {
     797             :   assert(&V.getSemantics() == TypeToFloatSemantics(Ty) &&
     798             :          "FP type Mismatch");
     799       24382 : }
     800             : 
     801        3937 : bool ConstantFP::isExactlyValue(const APFloat &V) const {
     802        3937 :   return Val.bitwiseIsEqual(V);
     803             : }
     804             : 
     805             : /// Remove the constant from the constant table.
     806           0 : void ConstantFP::destroyConstantImpl() {
     807           0 :   llvm_unreachable("You can't ConstantFP->destroyConstantImpl()!");
     808             : }
     809             : 
     810             : //===----------------------------------------------------------------------===//
     811             : //                   ConstantAggregateZero Implementation
     812             : //===----------------------------------------------------------------------===//
     813             : 
     814      340976 : Constant *ConstantAggregateZero::getSequentialElement() const {
     815      681952 :   return Constant::getNullValue(getType()->getSequentialElementType());
     816             : }
     817             : 
     818         791 : Constant *ConstantAggregateZero::getStructElement(unsigned Elt) const {
     819        1582 :   return Constant::getNullValue(getType()->getStructElementType(Elt));
     820             : }
     821             : 
     822           0 : Constant *ConstantAggregateZero::getElementValue(Constant *C) const {
     823           0 :   if (isa<SequentialType>(getType()))
     824           0 :     return getSequentialElement();
     825           0 :   return getStructElement(cast<ConstantInt>(C)->getZExtValue());
     826             : }
     827             : 
     828      341767 : Constant *ConstantAggregateZero::getElementValue(unsigned Idx) const {
     829      341767 :   if (isa<SequentialType>(getType()))
     830      340976 :     return getSequentialElement();
     831         791 :   return getStructElement(Idx);
     832             : }
     833             : 
     834      341784 : unsigned ConstantAggregateZero::getNumElements() const {
     835      341784 :   Type *Ty = getType();
     836             :   if (auto *AT = dyn_cast<ArrayType>(Ty))
     837      163012 :     return AT->getNumElements();
     838             :   if (auto *VT = dyn_cast<VectorType>(Ty))
     839      177980 :     return VT->getNumElements();
     840         792 :   return Ty->getStructNumElements();
     841             : }
     842             : 
     843             : //===----------------------------------------------------------------------===//
     844             : //                         UndefValue Implementation
     845             : //===----------------------------------------------------------------------===//
     846             : 
     847        2537 : UndefValue *UndefValue::getSequentialElement() const {
     848        5074 :   return UndefValue::get(getType()->getSequentialElementType());
     849             : }
     850             : 
     851        2179 : UndefValue *UndefValue::getStructElement(unsigned Elt) const {
     852        4358 :   return UndefValue::get(getType()->getStructElementType(Elt));
     853             : }
     854             : 
     855           0 : UndefValue *UndefValue::getElementValue(Constant *C) const {
     856           0 :   if (isa<SequentialType>(getType()))
     857           0 :     return getSequentialElement();
     858           0 :   return getStructElement(cast<ConstantInt>(C)->getZExtValue());
     859             : }
     860             : 
     861        4716 : UndefValue *UndefValue::getElementValue(unsigned Idx) const {
     862        4716 :   if (isa<SequentialType>(getType()))
     863        2537 :     return getSequentialElement();
     864        2179 :   return getStructElement(Idx);
     865             : }
     866             : 
     867        4721 : unsigned UndefValue::getNumElements() const {
     868        4721 :   Type *Ty = getType();
     869             :   if (auto *ST = dyn_cast<SequentialType>(Ty))
     870        2540 :     return ST->getNumElements();
     871        2181 :   return Ty->getStructNumElements();
     872             : }
     873             : 
     874             : //===----------------------------------------------------------------------===//
     875             : //                            ConstantXXX Classes
     876             : //===----------------------------------------------------------------------===//
     877             : 
     878             : template <typename ItTy, typename EltTy>
     879             : static bool rangeOnlyContains(ItTy Start, ItTy End, EltTy Elt) {
     880       21193 :   for (; Start != End; ++Start)
     881       12156 :     if (*Start != Elt)
     882             :       return false;
     883             :   return true;
     884             : }
     885             : 
     886             : template <typename SequentialTy, typename ElementTy>
     887      257450 : static Constant *getIntSequenceIfElementsMatch(ArrayRef<Constant *> V) {
     888             :   assert(!V.empty() && "Cannot get empty int sequence.");
     889             : 
     890             :   SmallVector<ElementTy, 16> Elts;
     891     2911210 :   for (Constant *C : V)
     892             :     if (auto *CI = dyn_cast<ConstantInt>(C))
     893     1326880 :       Elts.push_back(CI->getZExtValue());
     894             :     else
     895             :       return nullptr;
     896      165567 :   return SequentialTy::get(V[0]->getContext(), Elts);
     897             : }
     898             : 
     899             : template <typename SequentialTy, typename ElementTy>
     900        8731 : static Constant *getFPSequenceIfElementsMatch(ArrayRef<Constant *> V) {
     901             :   assert(!V.empty() && "Cannot get empty FP sequence.");
     902             : 
     903             :   SmallVector<ElementTy, 16> Elts;
     904       89315 :   for (Constant *C : V)
     905             :     if (auto *CFP = dyn_cast<ConstantFP>(C))
     906      120876 :       Elts.push_back(CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
     907             :     else
     908             :       return nullptr;
     909        7244 :   return SequentialTy::getFP(V[0]->getContext(), Elts);
     910             : }
     911             : 
     912             : template <typename SequenceTy>
     913      270974 : static Constant *getSequenceIfElementsMatch(Constant *C,
     914             :                                             ArrayRef<Constant *> V) {
     915             :   // We speculatively build the elements here even if it turns out that there is
     916             :   // a constantexpr or something else weird, since it is so uncommon for that to
     917             :   // happen.
     918             :   if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
     919      257450 :     if (CI->getType()->isIntegerTy(8))
     920       19323 :       return getIntSequenceIfElementsMatch<SequenceTy, uint8_t>(V);
     921      238127 :     else if (CI->getType()->isIntegerTy(16))
     922        8691 :       return getIntSequenceIfElementsMatch<SequenceTy, uint16_t>(V);
     923      229436 :     else if (CI->getType()->isIntegerTy(32))
     924       69360 :       return getIntSequenceIfElementsMatch<SequenceTy, uint32_t>(V);
     925      160076 :     else if (CI->getType()->isIntegerTy(64))
     926      160076 :       return getIntSequenceIfElementsMatch<SequenceTy, uint64_t>(V);
     927             :   } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
     928       17462 :     if (CFP->getType()->isHalfTy())
     929         609 :       return getFPSequenceIfElementsMatch<SequenceTy, uint16_t>(V);
     930        8122 :     else if (CFP->getType()->isFloatTy())
     931        5129 :       return getFPSequenceIfElementsMatch<SequenceTy, uint32_t>(V);
     932        2993 :     else if (CFP->getType()->isDoubleTy())
     933        2993 :       return getFPSequenceIfElementsMatch<SequenceTy, uint64_t>(V);
     934             :   }
     935             : 
     936             :   return nullptr;
     937             : }
     938             : 
     939      112625 : ConstantAggregate::ConstantAggregate(CompositeType *T, ValueTy VT,
     940             :                                      ArrayRef<Constant *> V)
     941             :     : Constant(T, VT, OperandTraits<ConstantAggregate>::op_end(this) - V.size(),
     942             :                V.size()) {
     943             :   std::copy(V.begin(), V.end(), op_begin());
     944             : 
     945             :   // Check that types match, unless this is an opaque struct.
     946             :   if (auto *ST = dyn_cast<StructType>(T))
     947             :     if (ST->isOpaque())
     948             :       return;
     949             :   for (unsigned I = 0, E = V.size(); I != E; ++I)
     950             :     assert(V[I]->getType() == T->getTypeAtIndex(I) &&
     951             :            "Initializer for composite element doesn't match!");
     952             : }
     953             : 
     954       15857 : ConstantArray::ConstantArray(ArrayType *T, ArrayRef<Constant *> V)
     955       15857 :     : ConstantAggregate(T, ConstantArrayVal, V) {
     956             :   assert(V.size() == T->getNumElements() &&
     957             :          "Invalid initializer for constant array");
     958       15857 : }
     959             : 
     960       23262 : Constant *ConstantArray::get(ArrayType *Ty, ArrayRef<Constant*> V) {
     961       23262 :   if (Constant *C = getImpl(Ty, V))
     962             :     return C;
     963       33094 :   return Ty->getContext().pImpl->ArrayConstants.getOrCreate(Ty, V);
     964             : }
     965             : 
     966       24514 : Constant *ConstantArray::getImpl(ArrayType *Ty, ArrayRef<Constant*> V) {
     967             :   // Empty arrays are canonicalized to ConstantAggregateZero.
     968       24514 :   if (V.empty())
     969         301 :     return ConstantAggregateZero::get(Ty);
     970             : 
     971             :   for (unsigned i = 0, e = V.size(); i != e; ++i) {
     972             :     assert(V[i]->getType() == Ty->getElementType() &&
     973             :            "Wrong type in array element initializer");
     974             :   }
     975             : 
     976             :   // If this is an all-zero array, return a ConstantAggregateZero object.  If
     977             :   // all undef, return an UndefValue, if "all simple", then return a
     978             :   // ConstantDataArray.
     979       24213 :   Constant *C = V[0];
     980       24219 :   if (isa<UndefValue>(C) && rangeOnlyContains(V.begin(), V.end(), C))
     981           3 :     return UndefValue::get(Ty);
     982             : 
     983       28391 :   if (C->isNullValue() && rangeOnlyContains(V.begin(), V.end(), C))
     984         531 :     return ConstantAggregateZero::get(Ty);
     985             : 
     986             :   // Check to see if all of the elements are ConstantFP or ConstantInt and if
     987             :   // the element type is compatible with ConstantDataVector.  If so, use it.
     988       23679 :   if (ConstantDataSequential::isElementTypeCompatible(C->getType()))
     989        6105 :     return getSequenceIfElementsMatch<ConstantDataArray>(C, V);
     990             : 
     991             :   // Otherwise, we really do want to create a ConstantArray.
     992             :   return nullptr;
     993             : }
     994             : 
     995       12606 : StructType *ConstantStruct::getTypeForElements(LLVMContext &Context,
     996             :                                                ArrayRef<Constant*> V,
     997             :                                                bool Packed) {
     998       12606 :   unsigned VecSize = V.size();
     999       25212 :   SmallVector<Type*, 16> EltTypes(VecSize);
    1000       79564 :   for (unsigned i = 0; i != VecSize; ++i)
    1001      100437 :     EltTypes[i] = V[i]->getType();
    1002             : 
    1003       37818 :   return StructType::get(Context, EltTypes, Packed);
    1004             : }
    1005             : 
    1006             : 
    1007        9395 : StructType *ConstantStruct::getTypeForElements(ArrayRef<Constant*> V,
    1008             :                                                bool Packed) {
    1009             :   assert(!V.empty() &&
    1010             :          "ConstantStruct::getTypeForElements cannot be called on empty list");
    1011        9395 :   return getTypeForElements(V[0]->getContext(), V, Packed);
    1012             : }
    1013             : 
    1014       82818 : ConstantStruct::ConstantStruct(StructType *T, ArrayRef<Constant *> V)
    1015       82818 :     : ConstantAggregate(T, ConstantStructVal, V) {
    1016             :   assert((T->isOpaque() || V.size() == T->getNumElements()) &&
    1017             :          "Invalid initializer for constant struct");
    1018       82818 : }
    1019             : 
    1020             : // ConstantStruct accessors.
    1021       86150 : Constant *ConstantStruct::get(StructType *ST, ArrayRef<Constant*> V) {
    1022             :   assert((ST->isOpaque() || ST->getNumElements() == V.size()) &&
    1023             :          "Incorrect # elements specified to ConstantStruct::get");
    1024             : 
    1025             :   // Create a ConstantAggregateZero value if all elements are zeros.
    1026             :   bool isZero = true;
    1027             :   bool isUndef = false;
    1028             : 
    1029       86150 :   if (!V.empty()) {
    1030       86118 :     isUndef = isa<UndefValue>(V[0]);
    1031       86118 :     isZero = V[0]->isNullValue();
    1032       86118 :     if (isUndef || isZero) {
    1033       47674 :       for (unsigned i = 0, e = V.size(); i != e; ++i) {
    1034       76574 :         if (!V[i]->isNullValue())
    1035             :           isZero = false;
    1036       76574 :         if (!isa<UndefValue>(V[i]))
    1037             :           isUndef = false;
    1038             :       }
    1039             :     }
    1040             :   }
    1041       86118 :   if (isZero)
    1042        2008 :     return ConstantAggregateZero::get(ST);
    1043       84142 :   if (isUndef)
    1044          60 :     return UndefValue::get(ST);
    1045             : 
    1046      168164 :   return ST->getContext().pImpl->StructConstants.getOrCreate(ST, V);
    1047             : }
    1048             : 
    1049       13950 : ConstantVector::ConstantVector(VectorType *T, ArrayRef<Constant *> V)
    1050       13950 :     : ConstantAggregate(T, ConstantVectorVal, V) {
    1051             :   assert(V.size() == T->getNumElements() &&
    1052             :          "Invalid initializer for constant vector");
    1053       13950 : }
    1054             : 
    1055             : // ConstantVector accessors.
    1056      273655 : Constant *ConstantVector::get(ArrayRef<Constant*> V) {
    1057      273655 :   if (Constant *C = getImpl(V))
    1058             :     return C;
    1059      106602 :   VectorType *Ty = VectorType::get(V.front()->getType(), V.size());
    1060      213204 :   return Ty->getContext().pImpl->VectorConstants.getOrCreate(Ty, V);
    1061             : }
    1062             : 
    1063      273655 : Constant *ConstantVector::getImpl(ArrayRef<Constant*> V) {
    1064             :   assert(!V.empty() && "Vectors can't be empty");
    1065      273655 :   VectorType *T = VectorType::get(V.front()->getType(), V.size());
    1066             : 
    1067             :   // If this is an all-undef or all-zero vector, return a
    1068             :   // ConstantAggregateZero or UndefValue.
    1069      273655 :   Constant *C = V[0];
    1070      273655 :   bool isZero = C->isNullValue();
    1071             :   bool isUndef = isa<UndefValue>(C);
    1072             : 
    1073      273655 :   if (isZero || isUndef) {
    1074      153468 :     for (unsigned i = 1, e = V.size(); i != e; ++i)
    1075      187654 :       if (V[i] != C) {
    1076             :         isZero = isUndef = false;
    1077             :         break;
    1078             :       }
    1079             :   }
    1080             : 
    1081      273655 :   if (isZero)
    1082        5578 :     return ConstantAggregateZero::get(T);
    1083      268077 :   if (isUndef)
    1084         292 :     return UndefValue::get(T);
    1085             : 
    1086             :   // Check to see if all of the elements are ConstantFP or ConstantInt and if
    1087             :   // the element type is compatible with ConstantDataVector.  If so, use it.
    1088      267785 :   if (ConstantDataSequential::isElementTypeCompatible(C->getType()))
    1089      264869 :     return getSequenceIfElementsMatch<ConstantDataVector>(C, V);
    1090             : 
    1091             :   // Otherwise, the element type isn't compatible with ConstantDataVector, or
    1092             :   // the operand list contains a ConstantExpr or something else strange.
    1093             :   return nullptr;
    1094             : }
    1095             : 
    1096       12247 : Constant *ConstantVector::getSplat(unsigned NumElts, Constant *V) {
    1097             :   // If this splat is compatible with ConstantDataVector, use it instead of
    1098             :   // ConstantVector.
    1099       36739 :   if ((isa<ConstantFP>(V) || isa<ConstantInt>(V)) &&
    1100       12245 :       ConstantDataSequential::isElementTypeCompatible(V->getType()))
    1101       11613 :     return ConstantDataVector::getSplat(NumElts, V);
    1102             : 
    1103         634 :   SmallVector<Constant*, 32> Elts(NumElts, V);
    1104         634 :   return get(Elts);
    1105             : }
    1106             : 
    1107        2547 : ConstantTokenNone *ConstantTokenNone::get(LLVMContext &Context) {
    1108        2547 :   LLVMContextImpl *pImpl = Context.pImpl;
    1109        2547 :   if (!pImpl->TheNoneToken)
    1110         287 :     pImpl->TheNoneToken.reset(new ConstantTokenNone(Context));
    1111        2547 :   return pImpl->TheNoneToken.get();
    1112             : }
    1113             : 
    1114             : /// Remove the constant from the constant table.
    1115           0 : void ConstantTokenNone::destroyConstantImpl() {
    1116           0 :   llvm_unreachable("You can't ConstantTokenNone->destroyConstantImpl()!");
    1117             : }
    1118             : 
    1119             : // Utility function for determining if a ConstantExpr is a CastOp or not. This
    1120             : // can't be inline because we don't want to #include Instruction.h into
    1121             : // Constant.h
    1122     1333966 : bool ConstantExpr::isCast() const {
    1123     1333966 :   return Instruction::isCast(getOpcode());
    1124             : }
    1125             : 
    1126    28442836 : bool ConstantExpr::isCompare() const {
    1127    28442836 :   return getOpcode() == Instruction::ICmp || getOpcode() == Instruction::FCmp;
    1128             : }
    1129             : 
    1130         221 : bool ConstantExpr::isGEPWithNoNotionalOverIndexing() const {
    1131         221 :   if (getOpcode() != Instruction::GetElementPtr) return false;
    1132             : 
    1133         219 :   gep_type_iterator GEPI = gep_type_begin(this), E = gep_type_end(this);
    1134             :   User::const_op_iterator OI = std::next(this->op_begin());
    1135             : 
    1136             :   // The remaining indices may be compile-time known integers within the bounds
    1137             :   // of the corresponding notional static array types.
    1138        2305 :   for (; GEPI != E; ++GEPI, ++OI) {
    1139        1043 :     if (isa<UndefValue>(*OI))
    1140           1 :       continue;
    1141             :     auto *CI = dyn_cast<ConstantInt>(*OI);
    1142         157 :     if (!CI || (GEPI.isBoundedSequential() &&
    1143         157 :                 (CI->getValue().getActiveBits() > 64 ||
    1144             :                  CI->getZExtValue() >= GEPI.getSequentialNumElements())))
    1145             :       return false;
    1146             :   }
    1147             : 
    1148             :   // All the indices checked out.
    1149             :   return true;
    1150             : }
    1151             : 
    1152    12915500 : bool ConstantExpr::hasIndices() const {
    1153    12915500 :   return getOpcode() == Instruction::ExtractValue ||
    1154    12915500 :          getOpcode() == Instruction::InsertValue;
    1155             : }
    1156             : 
    1157           7 : ArrayRef<unsigned> ConstantExpr::getIndices() const {
    1158             :   if (const ExtractValueConstantExpr *EVCE =
    1159             :         dyn_cast<ExtractValueConstantExpr>(this))
    1160           6 :     return EVCE->Indices;
    1161             : 
    1162           1 :   return cast<InsertValueConstantExpr>(this)->Indices;
    1163             : }
    1164             : 
    1165        5977 : unsigned ConstantExpr::getPredicate() const {
    1166        5977 :   return cast<CompareConstantExpr>(this)->predicate;
    1167             : }
    1168             : 
    1169             : Constant *
    1170           0 : ConstantExpr::getWithOperandReplaced(unsigned OpNo, Constant *Op) const {
    1171             :   assert(Op->getType() == getOperand(OpNo)->getType() &&
    1172             :          "Replacing operand with value of different type!");
    1173           0 :   if (getOperand(OpNo) == Op)
    1174           0 :     return const_cast<ConstantExpr*>(this);
    1175             : 
    1176             :   SmallVector<Constant*, 8> NewOps;
    1177           0 :   for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
    1178           0 :     NewOps.push_back(i == OpNo ? Op : getOperand(i));
    1179             : 
    1180             :   return getWithOperands(NewOps);
    1181             : }
    1182             : 
    1183        3016 : Constant *ConstantExpr::getWithOperands(ArrayRef<Constant *> Ops, Type *Ty,
    1184             :                                         bool OnlyIfReduced, Type *SrcTy) const {
    1185             :   assert(Ops.size() == getNumOperands() && "Operand count mismatch!");
    1186             : 
    1187             :   // If no operands changed return self.
    1188        6015 :   if (Ty == getType() && std::equal(Ops.begin(), Ops.end(), op_begin()))
    1189         299 :     return const_cast<ConstantExpr*>(this);
    1190             : 
    1191        2717 :   Type *OnlyIfReducedTy = OnlyIfReduced ? Ty : nullptr;
    1192        2717 :   switch (getOpcode()) {
    1193        2304 :   case Instruction::Trunc:
    1194             :   case Instruction::ZExt:
    1195             :   case Instruction::SExt:
    1196             :   case Instruction::FPTrunc:
    1197             :   case Instruction::FPExt:
    1198             :   case Instruction::UIToFP:
    1199             :   case Instruction::SIToFP:
    1200             :   case Instruction::FPToUI:
    1201             :   case Instruction::FPToSI:
    1202             :   case Instruction::PtrToInt:
    1203             :   case Instruction::IntToPtr:
    1204             :   case Instruction::BitCast:
    1205             :   case Instruction::AddrSpaceCast:
    1206        2304 :     return ConstantExpr::getCast(getOpcode(), Ops[0], Ty, OnlyIfReduced);
    1207           2 :   case Instruction::Select:
    1208           2 :     return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2], OnlyIfReducedTy);
    1209           0 :   case Instruction::InsertElement:
    1210           0 :     return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2],
    1211           0 :                                           OnlyIfReducedTy);
    1212          33 :   case Instruction::ExtractElement:
    1213          33 :     return ConstantExpr::getExtractElement(Ops[0], Ops[1], OnlyIfReducedTy);
    1214           0 :   case Instruction::InsertValue:
    1215           0 :     return ConstantExpr::getInsertValue(Ops[0], Ops[1], getIndices(),
    1216           0 :                                         OnlyIfReducedTy);
    1217           2 :   case Instruction::ExtractValue:
    1218           2 :     return ConstantExpr::getExtractValue(Ops[0], getIndices(), OnlyIfReducedTy);
    1219           0 :   case Instruction::ShuffleVector:
    1220           0 :     return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2],
    1221           0 :                                           OnlyIfReducedTy);
    1222             :   case Instruction::GetElementPtr: {
    1223             :     auto *GEPO = cast<GEPOperator>(this);
    1224             :     assert(SrcTy || (Ops[0]->getType() == getOperand(0)->getType()));
    1225         570 :     return ConstantExpr::getGetElementPtr(
    1226             :         SrcTy ? SrcTy : GEPO->getSourceElementType(), Ops[0], Ops.slice(1),
    1227             :         GEPO->isInBounds(), GEPO->getInRangeIndex(), OnlyIfReducedTy);
    1228             :   }
    1229           8 :   case Instruction::ICmp:
    1230             :   case Instruction::FCmp:
    1231           8 :     return ConstantExpr::getCompare(getPredicate(), Ops[0], Ops[1],
    1232           8 :                                     OnlyIfReducedTy);
    1233          83 :   default:
    1234             :     assert(getNumOperands() == 2 && "Must be binary operator?");
    1235          83 :     return ConstantExpr::get(getOpcode(), Ops[0], Ops[1], SubclassOptionalData,
    1236          83 :                              OnlyIfReducedTy);
    1237             :   }
    1238             : }
    1239             : 
    1240             : 
    1241             : //===----------------------------------------------------------------------===//
    1242             : //                      isValueValidForType implementations
    1243             : 
    1244          57 : bool ConstantInt::isValueValidForType(Type *Ty, uint64_t Val) {
    1245             :   unsigned NumBits = Ty->getIntegerBitWidth(); // assert okay
    1246          57 :   if (Ty->isIntegerTy(1))
    1247           0 :     return Val == 0 || Val == 1;
    1248             :   return isUIntN(NumBits, Val);
    1249             : }
    1250             : 
    1251       26806 : bool ConstantInt::isValueValidForType(Type *Ty, int64_t Val) {
    1252             :   unsigned NumBits = Ty->getIntegerBitWidth();
    1253       26806 :   if (Ty->isIntegerTy(1))
    1254           0 :     return Val == 0 || Val == 1 || Val == -1;
    1255             :   return isIntN(NumBits, Val);
    1256             : }
    1257             : 
    1258       55074 : bool ConstantFP::isValueValidForType(Type *Ty, const APFloat& Val) {
    1259             :   // convert modifies in place, so make a copy.
    1260             :   APFloat Val2 = APFloat(Val);
    1261             :   bool losesInfo;
    1262       55074 :   switch (Ty->getTypeID()) {
    1263             :   default:
    1264             :     return false;         // These can't be represented as floating point!
    1265             : 
    1266             :   // FIXME rounding mode needs to be more flexible
    1267        3156 :   case Type::HalfTyID: {
    1268        3156 :     if (&Val2.getSemantics() == &APFloat::IEEEhalf())
    1269             :       return true;
    1270        2036 :     Val2.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &losesInfo);
    1271        2036 :     return !losesInfo;
    1272             :   }
    1273       36560 :   case Type::FloatTyID: {
    1274       36560 :     if (&Val2.getSemantics() == &APFloat::IEEEsingle())
    1275             :       return true;
    1276       36560 :     Val2.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
    1277       36560 :     return !losesInfo;
    1278             :   }
    1279       14958 :   case Type::DoubleTyID: {
    1280       29916 :     if (&Val2.getSemantics() == &APFloat::IEEEhalf() ||
    1281       29916 :         &Val2.getSemantics() == &APFloat::IEEEsingle() ||
    1282       14958 :         &Val2.getSemantics() == &APFloat::IEEEdouble())
    1283             :       return true;
    1284           0 :     Val2.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
    1285           0 :     return !losesInfo;
    1286             :   }
    1287         143 :   case Type::X86_FP80TyID:
    1288         286 :     return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
    1289         286 :            &Val2.getSemantics() == &APFloat::IEEEsingle() ||
    1290         429 :            &Val2.getSemantics() == &APFloat::IEEEdouble() ||
    1291         143 :            &Val2.getSemantics() == &APFloat::x87DoubleExtended();
    1292         189 :   case Type::FP128TyID:
    1293         378 :     return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
    1294         378 :            &Val2.getSemantics() == &APFloat::IEEEsingle() ||
    1295         567 :            &Val2.getSemantics() == &APFloat::IEEEdouble() ||
    1296         189 :            &Val2.getSemantics() == &APFloat::IEEEquad();
    1297          68 :   case Type::PPC_FP128TyID:
    1298         136 :     return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
    1299         136 :            &Val2.getSemantics() == &APFloat::IEEEsingle() ||
    1300         204 :            &Val2.getSemantics() == &APFloat::IEEEdouble() ||
    1301          68 :            &Val2.getSemantics() == &APFloat::PPCDoubleDouble();
    1302             :   }
    1303             : }
    1304             : 
    1305             : 
    1306             : //===----------------------------------------------------------------------===//
    1307             : //                      Factory Function Implementation
    1308             : 
    1309      104057 : ConstantAggregateZero *ConstantAggregateZero::get(Type *Ty) {
    1310             :   assert((Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()) &&
    1311             :          "Cannot create an aggregate zero of non-aggregate type!");
    1312             : 
    1313             :   std::unique_ptr<ConstantAggregateZero> &Entry =
    1314      104057 :       Ty->getContext().pImpl->CAZConstants[Ty];
    1315      104057 :   if (!Entry)
    1316       19170 :     Entry.reset(new ConstantAggregateZero(Ty));
    1317             : 
    1318      104057 :   return Entry.get();
    1319             : }
    1320             : 
    1321             : /// Remove the constant from the constant table.
    1322           0 : void ConstantAggregateZero::destroyConstantImpl() {
    1323           0 :   getContext().pImpl->CAZConstants.erase(getType());
    1324           0 : }
    1325             : 
    1326             : /// Remove the constant from the constant table.
    1327       10772 : void ConstantArray::destroyConstantImpl() {
    1328       10772 :   getType()->getContext().pImpl->ArrayConstants.remove(this);
    1329       10772 : }
    1330             : 
    1331             : 
    1332             : //---- ConstantStruct::get() implementation...
    1333             : //
    1334             : 
    1335             : /// Remove the constant from the constant table.
    1336       30947 : void ConstantStruct::destroyConstantImpl() {
    1337       30947 :   getType()->getContext().pImpl->StructConstants.remove(this);
    1338       30947 : }
    1339             : 
    1340             : /// Remove the constant from the constant table.
    1341          73 : void ConstantVector::destroyConstantImpl() {
    1342          73 :   getType()->getContext().pImpl->VectorConstants.remove(this);
    1343          73 : }
    1344             : 
    1345     1512075 : Constant *Constant::getSplatValue() const {
    1346             :   assert(this->getType()->isVectorTy() && "Only valid for vectors!");
    1347     1512075 :   if (isa<ConstantAggregateZero>(this))
    1348       33428 :     return getNullValue(this->getType()->getVectorElementType());
    1349             :   if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this))
    1350     1480547 :     return CV->getSplatValue();
    1351             :   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
    1352        8805 :     return CV->getSplatValue();
    1353             :   return nullptr;
    1354             : }
    1355             : 
    1356        9426 : Constant *ConstantVector::getSplatValue() const {
    1357             :   // Check out first element.
    1358        9426 :   Constant *Elt = getOperand(0);
    1359             :   // Then make sure all remaining elements point to the same value.
    1360       36282 :   for (unsigned I = 1, E = getNumOperands(); I < E; ++I)
    1361       18394 :     if (getOperand(I) != Elt)
    1362             :       return nullptr;
    1363             :   return Elt;
    1364             : }
    1365             : 
    1366     7237239 : const APInt &Constant::getUniqueInteger() const {
    1367             :   if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
    1368     7236878 :     return CI->getValue();
    1369             :   assert(this->getSplatValue() && "Doesn't contain a unique integer!");
    1370         361 :   const Constant *C = this->getAggregateElement(0U);
    1371             :   assert(C && isa<ConstantInt>(C) && "Not a vector of numbers!");
    1372         361 :   return cast<ConstantInt>(C)->getValue();
    1373             : }
    1374             : 
    1375             : //---- ConstantPointerNull::get() implementation.
    1376             : //
    1377             : 
    1378      342243 : ConstantPointerNull *ConstantPointerNull::get(PointerType *Ty) {
    1379             :   std::unique_ptr<ConstantPointerNull> &Entry =
    1380      342243 :       Ty->getContext().pImpl->CPNConstants[Ty];
    1381      342243 :   if (!Entry)
    1382       18743 :     Entry.reset(new ConstantPointerNull(Ty));
    1383             : 
    1384      342243 :   return Entry.get();
    1385             : }
    1386             : 
    1387             : /// Remove the constant from the constant table.
    1388           0 : void ConstantPointerNull::destroyConstantImpl() {
    1389           0 :   getContext().pImpl->CPNConstants.erase(getType());
    1390           0 : }
    1391             : 
    1392     1547598 : UndefValue *UndefValue::get(Type *Ty) {
    1393     1547598 :   std::unique_ptr<UndefValue> &Entry = Ty->getContext().pImpl->UVConstants[Ty];
    1394     1547598 :   if (!Entry)
    1395       65449 :     Entry.reset(new UndefValue(Ty));
    1396             : 
    1397     1547598 :   return Entry.get();
    1398             : }
    1399             : 
    1400             : /// Remove the constant from the constant table.
    1401           0 : void UndefValue::destroyConstantImpl() {
    1402             :   // Free the constant and any dangling references to it.
    1403           0 :   getContext().pImpl->UVConstants.erase(getType());
    1404           0 : }
    1405             : 
    1406         268 : BlockAddress *BlockAddress::get(BasicBlock *BB) {
    1407             :   assert(BB->getParent() && "Block must have a parent");
    1408         268 :   return get(BB->getParent(), BB);
    1409             : }
    1410             : 
    1411         998 : BlockAddress *BlockAddress::get(Function *F, BasicBlock *BB) {
    1412             :   BlockAddress *&BA =
    1413        1996 :     F->getContext().pImpl->BlockAddresses[std::make_pair(F, BB)];
    1414         998 :   if (!BA)
    1415         841 :     BA = new BlockAddress(F, BB);
    1416             : 
    1417             :   assert(BA->getFunction() == F && "Basic block moved between functions");
    1418         998 :   return BA;
    1419             : }
    1420             : 
    1421         841 : BlockAddress::BlockAddress(Function *F, BasicBlock *BB)
    1422         841 : : Constant(Type::getInt8PtrTy(F->getContext()), Value::BlockAddressVal,
    1423             :            &Op<0>(), 2) {
    1424             :   setOperand(0, F);
    1425             :   setOperand(1, BB);
    1426             :   BB->AdjustBlockAddressRefCount(1);
    1427         841 : }
    1428             : 
    1429          62 : BlockAddress *BlockAddress::lookup(const BasicBlock *BB) {
    1430          62 :   if (!BB->hasAddressTaken())
    1431             :     return nullptr;
    1432             : 
    1433           2 :   const Function *F = BB->getParent();
    1434             :   assert(F && "Block must have a parent");
    1435             :   BlockAddress *BA =
    1436           4 :       F->getContext().pImpl->BlockAddresses.lookup(std::make_pair(F, BB));
    1437             :   assert(BA && "Refcount and block address map disagree!");
    1438           2 :   return BA;
    1439             : }
    1440             : 
    1441             : /// Remove the constant from the constant table.
    1442         840 : void BlockAddress::destroyConstantImpl() {
    1443         840 :   getFunction()->getType()->getContext().pImpl
    1444        1680 :     ->BlockAddresses.erase(std::make_pair(getFunction(), getBasicBlock()));
    1445             :   getBasicBlock()->AdjustBlockAddressRefCount(-1);
    1446         840 : }
    1447             : 
    1448          20 : Value *BlockAddress::handleOperandChangeImpl(Value *From, Value *To) {
    1449             :   // This could be replacing either the Basic Block or the Function.  In either
    1450             :   // case, we have to remove the map entry.
    1451             :   Function *NewF = getFunction();
    1452             :   BasicBlock *NewBB = getBasicBlock();
    1453             : 
    1454          20 :   if (From == NewF)
    1455             :     NewF = cast<Function>(To->stripPointerCasts());
    1456             :   else {
    1457             :     assert(From == NewBB && "From does not match any operand");
    1458             :     NewBB = cast<BasicBlock>(To);
    1459             :   }
    1460             : 
    1461             :   // See if the 'new' entry already exists, if not, just update this in place
    1462             :   // and return early.
    1463             :   BlockAddress *&NewBA =
    1464          40 :     getContext().pImpl->BlockAddresses[std::make_pair(NewF, NewBB)];
    1465          20 :   if (NewBA)
    1466             :     return NewBA;
    1467             : 
    1468             :   getBasicBlock()->AdjustBlockAddressRefCount(-1);
    1469             : 
    1470             :   // Remove the old entry, this can't cause the map to rehash (just a
    1471             :   // tombstone will get added).
    1472          18 :   getContext().pImpl->BlockAddresses.erase(std::make_pair(getFunction(),
    1473             :                                                           getBasicBlock()));
    1474           9 :   NewBA = this;
    1475             :   setOperand(0, NewF);
    1476             :   setOperand(1, NewBB);
    1477             :   getBasicBlock()->AdjustBlockAddressRefCount(1);
    1478             : 
    1479             :   // If we just want to keep the existing value, then return null.
    1480             :   // Callers know that this means we shouldn't delete this value.
    1481           9 :   return nullptr;
    1482             : }
    1483             : 
    1484             : //---- ConstantExpr::get() implementations.
    1485             : //
    1486             : 
    1487             : /// This is a utility function to handle folding of casts and lookup of the
    1488             : /// cast in the ExprConstants map. It is used by the various get* methods below.
    1489     3102602 : static Constant *getFoldedCast(Instruction::CastOps opc, Constant *C, Type *Ty,
    1490             :                                bool OnlyIfReduced = false) {
    1491             :   assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
    1492             :   // Fold a few common cases
    1493     3102602 :   if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty))
    1494             :     return FC;
    1495             : 
    1496     1634283 :   if (OnlyIfReduced)
    1497             :     return nullptr;
    1498             : 
    1499     1633261 :   LLVMContextImpl *pImpl = Ty->getContext().pImpl;
    1500             : 
    1501             :   // Look up the constant in the table first to ensure uniqueness.
    1502             :   ConstantExprKeyType Key(opc, C);
    1503             : 
    1504     1633261 :   return pImpl->ExprConstants.getOrCreate(Ty, Key);
    1505             : }
    1506             : 
    1507     1220096 : Constant *ConstantExpr::getCast(unsigned oc, Constant *C, Type *Ty,
    1508             :                                 bool OnlyIfReduced) {
    1509             :   Instruction::CastOps opc = Instruction::CastOps(oc);
    1510             :   assert(Instruction::isCast(opc) && "opcode out of range");
    1511             :   assert(C && Ty && "Null arguments to getCast");
    1512             :   assert(CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!");
    1513             : 
    1514     1220096 :   switch (opc) {
    1515           0 :   default:
    1516           0 :     llvm_unreachable("Invalid cast opcode");
    1517      398041 :   case Instruction::Trunc:
    1518      398041 :     return getTrunc(C, Ty, OnlyIfReduced);
    1519       24056 :   case Instruction::ZExt:
    1520       24056 :     return getZExt(C, Ty, OnlyIfReduced);
    1521       70631 :   case Instruction::SExt:
    1522       70631 :     return getSExt(C, Ty, OnlyIfReduced);
    1523        1048 :   case Instruction::FPTrunc:
    1524        1048 :     return getFPTrunc(C, Ty, OnlyIfReduced);
    1525         308 :   case Instruction::FPExt:
    1526         308 :     return getFPExtend(C, Ty, OnlyIfReduced);
    1527          56 :   case Instruction::UIToFP:
    1528          56 :     return getUIToFP(C, Ty, OnlyIfReduced);
    1529        3200 :   case Instruction::SIToFP:
    1530        3200 :     return getSIToFP(C, Ty, OnlyIfReduced);
    1531          12 :   case Instruction::FPToUI:
    1532          12 :     return getFPToUI(C, Ty, OnlyIfReduced);
    1533          51 :   case Instruction::FPToSI:
    1534          51 :     return getFPToSI(C, Ty, OnlyIfReduced);
    1535        9212 :   case Instruction::PtrToInt:
    1536        9212 :     return getPtrToInt(C, Ty, OnlyIfReduced);
    1537        6827 :   case Instruction::IntToPtr:
    1538        6827 :     return getIntToPtr(C, Ty, OnlyIfReduced);
    1539      705914 :   case Instruction::BitCast:
    1540      705914 :     return getBitCast(C, Ty, OnlyIfReduced);
    1541         740 :   case Instruction::AddrSpaceCast:
    1542         740 :     return getAddrSpaceCast(C, Ty, OnlyIfReduced);
    1543             :   }
    1544             : }
    1545             : 
    1546          94 : Constant *ConstantExpr::getZExtOrBitCast(Constant *C, Type *Ty) {
    1547          94 :   if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
    1548           0 :     return getBitCast(C, Ty);
    1549          94 :   return getZExt(C, Ty);
    1550             : }
    1551             : 
    1552        4684 : Constant *ConstantExpr::getSExtOrBitCast(Constant *C, Type *Ty) {
    1553        4684 :   if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
    1554        4606 :     return getBitCast(C, Ty);
    1555          78 :   return getSExt(C, Ty);
    1556             : }
    1557             : 
    1558          62 : Constant *ConstantExpr::getTruncOrBitCast(Constant *C, Type *Ty) {
    1559          62 :   if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
    1560           4 :     return getBitCast(C, Ty);
    1561          58 :   return getTrunc(C, Ty);
    1562             : }
    1563             : 
    1564      173548 : Constant *ConstantExpr::getPointerCast(Constant *S, Type *Ty) {
    1565             :   assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
    1566             :   assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) &&
    1567             :           "Invalid cast");
    1568             : 
    1569      173548 :   if (Ty->isIntOrIntVectorTy())
    1570        2444 :     return getPtrToInt(S, Ty);
    1571             : 
    1572      171104 :   unsigned SrcAS = S->getType()->getPointerAddressSpace();
    1573      342208 :   if (Ty->isPtrOrPtrVectorTy() && SrcAS != Ty->getPointerAddressSpace())
    1574         342 :     return getAddrSpaceCast(S, Ty);
    1575             : 
    1576      170762 :   return getBitCast(S, Ty);
    1577             : }
    1578             : 
    1579       11942 : Constant *ConstantExpr::getPointerBitCastOrAddrSpaceCast(Constant *S,
    1580             :                                                          Type *Ty) {
    1581             :   assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
    1582             :   assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast");
    1583             : 
    1584       23884 :   if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace())
    1585          29 :     return getAddrSpaceCast(S, Ty);
    1586             : 
    1587       11913 :   return getBitCast(S, Ty);
    1588             : }
    1589             : 
    1590       73336 : Constant *ConstantExpr::getIntegerCast(Constant *C, Type *Ty, bool isSigned) {
    1591             :   assert(C->getType()->isIntOrIntVectorTy() &&
    1592             :          Ty->isIntOrIntVectorTy() && "Invalid cast");
    1593       73336 :   unsigned SrcBits = C->getType()->getScalarSizeInBits();
    1594       73336 :   unsigned DstBits = Ty->getScalarSizeInBits();
    1595             :   Instruction::CastOps opcode =
    1596       73336 :     (SrcBits == DstBits ? Instruction::BitCast :
    1597       73043 :      (SrcBits > DstBits ? Instruction::Trunc :
    1598       54473 :       (isSigned ? Instruction::SExt : Instruction::ZExt)));
    1599       73336 :   return getCast(opcode, C, Ty);
    1600             : }
    1601             : 
    1602           0 : Constant *ConstantExpr::getFPCast(Constant *C, Type *Ty) {
    1603             :   assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
    1604             :          "Invalid cast");
    1605           0 :   unsigned SrcBits = C->getType()->getScalarSizeInBits();
    1606           0 :   unsigned DstBits = Ty->getScalarSizeInBits();
    1607           0 :   if (SrcBits == DstBits)
    1608             :     return C; // Avoid a useless cast
    1609             :   Instruction::CastOps opcode =
    1610           0 :     (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt);
    1611           0 :   return getCast(opcode, C, Ty);
    1612             : }
    1613             : 
    1614      427045 : Constant *ConstantExpr::getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced) {
    1615             : #ifndef NDEBUG
    1616             :   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
    1617             :   bool toVec = Ty->getTypeID() == Type::VectorTyID;
    1618             : #endif
    1619             :   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
    1620             :   assert(C->getType()->isIntOrIntVectorTy() && "Trunc operand must be integer");
    1621             :   assert(Ty->isIntOrIntVectorTy() && "Trunc produces only integral");
    1622             :   assert(C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
    1623             :          "SrcTy must be larger than DestTy for Trunc!");
    1624             : 
    1625      427045 :   return getFoldedCast(Instruction::Trunc, C, Ty, OnlyIfReduced);
    1626             : }
    1627             : 
    1628      166797 : Constant *ConstantExpr::getSExt(Constant *C, Type *Ty, bool OnlyIfReduced) {
    1629             : #ifndef NDEBUG
    1630             :   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
    1631             :   bool toVec = Ty->getTypeID() == Type::VectorTyID;
    1632             : #endif
    1633             :   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
    1634             :   assert(C->getType()->isIntOrIntVectorTy() && "SExt operand must be integral");
    1635             :   assert(Ty->isIntOrIntVectorTy() && "SExt produces only integer");
    1636             :   assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
    1637             :          "SrcTy must be smaller than DestTy for SExt!");
    1638             : 
    1639      166797 :   return getFoldedCast(Instruction::SExt, C, Ty, OnlyIfReduced);
    1640             : }
    1641             : 
    1642      148390 : Constant *ConstantExpr::getZExt(Constant *C, Type *Ty, bool OnlyIfReduced) {
    1643             : #ifndef NDEBUG
    1644             :   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
    1645             :   bool toVec = Ty->getTypeID() == Type::VectorTyID;
    1646             : #endif
    1647             :   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
    1648             :   assert(C->getType()->isIntOrIntVectorTy() && "ZEXt operand must be integral");
    1649             :   assert(Ty->isIntOrIntVectorTy() && "ZExt produces only integer");
    1650             :   assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
    1651             :          "SrcTy must be smaller than DestTy for ZExt!");
    1652             : 
    1653      148390 :   return getFoldedCast(Instruction::ZExt, C, Ty, OnlyIfReduced);
    1654             : }
    1655             : 
    1656        1588 : Constant *ConstantExpr::getFPTrunc(Constant *C, Type *Ty, bool OnlyIfReduced) {
    1657             : #ifndef NDEBUG
    1658             :   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
    1659             :   bool toVec = Ty->getTypeID() == Type::VectorTyID;
    1660             : #endif
    1661             :   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
    1662             :   assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
    1663             :          C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
    1664             :          "This is an illegal floating point truncation!");
    1665        1588 :   return getFoldedCast(Instruction::FPTrunc, C, Ty, OnlyIfReduced);
    1666             : }
    1667             : 
    1668         435 : Constant *ConstantExpr::getFPExtend(Constant *C, Type *Ty, bool OnlyIfReduced) {
    1669             : #ifndef NDEBUG
    1670             :   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
    1671             :   bool toVec = Ty->getTypeID() == Type::VectorTyID;
    1672             : #endif
    1673             :   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
    1674             :   assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
    1675             :          C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
    1676             :          "This is an illegal floating point extension!");
    1677         435 :   return getFoldedCast(Instruction::FPExt, C, Ty, OnlyIfReduced);
    1678             : }
    1679             : 
    1680          65 : Constant *ConstantExpr::getUIToFP(Constant *C, Type *Ty, bool OnlyIfReduced) {
    1681             : #ifndef NDEBUG
    1682             :   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
    1683             :   bool toVec = Ty->getTypeID() == Type::VectorTyID;
    1684             : #endif
    1685             :   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
    1686             :   assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
    1687             :          "This is an illegal uint to floating point cast!");
    1688          65 :   return getFoldedCast(Instruction::UIToFP, C, Ty, OnlyIfReduced);
    1689             : }
    1690             : 
    1691        3212 : Constant *ConstantExpr::getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced) {
    1692             : #ifndef NDEBUG
    1693             :   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
    1694             :   bool toVec = Ty->getTypeID() == Type::VectorTyID;
    1695             : #endif
    1696             :   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
    1697             :   assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
    1698             :          "This is an illegal sint to floating point cast!");
    1699        3212 :   return getFoldedCast(Instruction::SIToFP, C, Ty, OnlyIfReduced);
    1700             : }
    1701             : 
    1702          34 : Constant *ConstantExpr::getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced) {
    1703             : #ifndef NDEBUG
    1704             :   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
    1705             :   bool toVec = Ty->getTypeID() == Type::VectorTyID;
    1706             : #endif
    1707             :   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
    1708             :   assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
    1709             :          "This is an illegal floating point to uint cast!");
    1710          34 :   return getFoldedCast(Instruction::FPToUI, C, Ty, OnlyIfReduced);
    1711             : }
    1712             : 
    1713          78 : Constant *ConstantExpr::getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced) {
    1714             : #ifndef NDEBUG
    1715             :   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
    1716             :   bool toVec = Ty->getTypeID() == Type::VectorTyID;
    1717             : #endif
    1718             :   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
    1719             :   assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
    1720             :          "This is an illegal floating point to sint cast!");
    1721          78 :   return getFoldedCast(Instruction::FPToSI, C, Ty, OnlyIfReduced);
    1722             : }
    1723             : 
    1724       14494 : Constant *ConstantExpr::getPtrToInt(Constant *C, Type *DstTy,
    1725             :                                     bool OnlyIfReduced) {
    1726             :   assert(C->getType()->isPtrOrPtrVectorTy() &&
    1727             :          "PtrToInt source must be pointer or pointer vector");
    1728             :   assert(DstTy->isIntOrIntVectorTy() &&
    1729             :          "PtrToInt destination must be integer or integer vector");
    1730             :   assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy));
    1731             :   if (isa<VectorType>(C->getType()))
    1732             :     assert(C->getType()->getVectorNumElements()==DstTy->getVectorNumElements()&&
    1733             :            "Invalid cast between a different number of vector elements");
    1734       14494 :   return getFoldedCast(Instruction::PtrToInt, C, DstTy, OnlyIfReduced);
    1735             : }
    1736             : 
    1737       14345 : Constant *ConstantExpr::getIntToPtr(Constant *C, Type *DstTy,
    1738             :                                     bool OnlyIfReduced) {
    1739             :   assert(C->getType()->isIntOrIntVectorTy() &&
    1740             :          "IntToPtr source must be integer or integer vector");
    1741             :   assert(DstTy->isPtrOrPtrVectorTy() &&
    1742             :          "IntToPtr destination must be a pointer or pointer vector");
    1743             :   assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy));
    1744             :   if (isa<VectorType>(C->getType()))
    1745             :     assert(C->getType()->getVectorNumElements()==DstTy->getVectorNumElements()&&
    1746             :            "Invalid cast between a different number of vector elements");
    1747       14345 :   return getFoldedCast(Instruction::IntToPtr, C, DstTy, OnlyIfReduced);
    1748             : }
    1749             : 
    1750     2351787 : Constant *ConstantExpr::getBitCast(Constant *C, Type *DstTy,
    1751             :                                    bool OnlyIfReduced) {
    1752             :   assert(CastInst::castIsValid(Instruction::BitCast, C, DstTy) &&
    1753             :          "Invalid constantexpr bitcast!");
    1754             : 
    1755             :   // It is common to ask for a bitcast of a value to its own type, handle this
    1756             :   // speedily.
    1757     2351787 :   if (C->getType() == DstTy) return C;
    1758             : 
    1759     2324452 :   return getFoldedCast(Instruction::BitCast, C, DstTy, OnlyIfReduced);
    1760             : }
    1761             : 
    1762        1667 : Constant *ConstantExpr::getAddrSpaceCast(Constant *C, Type *DstTy,
    1763             :                                          bool OnlyIfReduced) {
    1764             :   assert(CastInst::castIsValid(Instruction::AddrSpaceCast, C, DstTy) &&
    1765             :          "Invalid constantexpr addrspacecast!");
    1766             : 
    1767             :   // Canonicalize addrspacecasts between different pointer types by first
    1768             :   // bitcasting the pointer type and then converting the address space.
    1769        1667 :   PointerType *SrcScalarTy = cast<PointerType>(C->getType()->getScalarType());
    1770             :   PointerType *DstScalarTy = cast<PointerType>(DstTy->getScalarType());
    1771        1667 :   Type *DstElemTy = DstScalarTy->getElementType();
    1772        1667 :   if (SrcScalarTy->getElementType() != DstElemTy) {
    1773         204 :     Type *MidTy = PointerType::get(DstElemTy, SrcScalarTy->getAddressSpace());
    1774             :     if (VectorType *VT = dyn_cast<VectorType>(DstTy)) {
    1775             :       // Handle vectors of pointers.
    1776           0 :       MidTy = VectorType::get(MidTy, VT->getNumElements());
    1777             :     }
    1778         204 :     C = getBitCast(C, MidTy);
    1779             :   }
    1780        1667 :   return getFoldedCast(Instruction::AddrSpaceCast, C, DstTy, OnlyIfReduced);
    1781             : }
    1782             : 
    1783      798564 : Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2,
    1784             :                             unsigned Flags, Type *OnlyIfReducedTy) {
    1785             :   // Check the operands for consistency first.
    1786             :   assert(Instruction::isBinaryOp(Opcode) &&
    1787             :          "Invalid opcode in binary constant expression");
    1788             :   assert(C1->getType() == C2->getType() &&
    1789             :          "Operand types in binary constant expression should match");
    1790             : 
    1791             : #ifndef NDEBUG
    1792             :   switch (Opcode) {
    1793             :   case Instruction::Add:
    1794             :   case Instruction::Sub:
    1795             :   case Instruction::Mul:
    1796             :     assert(C1->getType() == C2->getType() && "Op types should be identical!");
    1797             :     assert(C1->getType()->isIntOrIntVectorTy() &&
    1798             :            "Tried to create an integer operation on a non-integer type!");
    1799             :     break;
    1800             :   case Instruction::FAdd:
    1801             :   case Instruction::FSub:
    1802             :   case Instruction::FMul:
    1803             :     assert(C1->getType() == C2->getType() && "Op types should be identical!");
    1804             :     assert(C1->getType()->isFPOrFPVectorTy() &&
    1805             :            "Tried to create a floating-point operation on a "
    1806             :            "non-floating-point type!");
    1807             :     break;
    1808             :   case Instruction::UDiv:
    1809             :   case Instruction::SDiv:
    1810             :     assert(C1->getType() == C2->getType() && "Op types should be identical!");
    1811             :     assert(C1->getType()->isIntOrIntVectorTy() &&
    1812             :            "Tried to create an arithmetic operation on a non-arithmetic type!");
    1813             :     break;
    1814             :   case Instruction::FDiv:
    1815             :     assert(C1->getType() == C2->getType() && "Op types should be identical!");
    1816             :     assert(C1->getType()->isFPOrFPVectorTy() &&
    1817             :            "Tried to create an arithmetic operation on a non-arithmetic type!");
    1818             :     break;
    1819             :   case Instruction::URem:
    1820             :   case Instruction::SRem:
    1821             :     assert(C1->getType() == C2->getType() && "Op types should be identical!");
    1822             :     assert(C1->getType()->isIntOrIntVectorTy() &&
    1823             :            "Tried to create an arithmetic operation on a non-arithmetic type!");
    1824             :     break;
    1825             :   case Instruction::FRem:
    1826             :     assert(C1->getType() == C2->getType() && "Op types should be identical!");
    1827             :     assert(C1->getType()->isFPOrFPVectorTy() &&
    1828             :            "Tried to create an arithmetic operation on a non-arithmetic type!");
    1829             :     break;
    1830             :   case Instruction::And:
    1831             :   case Instruction::Or:
    1832             :   case Instruction::Xor:
    1833             :     assert(C1->getType() == C2->getType() && "Op types should be identical!");
    1834             :     assert(C1->getType()->isIntOrIntVectorTy() &&
    1835             :            "Tried to create a logical operation on a non-integral type!");
    1836             :     break;
    1837             :   case Instruction::Shl:
    1838             :   case Instruction::LShr:
    1839             :   case Instruction::AShr:
    1840             :     assert(C1->getType() == C2->getType() && "Op types should be identical!");
    1841             :     assert(C1->getType()->isIntOrIntVectorTy() &&
    1842             :            "Tried to create a shift operation on a non-integer type!");
    1843             :     break;
    1844             :   default:
    1845             :     break;
    1846             :   }
    1847             : #endif
    1848             : 
    1849      798564 :   if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))
    1850             :     return FC;          // Fold a few common cases.
    1851             : 
    1852       10428 :   if (OnlyIfReducedTy == C1->getType())
    1853             :     return nullptr;
    1854             : 
    1855       10386 :   Constant *ArgVec[] = { C1, C2 };
    1856             :   ConstantExprKeyType Key(Opcode, ArgVec, 0, Flags);
    1857             : 
    1858       10386 :   LLVMContextImpl *pImpl = C1->getContext().pImpl;
    1859       10386 :   return pImpl->ExprConstants.getOrCreate(C1->getType(), Key);
    1860             : }
    1861             : 
    1862         403 : Constant *ConstantExpr::getSizeOf(Type* Ty) {
    1863             :   // sizeof is implemented as: (i64) gep (Ty*)null, 1
    1864             :   // Note that a non-inbounds gep is used, as null isn't within any object.
    1865         403 :   Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
    1866         806 :   Constant *GEP = getGetElementPtr(
    1867         403 :       Ty, Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx);
    1868             :   return getPtrToInt(GEP,
    1869         403 :                      Type::getInt64Ty(Ty->getContext()));
    1870             : }
    1871             : 
    1872          38 : Constant *ConstantExpr::getAlignOf(Type* Ty) {
    1873             :   // alignof is implemented as: (i64) gep ({i1,Ty}*)null, 0, 1
    1874             :   // Note that a non-inbounds gep is used, as null isn't within any object.
    1875          38 :   Type *AligningTy = StructType::get(Type::getInt1Ty(Ty->getContext()), Ty);
    1876          38 :   Constant *NullPtr = Constant::getNullValue(AligningTy->getPointerTo(0));
    1877          38 :   Constant *Zero = ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0);
    1878          38 :   Constant *One = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
    1879          38 :   Constant *Indices[2] = { Zero, One };
    1880             :   Constant *GEP = getGetElementPtr(AligningTy, NullPtr, Indices);
    1881             :   return getPtrToInt(GEP,
    1882          38 :                      Type::getInt64Ty(Ty->getContext()));
    1883             : }
    1884             : 
    1885           0 : Constant *ConstantExpr::getOffsetOf(StructType* STy, unsigned FieldNo) {
    1886           0 :   return getOffsetOf(STy, ConstantInt::get(Type::getInt32Ty(STy->getContext()),
    1887           0 :                                            FieldNo));
    1888             : }
    1889             : 
    1890           0 : Constant *ConstantExpr::getOffsetOf(Type* Ty, Constant *FieldNo) {
    1891             :   // offsetof is implemented as: (i64) gep (Ty*)null, 0, FieldNo
    1892             :   // Note that a non-inbounds gep is used, as null isn't within any object.
    1893             :   Constant *GEPIdx[] = {
    1894           0 :     ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0),
    1895             :     FieldNo
    1896           0 :   };
    1897           0 :   Constant *GEP = getGetElementPtr(
    1898             :       Ty, Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx);
    1899             :   return getPtrToInt(GEP,
    1900           0 :                      Type::getInt64Ty(Ty->getContext()));
    1901             : }
    1902             : 
    1903       77930 : Constant *ConstantExpr::getCompare(unsigned short Predicate, Constant *C1,
    1904             :                                    Constant *C2, bool OnlyIfReduced) {
    1905             :   assert(C1->getType() == C2->getType() && "Op types should be identical!");
    1906             : 
    1907       77930 :   switch (Predicate) {
    1908           0 :   default: llvm_unreachable("Invalid CmpInst predicate");
    1909         360 :   case CmpInst::FCMP_FALSE: case CmpInst::FCMP_OEQ: case CmpInst::FCMP_OGT:
    1910             :   case CmpInst::FCMP_OGE:   case CmpInst::FCMP_OLT: case CmpInst::FCMP_OLE:
    1911             :   case CmpInst::FCMP_ONE:   case CmpInst::FCMP_ORD: case CmpInst::FCMP_UNO:
    1912             :   case CmpInst::FCMP_UEQ:   case CmpInst::FCMP_UGT: case CmpInst::FCMP_UGE:
    1913             :   case CmpInst::FCMP_ULT:   case CmpInst::FCMP_ULE: case CmpInst::FCMP_UNE:
    1914             :   case CmpInst::FCMP_TRUE:
    1915         360 :     return getFCmp(Predicate, C1, C2, OnlyIfReduced);
    1916             : 
    1917       77570 :   case CmpInst::ICMP_EQ:  case CmpInst::ICMP_NE:  case CmpInst::ICMP_UGT:
    1918             :   case CmpInst::ICMP_UGE: case CmpInst::ICMP_ULT: case CmpInst::ICMP_ULE:
    1919             :   case CmpInst::ICMP_SGT: case CmpInst::ICMP_SGE: case CmpInst::ICMP_SLT:
    1920             :   case CmpInst::ICMP_SLE:
    1921       77570 :     return getICmp(Predicate, C1, C2, OnlyIfReduced);
    1922             :   }
    1923             : }
    1924             : 
    1925        1158 : Constant *ConstantExpr::getSelect(Constant *C, Constant *V1, Constant *V2,
    1926             :                                   Type *OnlyIfReducedTy) {
    1927             :   assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands");
    1928             : 
    1929        1158 :   if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2))
    1930             :     return SC;        // Fold common cases
    1931             : 
    1932         108 :   if (OnlyIfReducedTy == V1->getType())
    1933             :     return nullptr;
    1934             : 
    1935         108 :   Constant *ArgVec[] = { C, V1, V2 };
    1936             :   ConstantExprKeyType Key(Instruction::Select, ArgVec);
    1937             : 
    1938         108 :   LLVMContextImpl *pImpl = C->getContext().pImpl;
    1939         108 :   return pImpl->ExprConstants.getOrCreate(V1->getType(), Key);
    1940             : }
    1941             : 
    1942    11029975 : Constant *ConstantExpr::getGetElementPtr(Type *Ty, Constant *C,
    1943             :                                          ArrayRef<Value *> Idxs, bool InBounds,
    1944             :                                          Optional<unsigned> InRangeIndex,
    1945             :                                          Type *OnlyIfReducedTy) {
    1946    11029975 :   if (!Ty)
    1947      369920 :     Ty = cast<PointerType>(C->getType()->getScalarType())->getElementType();
    1948             :   else
    1949             :     assert(
    1950             :         Ty ==
    1951             :         cast<PointerType>(C->getType()->getScalarType())->getContainedType(0u));
    1952             : 
    1953    11029975 :   if (Constant *FC =
    1954    11029975 :           ConstantFoldGetElementPtr(Ty, C, InBounds, InRangeIndex, Idxs))
    1955             :     return FC;          // Fold a few common cases.
    1956             : 
    1957             :   // Get the result type of the getelementptr!
    1958    10814345 :   Type *DestTy = GetElementPtrInst::getIndexedType(Ty, Idxs);
    1959             :   assert(DestTy && "GEP indices invalid!");
    1960    10814345 :   unsigned AS = C->getType()->getPointerAddressSpace();
    1961    10814345 :   Type *ReqTy = DestTy->getPointerTo(AS);
    1962             : 
    1963             :   unsigned NumVecElts = 0;
    1964    21628690 :   if (C->getType()->isVectorTy())
    1965             :     NumVecElts = C->getType()->getVectorNumElements();
    1966    54135356 :   else for (auto Idx : Idxs)
    1967    43321030 :     if (Idx->getType()->isVectorTy())
    1968             :       NumVecElts = Idx->getType()->getVectorNumElements();
    1969             : 
    1970    10814345 :   if (NumVecElts)
    1971          51 :     ReqTy = VectorType::get(ReqTy, NumVecElts);
    1972             : 
    1973    10814345 :   if (OnlyIfReducedTy == ReqTy)
    1974             :     return nullptr;
    1975             : 
    1976             :   // Look up the constant in the table first to ensure uniqueness
    1977             :   std::vector<Constant*> ArgVec;
    1978    10814241 :   ArgVec.reserve(1 + Idxs.size());
    1979    10814241 :   ArgVec.push_back(C);
    1980    32474608 :   for (unsigned i = 0, e = Idxs.size(); i != e; ++i) {
    1981             :     assert((!Idxs[i]->getType()->isVectorTy() ||
    1982             :             Idxs[i]->getType()->getVectorNumElements() == NumVecElts) &&
    1983             :            "getelementptr index type missmatch");
    1984             : 
    1985    43320734 :     Constant *Idx = cast<Constant>(Idxs[i]);
    1986    21660486 :     if (NumVecElts && !Idxs[i]->getType()->isVectorTy())
    1987          11 :       Idx = ConstantVector::getSplat(NumVecElts, Idx);
    1988    21660367 :     ArgVec.push_back(Idx);
    1989             :   }
    1990             : 
    1991    10814241 :   unsigned SubClassOptionalData = InBounds ? GEPOperator::IsInBounds : 0;
    1992    10814241 :   if (InRangeIndex && *InRangeIndex < 63)
    1993       27086 :     SubClassOptionalData |= (*InRangeIndex + 1) << 1;
    1994             :   const ConstantExprKeyType Key(Instruction::GetElementPtr, ArgVec, 0,
    1995             :                                 SubClassOptionalData, None, Ty);
    1996             : 
    1997    10814241 :   LLVMContextImpl *pImpl = C->getContext().pImpl;
    1998    10814241 :   return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
    1999             : }
    2000             : 
    2001       89358 : Constant *ConstantExpr::getICmp(unsigned short pred, Constant *LHS,
    2002             :                                 Constant *RHS, bool OnlyIfReduced) {
    2003             :   assert(LHS->getType() == RHS->getType());
    2004             :   assert(CmpInst::isIntPredicate((CmpInst::Predicate)pred) &&
    2005             :          "Invalid ICmp Predicate");
    2006             : 
    2007       89358 :   if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
    2008             :     return FC;          // Fold a few common cases...
    2009             : 
    2010        2865 :   if (OnlyIfReduced)
    2011             :     return nullptr;
    2012             : 
    2013             :   // Look up the constant in the table first to ensure uniqueness
    2014        2857 :   Constant *ArgVec[] = { LHS, RHS };
    2015             :   // Get the key type with both the opcode and predicate
    2016             :   const ConstantExprKeyType Key(Instruction::ICmp, ArgVec, pred);
    2017             : 
    2018        2857 :   Type *ResultTy = Type::getInt1Ty(LHS->getContext());
    2019        2857 :   if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
    2020           0 :     ResultTy = VectorType::get(ResultTy, VT->getNumElements());
    2021             : 
    2022        2857 :   LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
    2023        2857 :   return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
    2024             : }
    2025             : 
    2026         367 : Constant *ConstantExpr::getFCmp(unsigned short pred, Constant *LHS,
    2027             :                                 Constant *RHS, bool OnlyIfReduced) {
    2028             :   assert(LHS->getType() == RHS->getType());
    2029             :   assert(CmpInst::isFPPredicate((CmpInst::Predicate)pred) &&
    2030             :          "Invalid FCmp Predicate");
    2031             : 
    2032         367 :   if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
    2033             :     return FC;          // Fold a few common cases...
    2034             : 
    2035           4 :   if (OnlyIfReduced)
    2036             :     return nullptr;
    2037             : 
    2038             :   // Look up the constant in the table first to ensure uniqueness
    2039           4 :   Constant *ArgVec[] = { LHS, RHS };
    2040             :   // Get the key type with both the opcode and predicate
    2041             :   const ConstantExprKeyType Key(Instruction::FCmp, ArgVec, pred);
    2042             : 
    2043           4 :   Type *ResultTy = Type::getInt1Ty(LHS->getContext());
    2044           4 :   if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
    2045           0 :     ResultTy = VectorType::get(ResultTy, VT->getNumElements());
    2046             : 
    2047           4 :   LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
    2048           4 :   return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
    2049             : }
    2050             : 
    2051      309945 : Constant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx,
    2052             :                                           Type *OnlyIfReducedTy) {
    2053             :   assert(Val->getType()->isVectorTy() &&
    2054             :          "Tried to create extractelement operation on non-vector type!");
    2055             :   assert(Idx->getType()->isIntegerTy() &&
    2056             :          "Extractelement index must be an integer type!");
    2057             : 
    2058      309945 :   if (Constant *FC = ConstantFoldExtractElementInstruction(Val, Idx))
    2059             :     return FC;          // Fold a few common cases.
    2060             : 
    2061          95 :   Type *ReqTy = Val->getType()->getVectorElementType();
    2062          95 :   if (OnlyIfReducedTy == ReqTy)
    2063             :     return nullptr;
    2064             : 
    2065             :   // Look up the constant in the table first to ensure uniqueness
    2066          95 :   Constant *ArgVec[] = { Val, Idx };
    2067             :   const ConstantExprKeyType Key(Instruction::ExtractElement, ArgVec);
    2068             : 
    2069          95 :   LLVMContextImpl *pImpl = Val->getContext().pImpl;
    2070          95 :   return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
    2071             : }
    2072             : 
    2073      157325 : Constant *ConstantExpr::getInsertElement(Constant *Val, Constant *Elt,
    2074             :                                          Constant *Idx, Type *OnlyIfReducedTy) {
    2075             :   assert(Val->getType()->isVectorTy() &&
    2076             :          "Tried to create insertelement operation on non-vector type!");
    2077             :   assert(Elt->getType() == Val->getType()->getVectorElementType() &&
    2078             :          "Insertelement types must match!");
    2079             :   assert(Idx->getType()->isIntegerTy() &&
    2080             :          "Insertelement index must be i32 type!");
    2081             : 
    2082      157325 :   if (Constant *FC = ConstantFoldInsertElementInstruction(Val, Elt, Idx))
    2083             :     return FC;          // Fold a few common cases.
    2084             : 
    2085           0 :   if (OnlyIfReducedTy == Val->getType())
    2086             :     return nullptr;
    2087             : 
    2088             :   // Look up the constant in the table first to ensure uniqueness
    2089           0 :   Constant *ArgVec[] = { Val, Elt, Idx };
    2090             :   const ConstantExprKeyType Key(Instruction::InsertElement, ArgVec);
    2091             : 
    2092           0 :   LLVMContextImpl *pImpl = Val->getContext().pImpl;
    2093           0 :   return pImpl->ExprConstants.getOrCreate(Val->getType(), Key);
    2094             : }
    2095             : 
    2096        3190 : Constant *ConstantExpr::getShuffleVector(Constant *V1, Constant *V2,
    2097             :                                          Constant *Mask, Type *OnlyIfReducedTy) {
    2098             :   assert(ShuffleVectorInst::isValidOperands(V1, V2, Mask) &&
    2099             :          "Invalid shuffle vector constant expr operands!");
    2100             : 
    2101        3190 :   if (Constant *FC = ConstantFoldShuffleVectorInstruction(V1, V2, Mask))
    2102             :     return FC;          // Fold a few common cases.
    2103             : 
    2104           0 :   unsigned NElts = Mask->getType()->getVectorNumElements();
    2105           0 :   Type *EltTy = V1->getType()->getVectorElementType();
    2106           0 :   Type *ShufTy = VectorType::get(EltTy, NElts);
    2107             : 
    2108           0 :   if (OnlyIfReducedTy == ShufTy)
    2109             :     return nullptr;
    2110             : 
    2111             :   // Look up the constant in the table first to ensure uniqueness
    2112           0 :   Constant *ArgVec[] = { V1, V2, Mask };
    2113             :   const ConstantExprKeyType Key(Instruction::ShuffleVector, ArgVec);
    2114             : 
    2115           0 :   LLVMContextImpl *pImpl = ShufTy->getContext().pImpl;
    2116           0 :   return pImpl->ExprConstants.getOrCreate(ShufTy, Key);
    2117             : }
    2118             : 
    2119          93 : Constant *ConstantExpr::getInsertValue(Constant *Agg, Constant *Val,
    2120             :                                        ArrayRef<unsigned> Idxs,
    2121             :                                        Type *OnlyIfReducedTy) {
    2122             :   assert(Agg->getType()->isFirstClassType() &&
    2123             :          "Non-first-class type for constant insertvalue expression");
    2124             : 
    2125             :   assert(ExtractValueInst::getIndexedType(Agg->getType(),
    2126             :                                           Idxs) == Val->getType() &&
    2127             :          "insertvalue indices invalid!");
    2128          93 :   Type *ReqTy = Val->getType();
    2129             : 
    2130          93 :   if (Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs))
    2131             :     return FC;
    2132             : 
    2133           1 :   if (OnlyIfReducedTy == ReqTy)
    2134             :     return nullptr;
    2135             : 
    2136           1 :   Constant *ArgVec[] = { Agg, Val };
    2137             :   const ConstantExprKeyType Key(Instruction::InsertValue, ArgVec, 0, 0, Idxs);
    2138             : 
    2139           1 :   LLVMContextImpl *pImpl = Agg->getContext().pImpl;
    2140           1 :   return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
    2141             : }
    2142             : 
    2143      164451 : Constant *ConstantExpr::getExtractValue(Constant *Agg, ArrayRef<unsigned> Idxs,
    2144             :                                         Type *OnlyIfReducedTy) {
    2145             :   assert(Agg->getType()->isFirstClassType() &&
    2146             :          "Tried to create extractelement operation on non-first-class type!");
    2147             : 
    2148      164451 :   Type *ReqTy = ExtractValueInst::getIndexedType(Agg->getType(), Idxs);
    2149             :   (void)ReqTy;
    2150             :   assert(ReqTy && "extractvalue indices invalid!");
    2151             : 
    2152             :   assert(Agg->getType()->isFirstClassType() &&
    2153             :          "Non-first-class type for constant extractvalue expression");
    2154      164451 :   if (Constant *FC = ConstantFoldExtractValueInstruction(Agg, Idxs))
    2155             :     return FC;
    2156             : 
    2157           5 :   if (OnlyIfReducedTy == ReqTy)
    2158             :     return nullptr;
    2159             : 
    2160           5 :   Constant *ArgVec[] = { Agg };
    2161             :   const ConstantExprKeyType Key(Instruction::ExtractValue, ArgVec, 0, 0, Idxs);
    2162             : 
    2163           5 :   LLVMContextImpl *pImpl = Agg->getContext().pImpl;
    2164           5 :   return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
    2165             : }
    2166             : 
    2167      388766 : Constant *ConstantExpr::getNeg(Constant *C, bool HasNUW, bool HasNSW) {
    2168             :   assert(C->getType()->isIntOrIntVectorTy() &&
    2169             :          "Cannot NEG a nonintegral value!");
    2170      388766 :   return getSub(ConstantFP::getZeroValueForNegation(C->getType()),
    2171      388766 :                 C, HasNUW, HasNSW);
    2172             : }
    2173             : 
    2174          52 : Constant *ConstantExpr::getFNeg(Constant *C) {
    2175             :   assert(C->getType()->isFPOrFPVectorTy() &&
    2176             :          "Cannot FNEG a non-floating-point value!");
    2177          52 :   return getFSub(ConstantFP::getZeroValueForNegation(C->getType()), C);
    2178             : }
    2179             : 
    2180       81883 : Constant *ConstantExpr::getNot(Constant *C) {
    2181             :   assert(C->getType()->isIntOrIntVectorTy() &&
    2182             :          "Cannot NOT a nonintegral value!");
    2183       81883 :   return get(Instruction::Xor, C, Constant::getAllOnesValue(C->getType()));
    2184             : }
    2185             : 
    2186       31751 : Constant *ConstantExpr::getAdd(Constant *C1, Constant *C2,
    2187             :                                bool HasNUW, bool HasNSW) {
    2188       63502 :   unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
    2189       31751 :                    (HasNSW ? OverflowingBinaryOperator::NoSignedWrap   : 0);
    2190       31751 :   return get(Instruction::Add, C1, C2, Flags);
    2191             : }
    2192             : 
    2193           1 : Constant *ConstantExpr::getFAdd(Constant *C1, Constant *C2) {
    2194           1 :   return get(Instruction::FAdd, C1, C2);
    2195             : }
    2196             : 
    2197      445091 : Constant *ConstantExpr::getSub(Constant *C1, Constant *C2,
    2198             :                                bool HasNUW, bool HasNSW) {
    2199      890182 :   unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
    2200      445091 :                    (HasNSW ? OverflowingBinaryOperator::NoSignedWrap   : 0);
    2201      445091 :   return get(Instruction::Sub, C1, C2, Flags);
    2202             : }
    2203             : 
    2204          53 : Constant *ConstantExpr::getFSub(Constant *C1, Constant *C2) {
    2205          53 :   return get(Instruction::FSub, C1, C2);
    2206             : }
    2207             : 
    2208        7340 : Constant *ConstantExpr::getMul(Constant *C1, Constant *C2,
    2209             :                                bool HasNUW, bool HasNSW) {
    2210       14680 :   unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
    2211        7340 :                    (HasNSW ? OverflowingBinaryOperator::NoSignedWrap   : 0);
    2212        7340 :   return get(Instruction::Mul, C1, C2, Flags);
    2213             : }
    2214             : 
    2215          12 : Constant *ConstantExpr::getFMul(Constant *C1, Constant *C2) {
    2216          12 :   return get(Instruction::FMul, C1, C2);
    2217             : }
    2218             : 
    2219       11260 : Constant *ConstantExpr::getUDiv(Constant *C1, Constant *C2, bool isExact) {
    2220       11260 :   return get(Instruction::UDiv, C1, C2,
    2221       11260 :              isExact ? PossiblyExactOperator::IsExact : 0);
    2222             : }
    2223             : 
    2224       17791 : Constant *ConstantExpr::getSDiv(Constant *C1, Constant *C2, bool isExact) {
    2225       17791 :   return get(Instruction::SDiv, C1, C2,
    2226       17791 :              isExact ? PossiblyExactOperator::IsExact : 0);
    2227             : }
    2228             : 
    2229          42 : Constant *ConstantExpr::getFDiv(Constant *C1, Constant *C2) {
    2230          42 :   return get(Instruction::FDiv, C1, C2);
    2231             : }
    2232             : 
    2233           2 : Constant *ConstantExpr::getURem(Constant *C1, Constant *C2) {
    2234           2 :   return get(Instruction::URem, C1, C2);
    2235             : }
    2236             : 
    2237          64 : Constant *ConstantExpr::getSRem(Constant *C1, Constant *C2) {
    2238          64 :   return get(Instruction::SRem, C1, C2);
    2239             : }
    2240             : 
    2241           1 : Constant *ConstantExpr::getFRem(Constant *C1, Constant *C2) {
    2242           1 :   return get(Instruction::FRem, C1, C2);
    2243             : }
    2244             : 
    2245        1721 : Constant *ConstantExpr::getAnd(Constant *C1, Constant *C2) {
    2246        1721 :   return get(Instruction::And, C1, C2);
    2247             : }
    2248             : 
    2249        1189 : Constant *ConstantExpr::getOr(Constant *C1, Constant *C2) {
    2250        1189 :   return get(Instruction::Or, C1, C2);
    2251             : }
    2252             : 
    2253         119 : Constant *ConstantExpr::getXor(Constant *C1, Constant *C2) {
    2254         119 :   return get(Instruction::Xor, C1, C2);
    2255             : }
    2256             : 
    2257        6495 : Constant *ConstantExpr::getShl(Constant *C1, Constant *C2,
    2258             :                                bool HasNUW, bool HasNSW) {
    2259       12990 :   unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
    2260        6495 :                    (HasNSW ? OverflowingBinaryOperator::NoSignedWrap   : 0);
    2261        6495 :   return get(Instruction::Shl, C1, C2, Flags);
    2262             : }
    2263             : 
    2264         943 : Constant *ConstantExpr::getLShr(Constant *C1, Constant *C2, bool isExact) {
    2265         943 :   return get(Instruction::LShr, C1, C2,
    2266         943 :              isExact ? PossiblyExactOperator::IsExact : 0);
    2267             : }
    2268             : 
    2269         596 : Constant *ConstantExpr::getAShr(Constant *C1, Constant *C2, bool isExact) {
    2270         596 :   return get(Instruction::AShr, C1, C2,
    2271         596 :              isExact ? PossiblyExactOperator::IsExact : 0);
    2272             : }
    2273             : 
    2274      456583 : Constant *ConstantExpr::getBinOpIdentity(unsigned Opcode, Type *Ty,
    2275             :                                          bool AllowRHSConstant) {
    2276             :   assert(Instruction::isBinaryOp(Opcode) && "Only binops allowed");
    2277             : 
    2278             :   // Commutative opcodes: it does not matter if AllowRHSConstant is set.
    2279             :   if (Instruction::isCommutative(Opcode)) {
    2280      441151 :     switch (Opcode) {
    2281      419940 :       case Instruction::Add: // X + 0 = X
    2282             :       case Instruction::Or:  // X | 0 = X
    2283             :       case Instruction::Xor: // X ^ 0 = X
    2284      419940 :         return Constant::getNullValue(Ty);
    2285        7131 :       case Instruction::Mul: // X * 1 = X
    2286        7131 :         return ConstantInt::get(Ty, 1);
    2287       13961 :       case Instruction::And: // X & -1 = X
    2288       13961 :         return Constant::getAllOnesValue(Ty);
    2289          32 :       case Instruction::FAdd: // X + -0.0 = X
    2290             :         // TODO: If the fadd has 'nsz', should we return +0.0?
    2291          32 :         return ConstantFP::getNegativeZero(Ty);
    2292          87 :       case Instruction::FMul: // X * 1.0 = X
    2293          87 :         return ConstantFP::get(Ty, 1.0);
    2294           0 :       default:
    2295           0 :         llvm_unreachable("Every commutative binop has an identity constant");
    2296             :     }
    2297             :   }
    2298             : 
    2299             :   // Non-commutative opcodes: AllowRHSConstant must be set.
    2300       15432 :   if (!AllowRHSConstant)
    2301             :     return nullptr;
    2302             : 
    2303             :   switch (Opcode) {
    2304          20 :     case Instruction::Sub:  // X - 0 = X
    2305             :     case Instruction::Shl:  // X << 0 = X
    2306             :     case Instruction::LShr: // X >>u 0 = X
    2307             :     case Instruction::AShr: // X >> 0 = X
    2308             :     case Instruction::FSub: // X - 0.0 = X
    2309          20 :       return Constant::getNullValue(Ty);
    2310          12 :     case Instruction::SDiv: // X / 1 = X
    2311             :     case Instruction::UDiv: // X /u 1 = X
    2312          12 :       return ConstantInt::get(Ty, 1);
    2313           1 :     case Instruction::FDiv: // X / 1.0 = X
    2314           1 :       return ConstantFP::get(Ty, 1.0);
    2315             :     default:
    2316             :       return nullptr;
    2317             :   }
    2318             : }
    2319             : 
    2320      398364 : Constant *ConstantExpr::getBinOpAbsorber(unsigned Opcode, Type *Ty) {
    2321      398364 :   switch (Opcode) {
    2322             :   default:
    2323             :     // Doesn't have an absorber.
    2324             :     return nullptr;
    2325             : 
    2326         878 :   case Instruction::Or:
    2327         878 :     return Constant::getAllOnesValue(Ty);
    2328             : 
    2329        2778 :   case Instruction::And:
    2330             :   case Instruction::Mul:
    2331        2778 :     return Constant::getNullValue(Ty);
    2332             :   }
    2333             : }
    2334             : 
    2335             : /// Remove the constant from the constant table.
    2336      302979 : void ConstantExpr::destroyConstantImpl() {
    2337      302979 :   getType()->getContext().pImpl->ExprConstants.remove(this);
    2338      302979 : }
    2339             : 
    2340      102444 : const char *ConstantExpr::getOpcodeName() const {
    2341      102444 :   return Instruction::getOpcodeName(getOpcode());
    2342             : }
    2343             : 
    2344      429437 : GetElementPtrConstantExpr::GetElementPtrConstantExpr(
    2345      429437 :     Type *SrcElementTy, Constant *C, ArrayRef<Constant *> IdxList, Type *DestTy)
    2346             :     : ConstantExpr(DestTy, Instruction::GetElementPtr,
    2347             :                    OperandTraits<GetElementPtrConstantExpr>::op_end(this) -
    2348             :                        (IdxList.size() + 1),
    2349             :                    IdxList.size() + 1),
    2350             :       SrcElementTy(SrcElementTy),
    2351      858874 :       ResElementTy(GetElementPtrInst::getIndexedType(SrcElementTy, IdxList)) {
    2352             :   Op<0>() = C;
    2353      429437 :   Use *OperandList = getOperandList();
    2354     2158671 :   for (unsigned i = 0, E = IdxList.size(); i != E; ++i)
    2355     1729234 :     OperandList[i+1] = IdxList[i];
    2356      429437 : }
    2357             : 
    2358    35541235 : Type *GetElementPtrConstantExpr::getSourceElementType() const {
    2359    35541235 :   return SrcElementTy;
    2360             : }
    2361             : 
    2362    10290317 : Type *GetElementPtrConstantExpr::getResultElementType() const {
    2363    10290317 :   return ResElementTy;
    2364             : }
    2365             : 
    2366             : //===----------------------------------------------------------------------===//
    2367             : //                       ConstantData* implementations
    2368             : 
    2369    32706734 : Type *ConstantDataSequential::getElementType() const {
    2370    32706734 :   return getType()->getElementType();
    2371             : }
    2372             : 
    2373     1607819 : StringRef ConstantDataSequential::getRawDataValues() const {
    2374     1607819 :   return StringRef(DataElements, getNumElements()*getElementByteSize());
    2375             : }
    2376             : 
    2377      303709 : bool ConstantDataSequential::isElementTypeCompatible(Type *Ty) {
    2378      303709 :   if (Ty->isHalfTy() || Ty->isFloatTy() || Ty->isDoubleTy()) return true;
    2379             :   if (auto *IT = dyn_cast<IntegerType>(Ty)) {
    2380             :     switch (IT->getBitWidth()) {
    2381             :     case 8:
    2382             :     case 16:
    2383             :     case 32:
    2384             :     case 64:
    2385             :       return true;
    2386             :     default: break;
    2387             :     }
    2388             :   }
    2389             :   return false;
    2390             : }
    2391             : 
    2392     4567704 : unsigned ConstantDataSequential::getNumElements() const {
    2393             :   if (ArrayType *AT = dyn_cast<ArrayType>(getType()))
    2394      152279 :     return AT->getNumElements();
    2395     4415425 :   return getType()->getVectorNumElements();
    2396             : }
    2397             : 
    2398             : 
    2399    11405068 : uint64_t ConstantDataSequential::getElementByteSize() const {
    2400    11405068 :   return getElementType()->getPrimitiveSizeInBits()/8;
    2401             : }
    2402             : 
    2403             : /// Return the start of the specified element.
    2404     8291348 : const char *ConstantDataSequential::getElementPointer(unsigned Elt) const {
    2405             :   assert(Elt < getNumElements() && "Invalid Elt");
    2406     8291348 :   return DataElements+Elt*getElementByteSize();
    2407             : }
    2408             : 
    2409             : 
    2410             : /// Return true if the array is empty or all zeros.
    2411             : static bool isAllZeros(StringRef Arr) {
    2412      700609 :   for (char I : Arr)
    2413      483134 :     if (I != 0)
    2414             :       return false;
    2415             :   return true;
    2416             : }
    2417             : 
    2418             : /// This is the underlying implementation of all of the
    2419             : /// ConstantDataSequential::get methods.  They all thunk down to here, providing
    2420             : /// the correct element type.  We take the bytes in as a StringRef because
    2421             : /// we *want* an underlying "char*" to avoid TBAA type punning violations.
    2422      267639 : Constant *ConstantDataSequential::getImpl(StringRef Elements, Type *Ty) {
    2423             :   assert(isElementTypeCompatible(Ty->getSequentialElementType()));
    2424             :   // If the elements are all zero or there are no elements, return a CAZ, which
    2425             :   // is more dense and canonical.
    2426      267639 :   if (isAllZeros(Elements))
    2427         990 :     return ConstantAggregateZero::get(Ty);
    2428             : 
    2429             :   // Do a lookup to see if we have already formed one of these.
    2430             :   auto &Slot =
    2431      266649 :       *Ty->getContext()
    2432      266649 :            .pImpl->CDSConstants.insert(std::make_pair(Elements, nullptr))
    2433             :            .first;
    2434             : 
    2435             :   // The bucket can point to a linked list of different CDS's that have the same
    2436             :   // body but different types.  For example, 0,0,0,1 could be a 4 element array
    2437             :   // of i8, or a 1-element array of i32.  They'll both end up in the same
    2438             :   /// StringMap bucket, linked up by their Next pointers.  Walk the list.
    2439      266649 :   ConstantDataSequential **Entry = &Slot.second;
    2440      276257 :   for (ConstantDataSequential *Node = *Entry; Node;
    2441        9608 :        Entry = &Node->Next, Node = *Entry)
    2442      167956 :     if (Node->getType() == Ty)
    2443             :       return Node;
    2444             : 
    2445             :   // Okay, we didn't get a hit.  Create a node of the right class, link it in,
    2446             :   // and return it.
    2447      108301 :   if (isa<ArrayType>(Ty))
    2448       65796 :     return *Entry = new ConstantDataArray(Ty, Slot.first().data());
    2449             : 
    2450             :   assert(isa<VectorType>(Ty));
    2451       42505 :   return *Entry = new ConstantDataVector(Ty, Slot.first().data());
    2452             : }
    2453             : 
    2454           0 : void ConstantDataSequential::destroyConstantImpl() {
    2455             :   // Remove the constant from the StringMap.
    2456             :   StringMap<ConstantDataSequential*> &CDSConstants =
    2457           0 :     getType()->getContext().pImpl->CDSConstants;
    2458             : 
    2459             :   StringMap<ConstantDataSequential*>::iterator Slot =
    2460           0 :     CDSConstants.find(getRawDataValues());
    2461             : 
    2462             :   assert(Slot != CDSConstants.end() && "CDS not found in uniquing table");
    2463             : 
    2464             :   ConstantDataSequential **Entry = &Slot->getValue();
    2465             : 
    2466             :   // Remove the entry from the hash table.
    2467           0 :   if (!(*Entry)->Next) {
    2468             :     // If there is only one value in the bucket (common case) it must be this
    2469             :     // entry, and removing the entry should remove the bucket completely.
    2470             :     assert((*Entry) == this && "Hash mismatch in ConstantDataSequential");
    2471           0 :     getContext().pImpl->CDSConstants.erase(Slot);
    2472             :   } else {
    2473             :     // Otherwise, there are multiple entries linked off the bucket, unlink the
    2474             :     // node we care about but keep the bucket around.
    2475             :     for (ConstantDataSequential *Node = *Entry; ;
    2476           0 :          Entry = &Node->Next, Node = *Entry) {
    2477           0 :       assert(Node && "Didn't find entry in its uniquing hash table!");
    2478             :       // If we found our entry, unlink it from the list and we're done.
    2479           0 :       if (Node == this) {
    2480           0 :         *Entry = Node->Next;
    2481           0 :         break;
    2482             :       }
    2483             :     }
    2484             :   }
    2485             : 
    2486             :   // If we were part of a list, make sure that we don't delete the list that is
    2487             :   // still owned by the uniquing map.
    2488           0 :   Next = nullptr;
    2489           0 : }
    2490             : 
    2491             : /// getFP() constructors - Return a constant with array type with an element
    2492             : /// count and element type of float with precision matching the number of
    2493             : /// bits in the ArrayRef passed in. (i.e. half for 16bits, float for 32bits,
    2494             : /// double for 64bits) Note that this can return a ConstantAggregateZero
    2495             : /// object.
    2496          19 : Constant *ConstantDataArray::getFP(LLVMContext &Context,
    2497             :                                    ArrayRef<uint16_t> Elts) {
    2498          19 :   Type *Ty = ArrayType::get(Type::getHalfTy(Context), Elts.size());
    2499          19 :   const char *Data = reinterpret_cast<const char *>(Elts.data());
    2500          38 :   return getImpl(StringRef(Data, Elts.size() * 2), Ty);
    2501             : }
    2502         100 : Constant *ConstantDataArray::getFP(LLVMContext &Context,
    2503             :                                    ArrayRef<uint32_t> Elts) {
    2504         100 :   Type *Ty = ArrayType::get(Type::getFloatTy(Context), Elts.size());
    2505         100 :   const char *Data = reinterpret_cast<const char *>(Elts.data());
    2506         200 :   return getImpl(StringRef(Data, Elts.size() * 4), Ty);
    2507             : }
    2508          43 : Constant *ConstantDataArray::getFP(LLVMContext &Context,
    2509             :                                    ArrayRef<uint64_t> Elts) {
    2510          43 :   Type *Ty = ArrayType::get(Type::getDoubleTy(Context), Elts.size());
    2511          43 :   const char *Data = reinterpret_cast<const char *>(Elts.data());
    2512          86 :   return getImpl(StringRef(Data, Elts.size() * 8), Ty);
    2513             : }
    2514             : 
    2515       76242 : Constant *ConstantDataArray::getString(LLVMContext &Context,
    2516             :                                        StringRef Str, bool AddNull) {
    2517       76242 :   if (!AddNull) {
    2518             :     const uint8_t *Data = reinterpret_cast<const uint8_t *>(Str.data());
    2519       37403 :     return get(Context, makeArrayRef(Data, Str.size()));
    2520             :   }
    2521             : 
    2522             :   SmallVector<uint8_t, 64> ElementVals;
    2523       38839 :   ElementVals.append(Str.begin(), Str.end());
    2524       38839 :   ElementVals.push_back(0);
    2525             :   return get(Context, ElementVals);
    2526             : }
    2527             : 
    2528             : /// get() constructors - Return a constant with vector type with an element
    2529             : /// count and element type matching the ArrayRef passed in.  Note that this
    2530             : /// can return a ConstantAggregateZero object.
    2531       12973 : Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint8_t> Elts){
    2532       12973 :   Type *Ty = VectorType::get(Type::getInt8Ty(Context), Elts.size());
    2533       12973 :   const char *Data = reinterpret_cast<const char *>(Elts.data());
    2534       12973 :   return getImpl(StringRef(Data, Elts.size() * 1), Ty);
    2535             : }
    2536        8465 : Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint16_t> Elts){
    2537        8465 :   Type *Ty = VectorType::get(Type::getInt16Ty(Context), Elts.size());
    2538        8465 :   const char *Data = reinterpret_cast<const char *>(Elts.data());
    2539       16930 :   return getImpl(StringRef(Data, Elts.size() * 2), Ty);
    2540             : }
    2541       61510 : Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint32_t> Elts){
    2542       61510 :   Type *Ty = VectorType::get(Type::getInt32Ty(Context), Elts.size());
    2543       61510 :   const char *Data = reinterpret_cast<const char *>(Elts.data());
    2544      123020 :   return getImpl(StringRef(Data, Elts.size() * 4), Ty);
    2545             : }
    2546       86288 : Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint64_t> Elts){
    2547       86288 :   Type *Ty = VectorType::get(Type::getInt64Ty(Context), Elts.size());
    2548       86288 :   const char *Data = reinterpret_cast<const char *>(Elts.data());
    2549      172576 :   return getImpl(StringRef(Data, Elts.size() * 8), Ty);
    2550             : }
    2551           0 : Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<float> Elts) {
    2552           0 :   Type *Ty = VectorType::get(Type::getFloatTy(Context), Elts.size());
    2553           0 :   const char *Data = reinterpret_cast<const char *>(Elts.data());
    2554           0 :   return getImpl(StringRef(Data, Elts.size() * 4), Ty);
    2555             : }
    2556           0 : Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<double> Elts) {
    2557           0 :   Type *Ty = VectorType::get(Type::getDoubleTy(Context), Elts.size());
    2558           0 :   const char *Data = reinterpret_cast<const char *>(Elts.data());
    2559           0 :   return getImpl(StringRef(Data, Elts.size() * 8), Ty);
    2560             : }
    2561             : 
    2562             : /// getFP() constructors - Return a constant with vector type with an element
    2563             : /// count and element type of float with the precision matching the number of
    2564             : /// bits in the ArrayRef passed in.  (i.e. half for 16bits, float for 32bits,
    2565             : /// double for 64bits) Note that this can return a ConstantAggregateZero
    2566             : /// object.
    2567         672 : Constant *ConstantDataVector::getFP(LLVMContext &Context,
    2568             :                                     ArrayRef<uint16_t> Elts) {
    2569         672 :   Type *Ty = VectorType::get(Type::getHalfTy(Context), Elts.size());
    2570         672 :   const char *Data = reinterpret_cast<const char *>(Elts.data());
    2571        1344 :   return getImpl(StringRef(Data, Elts.size() * 2), Ty);
    2572             : }
    2573        5867 : Constant *ConstantDataVector::getFP(LLVMContext &Context,
    2574             :                                     ArrayRef<uint32_t> Elts) {
    2575        5867 :   Type *Ty = VectorType::get(Type::getFloatTy(Context), Elts.size());
    2576        5867 :   const char *Data = reinterpret_cast<const char *>(Elts.data());
    2577       11734 :   return getImpl(StringRef(Data, Elts.size() * 4), Ty);
    2578             : }
    2579        4006 : Constant *ConstantDataVector::getFP(LLVMContext &Context,
    2580             :                                     ArrayRef<uint64_t> Elts) {
    2581        4006 :   Type *Ty = VectorType::get(Type::getDoubleTy(Context), Elts.size());
    2582        4006 :   const char *Data = reinterpret_cast<const char *>(Elts.data());
    2583        8012 :   return getImpl(StringRef(Data, Elts.size() * 8), Ty);
    2584             : }
    2585             : 
    2586       11620 : Constant *ConstantDataVector::getSplat(unsigned NumElts, Constant *V) {
    2587             :   assert(isElementTypeCompatible(V->getType()) &&
    2588             :          "Element type not compatible with ConstantData");
    2589             :   if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
    2590        8233 :     if (CI->getType()->isIntegerTy(8)) {
    2591        2258 :       SmallVector<uint8_t, 16> Elts(NumElts, CI->getZExtValue());
    2592        1129 :       return get(V->getContext(), Elts);
    2593             :     }
    2594        7104 :     if (CI->getType()->isIntegerTy(16)) {
    2595        2078 :       SmallVector<uint16_t, 16> Elts(NumElts, CI->getZExtValue());
    2596        1039 :       return get(V->getContext(), Elts);
    2597             :     }
    2598        6065 :     if (CI->getType()->isIntegerTy(32)) {
    2599        8286 :       SmallVector<uint32_t, 16> Elts(NumElts, CI->getZExtValue());
    2600        4143 :       return get(V->getContext(), Elts);
    2601             :     }
    2602             :     assert(CI->getType()->isIntegerTy(64) && "Unsupported ConstantData type");
    2603        3844 :     SmallVector<uint64_t, 16> Elts(NumElts, CI->getZExtValue());
    2604        1922 :     return get(V->getContext(), Elts);
    2605             :   }
    2606             : 
    2607             :   if (ConstantFP *CFP = dyn_cast<ConstantFP>(V)) {
    2608        6774 :     if (CFP->getType()->isHalfTy()) {
    2609             :       SmallVector<uint16_t, 16> Elts(
    2610         480 :           NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
    2611         120 :       return getFP(V->getContext(), Elts);
    2612             :     }
    2613        3267 :     if (CFP->getType()->isFloatTy()) {
    2614             :       SmallVector<uint32_t, 16> Elts(
    2615        6924 :           NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
    2616        1731 :       return getFP(V->getContext(), Elts);
    2617             :     }
    2618        1536 :     if (CFP->getType()->isDoubleTy()) {
    2619             :       SmallVector<uint64_t, 16> Elts(
    2620        6144 :           NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
    2621        1536 :       return getFP(V->getContext(), Elts);
    2622             :     }
    2623             :   }
    2624           0 :   return ConstantVector::getSplat(NumElts, V);
    2625             : }
    2626             : 
    2627             : 
    2628     8200640 : uint64_t ConstantDataSequential::getElementAsInteger(unsigned Elt) const {
    2629             :   assert(isa<IntegerType>(getElementType()) &&
    2630             :          "Accessor can only be used when element is an integer");
    2631     8200640 :   const char *EltPtr = getElementPointer(Elt);
    2632             : 
    2633             :   // The data is stored in host byte order, make sure to cast back to the right
    2634             :   // type to load with the right endianness.
    2635    16401280 :   switch (getElementType()->getIntegerBitWidth()) {
    2636           0 :   default: llvm_unreachable("Invalid bitwidth for CDS");
    2637     3616975 :   case 8:
    2638     3616975 :     return *reinterpret_cast<const uint8_t *>(EltPtr);
    2639      197043 :   case 16:
    2640      197043 :     return *reinterpret_cast<const uint16_t *>(EltPtr);
    2641     2846094 :   case 32:
    2642     2846094 :     return *reinterpret_cast<const uint32_t *>(EltPtr);
    2643     1540528 :   case 64:
    2644     1540528 :     return *reinterpret_cast<const uint64_t *>(EltPtr);
    2645             :   }
    2646             : }
    2647             : 
    2648       50909 : APInt ConstantDataSequential::getElementAsAPInt(unsigned Elt) const {
    2649             :   assert(isa<IntegerType>(getElementType()) &&
    2650             :          "Accessor can only be used when element is an integer");
    2651       50909 :   const char *EltPtr = getElementPointer(Elt);
    2652             : 
    2653             :   // The data is stored in host byte order, make sure to cast back to the right
    2654             :   // type to load with the right endianness.
    2655      101818 :   switch (getElementType()->getIntegerBitWidth()) {
    2656           0 :   default: llvm_unreachable("Invalid bitwidth for CDS");
    2657        2289 :   case 8: {
    2658        2289 :     auto EltVal = *reinterpret_cast<const uint8_t *>(EltPtr);
    2659        2289 :     return APInt(8, EltVal);
    2660             :   }
    2661        2739 :   case 16: {
    2662        2739 :     auto EltVal = *reinterpret_cast<const uint16_t *>(EltPtr);
    2663        2739 :     return APInt(16, EltVal);
    2664             :   }
    2665       27862 :   case 32: {
    2666       27862 :     auto EltVal = *reinterpret_cast<const uint32_t *>(EltPtr);
    2667       27862 :     return APInt(32, EltVal);
    2668             :   }
    2669       18019 :   case 64: {
    2670       18019 :     auto EltVal = *reinterpret_cast<const uint64_t *>(EltPtr);
    2671             :     return APInt(64, EltVal);
    2672             :   }
    2673             :   }
    2674             : }
    2675             : 
    2676       37357 : APFloat ConstantDataSequential::getElementAsAPFloat(unsigned Elt) const {
    2677       37357 :   const char *EltPtr = getElementPointer(Elt);
    2678             : 
    2679       74714 :   switch (getElementType()->getTypeID()) {
    2680           0 :   default:
    2681           0 :     llvm_unreachable("Accessor can only be used when element is float/double!");
    2682        2753 :   case Type::HalfTyID: {
    2683        2753 :     auto EltVal = *reinterpret_cast<const uint16_t *>(EltPtr);
    2684        8259 :     return APFloat(APFloat::IEEEhalf(), APInt(16, EltVal));
    2685             :   }
    2686       26369 :   case Type::FloatTyID: {
    2687       26369 :     auto EltVal = *reinterpret_cast<const uint32_t *>(EltPtr);
    2688       79107 :     return APFloat(APFloat::IEEEsingle(), APInt(32, EltVal));
    2689             :   }
    2690        8235 :   case Type::DoubleTyID: {
    2691        8235 :     auto EltVal = *reinterpret_cast<const uint64_t *>(EltPtr);
    2692       16470 :     return APFloat(APFloat::IEEEdouble(), APInt(64, EltVal));
    2693             :   }
    2694             :   }
    2695             : }
    2696             : 
    2697        1777 : float ConstantDataSequential::getElementAsFloat(unsigned Elt) const {
    2698             :   assert(getElementType()->isFloatTy() &&
    2699             :          "Accessor can only be used when element is a 'float'");
    2700        1777 :   return *reinterpret_cast<const float *>(getElementPointer(Elt));
    2701             : }
    2702             : 
    2703         665 : double ConstantDataSequential::getElementAsDouble(unsigned Elt) const {
    2704             :   assert(getElementType()->isDoubleTy() &&
    2705             :          "Accessor can only be used when element is a 'float'");
    2706         665 :   return *reinterpret_cast<const double *>(getElementPointer(Elt));
    2707             : }
    2708             : 
    2709     3219499 : Constant *ConstantDataSequential::getElementAsConstant(unsigned Elt) const {
    2710    12852803 :   if (getElementType()->isHalfTy() || getElementType()->isFloatTy() ||
    2711     3196995 :       getElementType()->isDoubleTy())
    2712       57976 :     return ConstantFP::get(getContext(), getElementAsAPFloat(Elt));
    2713             : 
    2714     3190511 :   return ConstantInt::get(getElementType(), getElementAsInteger(Elt));
    2715             : }
    2716             : 
    2717       83583 : bool ConstantDataSequential::isString(unsigned CharSize) const {
    2718       83583 :   return isa<ArrayType>(getType()) && getElementType()->isIntegerTy(CharSize);
    2719             : }
    2720             : 
    2721        1821 : bool ConstantDataSequential::isCString() const {
    2722        1821 :   if (!isString())
    2723             :     return false;
    2724             : 
    2725        1821 :   StringRef Str = getAsString();
    2726             : 
    2727             :   // The last value must be nul.
    2728        1821 :   if (Str.back() != 0) return false;
    2729             : 
    2730             :   // Other elements must be non-nul.
    2731        1034 :   return Str.drop_back().find(0) == StringRef::npos;
    2732             : }
    2733             : 
    2734     1489454 : bool ConstantDataVector::isSplat() const {
    2735     2978908 :   const char *Base = getRawDataValues().data();
    2736             : 
    2737             :   // Compare elements 1+ to the 0'th element.
    2738     1489454 :   unsigned EltSize = getElementByteSize();
    2739     3281513 :   for (unsigned i = 1, e = getNumElements(); i != e; ++i)
    2740     1818031 :     if (memcmp(Base, Base+i*EltSize, EltSize))
    2741             :       return false;
    2742             : 
    2743             :   return true;
    2744             : }
    2745             : 
    2746     1480582 : Constant *ConstantDataVector::getSplatValue() const {
    2747             :   // If they're all the same, return the 0th one as a representative.
    2748     1480582 :   return isSplat() ? getElementAsConstant(0) : nullptr;
    2749             : }
    2750             : 
    2751             : //===----------------------------------------------------------------------===//
    2752             : //                handleOperandChange implementations
    2753             : 
    2754             : /// Update this constant array to change uses of
    2755             : /// 'From' to be uses of 'To'.  This must update the uniquing data structures
    2756             : /// etc.
    2757             : ///
    2758             : /// Note that we intentionally replace all uses of From with To here.  Consider
    2759             : /// a large array that uses 'From' 1000 times.  By handling this case all here,
    2760             : /// ConstantArray::handleOperandChange is only invoked once, and that
    2761             : /// single invocation handles all 1000 uses.  Handling them one at a time would
    2762             : /// work, but would be really slow because it would have to unique each updated
    2763             : /// array instance.
    2764             : ///
    2765        3823 : void Constant::handleOperandChange(Value *From, Value *To) {
    2766             :   Value *Replacement = nullptr;
    2767        7646 :   switch (getValueID()) {
    2768           0 :   default:
    2769           0 :     llvm_unreachable("Not a constant!");
    2770             : #define HANDLE_CONSTANT(Name)                                                  \
    2771             :   case Value::Name##Val:                                                       \
    2772             :     Replacement = cast<Name>(this)->handleOperandChangeImpl(From, To);         \
    2773             :     break;
    2774             : #include "llvm/IR/Value.def"
    2775             :   }
    2776             : 
    2777             :   // If handleOperandChangeImpl returned nullptr, then it handled
    2778             :   // replacing itself and we don't want to delete or replace anything else here.
    2779        3823 :   if (!Replacement)
    2780             :     return;
    2781             : 
    2782             :   // I do need to replace this with an existing value.
    2783             :   assert(Replacement != this && "I didn't contain From!");
    2784             : 
    2785             :   // Everyone using this now uses the replacement.
    2786        1468 :   replaceAllUsesWith(Replacement);
    2787             : 
    2788             :   // Delete the old constant!
    2789        1468 :   destroyConstant();
    2790             : }
    2791             : 
    2792        1255 : Value *ConstantArray::handleOperandChangeImpl(Value *From, Value *To) {
    2793             :   assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
    2794             :   Constant *ToC = cast<Constant>(To);
    2795             : 
    2796             :   SmallVector<Constant*, 8> Values;
    2797        1255 :   Values.reserve(getNumOperands());  // Build replacement array.
    2798             : 
    2799             :   // Fill values with the modified operands of the constant array.  Also,
    2800             :   // compute whether this turns into an all-zeros array.
    2801             :   unsigned NumUpdated = 0;
    2802             : 
    2803             :   // Keep track of whether all the values in the array are "ToC".
    2804             :   bool AllSame = true;
    2805        1255 :   Use *OperandList = getOperandList();
    2806             :   unsigned OperandNo = 0;
    2807        8943 :   for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
    2808        7688 :     Constant *Val = cast<Constant>(O->get());
    2809        7688 :     if (Val == From) {
    2810        1263 :       OperandNo = (O - OperandList);
    2811        1263 :       Val = ToC;
    2812        1263 :       ++NumUpdated;
    2813             :     }
    2814        7688 :     Values.push_back(Val);
    2815        7688 :     AllSame &= Val == ToC;
    2816             :   }
    2817             : 
    2818        1255 :   if (AllSame && ToC->isNullValue())
    2819           3 :     return ConstantAggregateZero::get(getType());
    2820             : 
    2821        1311 :   if (AllSame && isa<UndefValue>(ToC))
    2822           0 :     return UndefValue::get(getType());
    2823             : 
    2824             :   // Check for any other type of constant-folding.
    2825        1252 :   if (Constant *C = getImpl(getType(), Values))
    2826             :     return C;
    2827             : 
    2828             :   // Update to the new value.
    2829        2502 :   return getContext().pImpl->ArrayConstants.replaceOperandsInPlace(
    2830        1251 :       Values, this, From, ToC, NumUpdated, OperandNo);
    2831             : }
    2832             : 
    2833          53 : Value *ConstantStruct::handleOperandChangeImpl(Value *From, Value *To) {
    2834             :   assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
    2835             :   Constant *ToC = cast<Constant>(To);
    2836             : 
    2837          53 :   Use *OperandList = getOperandList();
    2838             : 
    2839             :   SmallVector<Constant*, 8> Values;
    2840          53 :   Values.reserve(getNumOperands());  // Build replacement struct.
    2841             : 
    2842             :   // Fill values with the modified operands of the constant struct.  Also,
    2843             :   // compute whether this turns into an all-zeros struct.
    2844             :   unsigned NumUpdated = 0;
    2845             :   bool AllSame = true;
    2846             :   unsigned OperandNo = 0;
    2847         273 :   for (Use *O = OperandList, *E = OperandList + getNumOperands(); O != E; ++O) {
    2848         220 :     Constant *Val = cast<Constant>(O->get());
    2849         220 :     if (Val == From) {
    2850          62 :       OperandNo = (O - OperandList);
    2851          62 :       Val = ToC;
    2852          62 :       ++NumUpdated;
    2853             :     }
    2854         220 :     Values.push_back(Val);
    2855         220 :     AllSame &= Val == ToC;
    2856             :   }
    2857             : 
    2858          53 :   if (AllSame && ToC->isNullValue())
    2859           0 :     return ConstantAggregateZero::get(getType());
    2860             : 
    2861          60 :   if (AllSame && isa<UndefValue>(ToC))
    2862           0 :     return UndefValue::get(getType());
    2863             : 
    2864             :   // Update to the new value.
    2865         106 :   return getContext().pImpl->StructConstants.replaceOperandsInPlace(
    2866          53 :       Values, this, From, ToC, NumUpdated, OperandNo);
    2867             : }
    2868             : 
    2869           0 : Value *ConstantVector::handleOperandChangeImpl(Value *From, Value *To) {
    2870             :   assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
    2871             :   Constant *ToC = cast<Constant>(To);
    2872             : 
    2873             :   SmallVector<Constant*, 8> Values;
    2874           0 :   Values.reserve(getNumOperands());  // Build replacement array...
    2875             :   unsigned NumUpdated = 0;
    2876             :   unsigned OperandNo = 0;
    2877           0 :   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
    2878           0 :     Constant *Val = getOperand(i);
    2879           0 :     if (Val == From) {
    2880             :       OperandNo = i;
    2881           0 :       ++NumUpdated;
    2882           0 :       Val = ToC;
    2883             :     }
    2884           0 :     Values.push_back(Val);
    2885             :   }
    2886             : 
    2887           0 :   if (Constant *C = getImpl(Values))
    2888             :     return C;
    2889             : 
    2890             :   // Update to the new value.
    2891           0 :   return getContext().pImpl->VectorConstants.replaceOperandsInPlace(
    2892           0 :       Values, this, From, ToC, NumUpdated, OperandNo);
    2893             : }
    2894             : 
    2895        2495 : Value *ConstantExpr::handleOperandChangeImpl(Value *From, Value *ToV) {
    2896             :   assert(isa<Constant>(ToV) && "Cannot make Constant refer to non-constant!");
    2897             :   Constant *To = cast<Constant>(ToV);
    2898             : 
    2899             :   SmallVector<Constant*, 8> NewOps;
    2900             :   unsigned NumUpdated = 0;
    2901             :   unsigned OperandNo = 0;
    2902        8677 :   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
    2903        3091 :     Constant *Op = getOperand(i);
    2904        3091 :     if (Op == From) {
    2905             :       OperandNo = i;
    2906        2498 :       ++NumUpdated;
    2907        2498 :       Op = To;
    2908             :     }
    2909        3091 :     NewOps.push_back(Op);
    2910             :   }
    2911             :   assert(NumUpdated && "I didn't contain From!");
    2912             : 
    2913        4990 :   if (Constant *C = getWithOperands(NewOps, getType(), true))
    2914             :     return C;
    2915             : 
    2916             :   // Update to the new value.
    2917        2352 :   return getContext().pImpl->ExprConstants.replaceOperandsInPlace(
    2918        1176 :       NewOps, this, From, To, NumUpdated, OperandNo);
    2919             : }
    2920             : 
    2921         144 : Instruction *ConstantExpr::getAsInstruction() {
    2922             :   SmallVector<Value *, 4> ValueOperands(op_begin(), op_end());
    2923             :   ArrayRef<Value*> Ops(ValueOperands);
    2924             : 
    2925         144 :   switch (getOpcode()) {
    2926             :   case Instruction::Trunc:
    2927             :   case Instruction::ZExt:
    2928             :   case Instruction::SExt:
    2929             :   case Instruction::FPTrunc:
    2930             :   case Instruction::FPExt:
    2931             :   case Instruction::UIToFP:
    2932             :   case Instruction::SIToFP:
    2933             :   case Instruction::FPToUI:
    2934             :   case Instruction::FPToSI:
    2935             :   case Instruction::PtrToInt:
    2936             :   case Instruction::IntToPtr:
    2937             :   case Instruction::BitCast:
    2938             :   case Instruction::AddrSpaceCast:
    2939         222 :     return CastInst::Create((Instruction::CastOps)getOpcode(),
    2940         111 :                             Ops[0], getType());
    2941             :   case Instruction::Select:
    2942           2 :     return SelectInst::Create(Ops[0], Ops[1], Ops[2]);
    2943             :   case Instruction::InsertElement:
    2944           0 :     return InsertElementInst::Create(Ops[0], Ops[1], Ops[2]);
    2945             :   case Instruction::ExtractElement:
    2946           2 :     return ExtractElementInst::Create(Ops[0], Ops[1]);
    2947             :   case Instruction::InsertValue:
    2948           0 :     return InsertValueInst::Create(Ops[0], Ops[1], getIndices());
    2949             :   case Instruction::ExtractValue:
    2950           0 :     return ExtractValueInst::Create(Ops[0], getIndices());
    2951           0 :   case Instruction::ShuffleVector:
    2952           0 :     return new ShuffleVectorInst(Ops[0], Ops[1], Ops[2]);
    2953             : 
    2954             :   case Instruction::GetElementPtr: {
    2955             :     const auto *GO = cast<GEPOperator>(this);
    2956           1 :     if (GO->isInBounds())
    2957           2 :       return GetElementPtrInst::CreateInBounds(GO->getSourceElementType(),
    2958             :                                                Ops[0], Ops.slice(1));
    2959           0 :     return GetElementPtrInst::Create(GO->getSourceElementType(), Ops[0],
    2960           0 :                                      Ops.slice(1));
    2961             :   }
    2962             :   case Instruction::ICmp:
    2963             :   case Instruction::FCmp:
    2964           4 :     return CmpInst::Create((Instruction::OtherOps)getOpcode(),
    2965           4 :                            (CmpInst::Predicate)getPredicate(), Ops[0], Ops[1]);
    2966             : 
    2967             :   default:
    2968             :     assert(getNumOperands() == 2 && "Must be binary operator?");
    2969             :     BinaryOperator *BO =
    2970          28 :       BinaryOperator::Create((Instruction::BinaryOps)getOpcode(),
    2971             :                              Ops[0], Ops[1]);
    2972             :     if (isa<OverflowingBinaryOperator>(BO)) {
    2973           9 :       BO->setHasNoUnsignedWrap(SubclassOptionalData &
    2974             :                                OverflowingBinaryOperator::NoUnsignedWrap);
    2975           9 :       BO->setHasNoSignedWrap(SubclassOptionalData &
    2976             :                              OverflowingBinaryOperator::NoSignedWrap);
    2977             :     }
    2978             :     if (isa<PossiblyExactOperator>(BO))
    2979           7 :       BO->setIsExact(SubclassOptionalData & PossiblyExactOperator::IsExact);
    2980             :     return BO;
    2981             :   }
    2982             : }

Generated by: LCOV version 1.13