lib/VMCore/Constants.cpp

   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/Constants.h"
  15 #include "LLVMContextImpl.h"
  16 #include "ConstantFold.h"
  17 #include "llvm/DerivedTypes.h"
  18 #include "llvm/GlobalValue.h"
  19 #include "llvm/Instructions.h"
  20 #include "llvm/Module.h"
  21 #include "llvm/Operator.h"
  22 #include "llvm/ADT/FoldingSet.h"
  23 #include "llvm/ADT/StringExtras.h"
  24 #include "llvm/ADT/StringMap.h"
  25 #include "llvm/Support/Compiler.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 "llvm/Support/GetElementPtrTypeIterator.h"
  32 #include "llvm/ADT/DenseMap.h"
  33 #include "llvm/ADT/SmallVector.h"
  34 #include "llvm/ADT/STLExtras.h"
  35 #include <algorithm>
  36 #include <cstdarg>
  37 using namespace llvm;
  38
  39 //===----------------------------------------------------------------------===//
  40 //                              Constant Class
  41 //===----------------------------------------------------------------------===//
  42
  43 bool Constant::isNegativeZeroValue() const {
  44   // Floating point values have an explicit -0.0 value.
  45   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
  46     return CFP->isZero() && CFP->isNegative();
  47
  48   // Otherwise, just use +0.0.
  49   return isNullValue();
  50 }
  51
  52 bool Constant::isNullValue() const {
  53   // 0 is null.
  54   if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
  55     return CI->isZero();
  56
  57   // +0.0 is null.
  58   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
  59     return CFP->isZero() && !CFP->isNegative();
  60
  61   // constant zero is zero for aggregates and cpnull is null for pointers.
  62   return isa<ConstantAggregateZero>(this) || isa<ConstantPointerNull>(this);
  63 }
  64
  65 bool Constant::isAllOnesValue() const {
  66   // Check for -1 integers
  67   if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
  68     return CI->isMinusOne();
  69
  70   // Check for FP which are bitcasted from -1 integers
  71   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
  72     return CFP->getValueAPF().bitcastToAPInt().isAllOnesValue();
  73
  74   // Check for constant vectors
  75   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
  76     return CV->isAllOnesValue();
  77
  78   return false;
  79 }
  80 // Constructor to create a '0' constant of arbitrary type...
  81 Constant *Constant::getNullValue(Type *Ty) {
  82   switch (Ty->getTypeID()) {
  83   case Type::IntegerTyID:
  84     return ConstantInt::get(Ty, 0);
  85   case Type::FloatTyID:
  86     return ConstantFP::get(Ty->getContext(),
  87                            APFloat::getZero(APFloat::IEEEsingle));
  88   case Type::DoubleTyID:
  89     return ConstantFP::get(Ty->getContext(),
  90                            APFloat::getZero(APFloat::IEEEdouble));
  91   case Type::X86_FP80TyID:
  92     return ConstantFP::get(Ty->getContext(),
  93                            APFloat::getZero(APFloat::x87DoubleExtended));
  94   case Type::FP128TyID:
  95     return ConstantFP::get(Ty->getContext(),
  96                            APFloat::getZero(APFloat::IEEEquad));
  97   case Type::PPC_FP128TyID:
  98     return ConstantFP::get(Ty->getContext(),
  99                            APFloat(APInt::getNullValue(128)));
 100   case Type::PointerTyID:
 101     return ConstantPointerNull::get(cast<PointerType>(Ty));
 102   case Type::StructTyID:
 103   case Type::ArrayTyID:
 104   case Type::VectorTyID:
 105     return ConstantAggregateZero::get(Ty);
 106   default:
 107     // Function, Label, or Opaque type?
 108     assert(0 && "Cannot create a null constant of that type!");
 109     return 0;
 110   }
 111 }
 112
 113 Constant *Constant::getIntegerValue(Type *Ty, const APInt &V) {
 114   Type *ScalarTy = Ty->getScalarType();
 115
 116   // Create the base integer constant.
 117   Constant *C = ConstantInt::get(Ty->getContext(), V);
 118
 119   // Convert an integer to a pointer, if necessary.
 120   if (PointerType *PTy = dyn_cast<PointerType>(ScalarTy))
 121     C = ConstantExpr::getIntToPtr(C, PTy);
 122
 123   // Broadcast a scalar to a vector, if necessary.
 124   if (VectorType *VTy = dyn_cast<VectorType>(Ty))
 125     C = ConstantVector::get(std::vector<Constant *>(VTy->getNumElements(), C));
 126
 127   return C;
 128 }
 129
 130 Constant *Constant::getAllOnesValue(Type *Ty) {
 131   if (IntegerType *ITy = dyn_cast<IntegerType>(Ty))
 132     return ConstantInt::get(Ty->getContext(),
 133                             APInt::getAllOnesValue(ITy->getBitWidth()));
 134
 135   if (Ty->isFloatingPointTy()) {
 136     APFloat FL = APFloat::getAllOnesValue(Ty->getPrimitiveSizeInBits(),
 137                                           !Ty->isPPC_FP128Ty());
 138     return ConstantFP::get(Ty->getContext(), FL);
 139   }
 140
 141   SmallVector<Constant*, 16> Elts;
 142   VectorType *VTy = cast<VectorType>(Ty);
 143   Elts.resize(VTy->getNumElements(), getAllOnesValue(VTy->getElementType()));
 144   assert(Elts[0] && "Invalid AllOnes value!");
 145   return cast<ConstantVector>(ConstantVector::get(Elts));
 146 }
 147
 148 void Constant::destroyConstantImpl() {
 149   // When a Constant is destroyed, there may be lingering
 150   // references to the constant by other constants in the constant pool.  These
 151   // constants are implicitly dependent on the module that is being deleted,
 152   // but they don't know that.  Because we only find out when the CPV is
 153   // deleted, we must now notify all of our users (that should only be
 154   // Constants) that they are, in fact, invalid now and should be deleted.
 155   //
 156   while (!use_empty()) {
 157     Value *V = use_back();
 158 #ifndef NDEBUG      // Only in -g mode...
 159     if (!isa<Constant>(V)) {
 160       dbgs() << "While deleting: " << *this
 161              << "\n\nUse still stuck around after Def is destroyed: "
 162              << *V << "\n\n";
 163     }
 164 #endif
 165     assert(isa<Constant>(V) && "References remain to Constant being destroyed");
 166     Constant *CV = cast<Constant>(V);
 167     CV->destroyConstant();
 168
 169     // The constant should remove itself from our use list...
 170     assert((use_empty() || use_back() != V) && "Constant not removed!");
 171   }
 172
 173   // Value has no outstanding references it is safe to delete it now...
 174   delete this;
 175 }
 176
 177 /// canTrap - Return true if evaluation of this constant could trap.  This is
 178 /// true for things like constant expressions that could divide by zero.
 179 bool Constant::canTrap() const {
 180   assert(getType()->isFirstClassType() && "Cannot evaluate aggregate vals!");
 181   // The only thing that could possibly trap are constant exprs.
 182   const ConstantExpr *CE = dyn_cast<ConstantExpr>(this);
 183   if (!CE) return false;
 184
 185   // ConstantExpr traps if any operands can trap.
 186   for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
 187     if (CE->getOperand(i)->canTrap())
 188       return true;
 189
 190   // Otherwise, only specific operations can trap.
 191   switch (CE->getOpcode()) {
 192   default:
 193     return false;
 194   case Instruction::UDiv:
 195   case Instruction::SDiv:
 196   case Instruction::FDiv:
 197   case Instruction::URem:
 198   case Instruction::SRem:
 199   case Instruction::FRem:
 200     // Div and rem can trap if the RHS is not known to be non-zero.
 201     if (!isa<ConstantInt>(CE->getOperand(1)) ||CE->getOperand(1)->isNullValue())
 202       return true;
 203     return false;
 204   }
 205 }
 206
 207 /// isConstantUsed - Return true if the constant has users other than constant
 208 /// exprs and other dangling things.
 209 bool Constant::isConstantUsed() const {
 210   for (const_use_iterator UI = use_begin(), E = use_end(); UI != E; ++UI) {
 211     const Constant *UC = dyn_cast<Constant>(*UI);
 212     if (UC == 0 || isa<GlobalValue>(UC))
 213       return true;
 214
 215     if (UC->isConstantUsed())
 216       return true;
 217   }
 218   return false;
 219 }
 220
 221
 222
 223 /// getRelocationInfo - This method classifies the entry according to
 224 /// whether or not it may generate a relocation entry.  This must be
 225 /// conservative, so if it might codegen to a relocatable entry, it should say
 226 /// so.  The return values are:
 227 ///
 228 ///  NoRelocation: This constant pool entry is guaranteed to never have a
 229 ///     relocation applied to it (because it holds a simple constant like
 230 ///     '4').
 231 ///  LocalRelocation: This entry has relocations, but the entries are
 232 ///     guaranteed to be resolvable by the static linker, so the dynamic
 233 ///     linker will never see them.
 234 ///  GlobalRelocations: This entry may have arbitrary relocations.
 235 ///
 236 /// FIXME: This really should not be in VMCore.
 237 Constant::PossibleRelocationsTy Constant::getRelocationInfo() const {
 238   if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
 239     if (GV->hasLocalLinkage() || GV->hasHiddenVisibility())
 240       return LocalRelocation;  // Local to this file/library.
 241     return GlobalRelocations;    // Global reference.
 242   }
 243
 244   if (const BlockAddress *BA = dyn_cast<BlockAddress>(this))
 245     return BA->getFunction()->getRelocationInfo();
 246
 247   // While raw uses of blockaddress need to be relocated, differences between
 248   // two of them don't when they are for labels in the same function.  This is a
 249   // common idiom when creating a table for the indirect goto extension, so we
 250   // handle it efficiently here.
 251   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(this))
 252     if (CE->getOpcode() == Instruction::Sub) {
 253       ConstantExpr *LHS = dyn_cast<ConstantExpr>(CE->getOperand(0));
 254       ConstantExpr *RHS = dyn_cast<ConstantExpr>(CE->getOperand(1));
 255       if (LHS && RHS &&
 256           LHS->getOpcode() == Instruction::PtrToInt &&
 257           RHS->getOpcode() == Instruction::PtrToInt &&
 258           isa<BlockAddress>(LHS->getOperand(0)) &&
 259           isa<BlockAddress>(RHS->getOperand(0)) &&
 260           cast<BlockAddress>(LHS->getOperand(0))->getFunction() ==
 261             cast<BlockAddress>(RHS->getOperand(0))->getFunction())
 262         return NoRelocation;
 263     }
 264
 265   PossibleRelocationsTy Result = NoRelocation;
 266   for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
 267     Result = std::max(Result,
 268                       cast<Constant>(getOperand(i))->getRelocationInfo());
 269
 270   return Result;
 271 }
 272
 273
 274 /// getVectorElements - This method, which is only valid on constant of vector
 275 /// type, returns the elements of the vector in the specified smallvector.
 276 /// This handles breaking down a vector undef into undef elements, etc.  For
 277 /// constant exprs and other cases we can't handle, we return an empty vector.
 278 void Constant::getVectorElements(SmallVectorImpl<Constant*> &Elts) const {
 279   assert(getType()->isVectorTy() && "Not a vector constant!");
 280
 281   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this)) {
 282     for (unsigned i = 0, e = CV->getNumOperands(); i != e; ++i)
 283       Elts.push_back(CV->getOperand(i));
 284     return;
 285   }
 286
 287   VectorType *VT = cast<VectorType>(getType());
 288   if (isa<ConstantAggregateZero>(this)) {
 289     Elts.assign(VT->getNumElements(),
 290                 Constant::getNullValue(VT->getElementType()));
 291     return;
 292   }
 293
 294   if (isa<UndefValue>(this)) {
 295     Elts.assign(VT->getNumElements(), UndefValue::get(VT->getElementType()));
 296     return;
 297   }
 298
 299   // Unknown type, must be constant expr etc.
 300 }
 301
 302
 303 /// removeDeadUsersOfConstant - If the specified constantexpr is dead, remove
 304 /// it.  This involves recursively eliminating any dead users of the
 305 /// constantexpr.
 306 static bool removeDeadUsersOfConstant(const Constant *C) {
 307   if (isa<GlobalValue>(C)) return false; // Cannot remove this
 308
 309   while (!C->use_empty()) {
 310     const Constant *User = dyn_cast<Constant>(C->use_back());
 311     if (!User) return false; // Non-constant usage;
 312     if (!removeDeadUsersOfConstant(User))
 313       return false; // Constant wasn't dead
 314   }
 315
 316   const_cast<Constant*>(C)->destroyConstant();
 317   return true;
 318 }
 319
 320
 321 /// removeDeadConstantUsers - If there are any dead constant users dangling
 322 /// off of this constant, remove them.  This method is useful for clients
 323 /// that want to check to see if a global is unused, but don't want to deal
 324 /// with potentially dead constants hanging off of the globals.
 325 void Constant::removeDeadConstantUsers() const {
 326   Value::const_use_iterator I = use_begin(), E = use_end();
 327   Value::const_use_iterator LastNonDeadUser = E;
 328   while (I != E) {
 329     const Constant *User = dyn_cast<Constant>(*I);
 330     if (User == 0) {
 331       LastNonDeadUser = I;
 332       ++I;
 333       continue;
 334     }
 335
 336     if (!removeDeadUsersOfConstant(User)) {
 337       // If the constant wasn't dead, remember that this was the last live use
 338       // and move on to the next constant.
 339       LastNonDeadUser = I;
 340       ++I;
 341       continue;
 342     }
 343
 344     // If the constant was dead, then the iterator is invalidated.
 345     if (LastNonDeadUser == E) {
 346       I = use_begin();
 347       if (I == E) break;
 348     } else {
 349       I = LastNonDeadUser;
 350       ++I;
 351     }
 352   }
 353 }
 354
 355
 356
 357 //===----------------------------------------------------------------------===//
 358 //                                ConstantInt
 359 //===----------------------------------------------------------------------===//
 360
 361 ConstantInt::ConstantInt(IntegerType *Ty, const APInt& V)
 362   : Constant(Ty, ConstantIntVal, 0, 0), Val(V) {
 363   assert(V.getBitWidth() == Ty->getBitWidth() && "Invalid constant for type");
 364 }
 365
 366 ConstantInt *ConstantInt::getTrue(LLVMContext &Context) {
 367   LLVMContextImpl *pImpl = Context.pImpl;
 368   if (!pImpl->TheTrueVal)
 369     pImpl->TheTrueVal = ConstantInt::get(Type::getInt1Ty(Context), 1);
 370   return pImpl->TheTrueVal;
 371 }
 372
 373 ConstantInt *ConstantInt::getFalse(LLVMContext &Context) {
 374   LLVMContextImpl *pImpl = Context.pImpl;
 375   if (!pImpl->TheFalseVal)
 376     pImpl->TheFalseVal = ConstantInt::get(Type::getInt1Ty(Context), 0);
 377   return pImpl->TheFalseVal;
 378 }
 379
 380 Constant *ConstantInt::getTrue(Type *Ty) {
 381   VectorType *VTy = dyn_cast<VectorType>(Ty);
 382   if (!VTy) {
 383     assert(Ty->isIntegerTy(1) && "True must be i1 or vector of i1.");
 384     return ConstantInt::getTrue(Ty->getContext());
 385   }
 386   assert(VTy->getElementType()->isIntegerTy(1) &&
 387          "True must be vector of i1 or i1.");
 388   SmallVector<Constant*, 16> Splat(VTy->getNumElements(),
 389                                    ConstantInt::getTrue(Ty->getContext()));
 390   return ConstantVector::get(Splat);
 391 }
 392
 393 Constant *ConstantInt::getFalse(Type *Ty) {
 394   VectorType *VTy = dyn_cast<VectorType>(Ty);
 395   if (!VTy) {
 396     assert(Ty->isIntegerTy(1) && "False must be i1 or vector of i1.");
 397     return ConstantInt::getFalse(Ty->getContext());
 398   }
 399   assert(VTy->getElementType()->isIntegerTy(1) &&
 400          "False must be vector of i1 or i1.");
 401   SmallVector<Constant*, 16> Splat(VTy->getNumElements(),
 402                                    ConstantInt::getFalse(Ty->getContext()));
 403   return ConstantVector::get(Splat);
 404 }
 405
 406
 407 // Get a ConstantInt from an APInt. Note that the value stored in the DenseMap
 408 // as the key, is a DenseMapAPIntKeyInfo::KeyTy which has provided the
 409 // operator== and operator!= to ensure that the DenseMap doesn't attempt to
 410 // compare APInt's of different widths, which would violate an APInt class
 411 // invariant which generates an assertion.
 412 ConstantInt *ConstantInt::get(LLVMContext &Context, const APInt &V) {
 413   // Get the corresponding integer type for the bit width of the value.
 414   IntegerType *ITy = IntegerType::get(Context, V.getBitWidth());
 415   // get an existing value or the insertion position
 416   DenseMapAPIntKeyInfo::KeyTy Key(V, ITy);
 417   ConstantInt *&Slot = Context.pImpl->IntConstants[Key];
 418   if (!Slot) Slot = new ConstantInt(ITy, V);
 419   return Slot;
 420 }
 421
 422 Constant *ConstantInt::get(Type *Ty, uint64_t V, bool isSigned) {
 423   Constant *C = get(cast<IntegerType>(Ty->getScalarType()), V, isSigned);
 424
 425   // For vectors, broadcast the value.
 426   if (VectorType *VTy = dyn_cast<VectorType>(Ty))
 427     return ConstantVector::get(SmallVector<Constant*,
 428                                            16>(VTy->getNumElements(), C));
 429
 430   return C;
 431 }
 432
 433 ConstantInt* ConstantInt::get(IntegerType* Ty, uint64_t V,
 434                               bool isSigned) {
 435   return get(Ty->getContext(), APInt(Ty->getBitWidth(), V, isSigned));
 436 }
 437
 438 ConstantInt* ConstantInt::getSigned(IntegerType* Ty, int64_t V) {
 439   return get(Ty, V, true);
 440 }
 441
 442 Constant *ConstantInt::getSigned(Type *Ty, int64_t V) {
 443   return get(Ty, V, true);
 444 }
 445
 446 Constant *ConstantInt::get(Type* Ty, const APInt& V) {
 447   ConstantInt *C = get(Ty->getContext(), V);
 448   assert(C->getType() == Ty->getScalarType() &&
 449          "ConstantInt type doesn't match the type implied by its value!");
 450
 451   // For vectors, broadcast the value.
 452   if (VectorType *VTy = dyn_cast<VectorType>(Ty))
 453     return ConstantVector::get(
 454       SmallVector<Constant *, 16>(VTy->getNumElements(), C));
 455
 456   return C;
 457 }
 458
 459 ConstantInt* ConstantInt::get(IntegerType* Ty, StringRef Str,
 460                               uint8_t radix) {
 461   return get(Ty->getContext(), APInt(Ty->getBitWidth(), Str, radix));
 462 }
 463
 464 //===----------------------------------------------------------------------===//
 465 //                                ConstantFP
 466 //===----------------------------------------------------------------------===//
 467
 468 static const fltSemantics *TypeToFloatSemantics(Type *Ty) {
 469   if (Ty->isFloatTy())
 470     return &APFloat::IEEEsingle;
 471   if (Ty->isDoubleTy())
 472     return &APFloat::IEEEdouble;
 473   if (Ty->isX86_FP80Ty())
 474     return &APFloat::x87DoubleExtended;
 475   else if (Ty->isFP128Ty())
 476     return &APFloat::IEEEquad;
 477
 478   assert(Ty->isPPC_FP128Ty() && "Unknown FP format");
 479   return &APFloat::PPCDoubleDouble;
 480 }
 481
 482 /// get() - This returns a constant fp for the specified value in the
 483 /// specified type.  This should only be used for simple constant values like
 484 /// 2.0/1.0 etc, that are known-valid both as double and as the target format.
 485 Constant *ConstantFP::get(Type* Ty, double V) {
 486   LLVMContext &Context = Ty->getContext();
 487
 488   APFloat FV(V);
 489   bool ignored;
 490   FV.convert(*TypeToFloatSemantics(Ty->getScalarType()),
 491              APFloat::rmNearestTiesToEven, &ignored);
 492   Constant *C = get(Context, FV);
 493
 494   // For vectors, broadcast the value.
 495   if (VectorType *VTy = dyn_cast<VectorType>(Ty))
 496     return ConstantVector::get(
 497       SmallVector<Constant *, 16>(VTy->getNumElements(), C));
 498
 499   return C;
 500 }
 501
 502
 503 Constant *ConstantFP::get(Type* Ty, StringRef Str) {
 504   LLVMContext &Context = Ty->getContext();
 505
 506   APFloat FV(*TypeToFloatSemantics(Ty->getScalarType()), Str);
 507   Constant *C = get(Context, FV);
 508
 509   // For vectors, broadcast the value.
 510   if (VectorType *VTy = dyn_cast<VectorType>(Ty))
 511     return ConstantVector::get(
 512       SmallVector<Constant *, 16>(VTy->getNumElements(), C));
 513
 514   return C;
 515 }
 516
 517
 518 ConstantFP* ConstantFP::getNegativeZero(Type* Ty) {
 519   LLVMContext &Context = Ty->getContext();
 520   APFloat apf = cast <ConstantFP>(Constant::getNullValue(Ty))->getValueAPF();
 521   apf.changeSign();
 522   return get(Context, apf);
 523 }
 524
 525
 526 Constant *ConstantFP::getZeroValueForNegation(Type* Ty) {
 527   if (VectorType *PTy = dyn_cast<VectorType>(Ty))
 528     if (PTy->getElementType()->isFloatingPointTy()) {
 529       SmallVector<Constant*, 16> zeros(PTy->getNumElements(),
 530                            getNegativeZero(PTy->getElementType()));
 531       return ConstantVector::get(zeros);
 532     }
 533
 534   if (Ty->isFloatingPointTy())
 535     return getNegativeZero(Ty);
 536
 537   return Constant::getNullValue(Ty);
 538 }
 539
 540
 541 // ConstantFP accessors.
 542 ConstantFP* ConstantFP::get(LLVMContext &Context, const APFloat& V) {
 543   DenseMapAPFloatKeyInfo::KeyTy Key(V);
 544
 545   LLVMContextImpl* pImpl = Context.pImpl;
 546
 547   ConstantFP *&Slot = pImpl->FPConstants[Key];
 548
 549   if (!Slot) {
 550     Type *Ty;
 551     if (&V.getSemantics() == &APFloat::IEEEsingle)
 552       Ty = Type::getFloatTy(Context);
 553     else if (&V.getSemantics() == &APFloat::IEEEdouble)
 554       Ty = Type::getDoubleTy(Context);
 555     else if (&V.getSemantics() == &APFloat::x87DoubleExtended)
 556       Ty = Type::getX86_FP80Ty(Context);
 557     else if (&V.getSemantics() == &APFloat::IEEEquad)
 558       Ty = Type::getFP128Ty(Context);
 559     else {
 560       assert(&V.getSemantics() == &APFloat::PPCDoubleDouble &&
 561              "Unknown FP format");
 562       Ty = Type::getPPC_FP128Ty(Context);
 563     }
 564     Slot = new ConstantFP(Ty, V);
 565   }
 566
 567   return Slot;
 568 }
 569
 570 ConstantFP *ConstantFP::getInfinity(Type *Ty, bool Negative) {
 571   const fltSemantics &Semantics = *TypeToFloatSemantics(Ty);
 572   return ConstantFP::get(Ty->getContext(),
 573                          APFloat::getInf(Semantics, Negative));
 574 }
 575
 576 ConstantFP::ConstantFP(Type *Ty, const APFloat& V)
 577   : Constant(Ty, ConstantFPVal, 0, 0), Val(V) {
 578   assert(&V.getSemantics() == TypeToFloatSemantics(Ty) &&
 579          "FP type Mismatch");
 580 }
 581
 582 bool ConstantFP::isExactlyValue(const APFloat &V) const {
 583   return Val.bitwiseIsEqual(V);
 584 }
 585
 586 //===----------------------------------------------------------------------===//
 587 //                            ConstantXXX Classes
 588 //===----------------------------------------------------------------------===//
 589
 590
 591 ConstantArray::ConstantArray(ArrayType *T, ArrayRef<Constant *> V)
 592   : Constant(T, ConstantArrayVal,
 593              OperandTraits<ConstantArray>::op_end(this) - V.size(),
 594              V.size()) {
 595   assert(V.size() == T->getNumElements() &&
 596          "Invalid initializer vector for constant array");
 597   for (unsigned i = 0, e = V.size(); i != e; ++i)
 598     assert(V[i]->getType() == T->getElementType() &&
 599            "Initializer for array element doesn't match array element type!");
 600   std::copy(V.begin(), V.end(), op_begin());
 601 }
 602
 603 Constant *ConstantArray::get(ArrayType *Ty, ArrayRef<Constant*> V) {
 604   for (unsigned i = 0, e = V.size(); i != e; ++i) {
 605     assert(V[i]->getType() == Ty->getElementType() &&
 606            "Wrong type in array element initializer");
 607   }
 608   LLVMContextImpl *pImpl = Ty->getContext().pImpl;
 609   // If this is an all-zero array, return a ConstantAggregateZero object
 610   if (!V.empty()) {
 611     Constant *C = V[0];
 612     if (!C->isNullValue())
 613       return pImpl->ArrayConstants.getOrCreate(Ty, V);
 614
 615     for (unsigned i = 1, e = V.size(); i != e; ++i)
 616       if (V[i] != C)
 617         return pImpl->ArrayConstants.getOrCreate(Ty, V);
 618   }
 619
 620   return ConstantAggregateZero::get(Ty);
 621 }
 622
 623 /// ConstantArray::get(const string&) - Return an array that is initialized to
 624 /// contain the specified string.  If length is zero then a null terminator is
 625 /// added to the specified string so that it may be used in a natural way.
 626 /// Otherwise, the length parameter specifies how much of the string to use
 627 /// and it won't be null terminated.
 628 ///
 629 Constant *ConstantArray::get(LLVMContext &Context, StringRef Str,
 630                              bool AddNull) {
 631   std::vector<Constant*> ElementVals;
 632   ElementVals.reserve(Str.size() + size_t(AddNull));
 633   for (unsigned i = 0; i < Str.size(); ++i)
 634     ElementVals.push_back(ConstantInt::get(Type::getInt8Ty(Context), Str[i]));
 635
 636   // Add a null terminator to the string...
 637   if (AddNull) {
 638     ElementVals.push_back(ConstantInt::get(Type::getInt8Ty(Context), 0));
 639   }
 640
 641   ArrayType *ATy = ArrayType::get(Type::getInt8Ty(Context), ElementVals.size());
 642   return get(ATy, ElementVals);
 643 }
 644
 645 /// getTypeForElements - Return an anonymous struct type to use for a constant
 646 /// with the specified set of elements.  The list must not be empty.
 647 StructType *ConstantStruct::getTypeForElements(LLVMContext &Context,
 648                                                ArrayRef<Constant*> V,
 649                                                bool Packed) {
 650   SmallVector<Type*, 16> EltTypes;
 651   for (unsigned i = 0, e = V.size(); i != e; ++i)
 652     EltTypes.push_back(V[i]->getType());
 653
 654   return StructType::get(Context, EltTypes, Packed);
 655 }
 656
 657
 658 StructType *ConstantStruct::getTypeForElements(ArrayRef<Constant*> V,
 659                                                bool Packed) {
 660   assert(!V.empty() &&
 661          "ConstantStruct::getTypeForElements cannot be called on empty list");
 662   return getTypeForElements(V[0]->getContext(), V, Packed);
 663 }
 664
 665
 666 ConstantStruct::ConstantStruct(StructType *T, ArrayRef<Constant *> V)
 667   : Constant(T, ConstantStructVal,
 668              OperandTraits<ConstantStruct>::op_end(this) - V.size(),
 669              V.size()) {
 670   assert(V.size() == T->getNumElements() &&
 671          "Invalid initializer vector for constant structure");
 672   for (unsigned i = 0, e = V.size(); i != e; ++i)
 673     assert((T->isOpaque() || V[i]->getType() == T->getElementType(i)) &&
 674            "Initializer for struct element doesn't match struct element type!");
 675   std::copy(V.begin(), V.end(), op_begin());
 676 }
 677
 678 // ConstantStruct accessors.
 679 Constant *ConstantStruct::get(StructType *ST, ArrayRef<Constant*> V) {
 680   // Create a ConstantAggregateZero value if all elements are zeros.
 681   for (unsigned i = 0, e = V.size(); i != e; ++i)
 682     if (!V[i]->isNullValue())
 683       return ST->getContext().pImpl->StructConstants.getOrCreate(ST, V);
 684
 685   assert((ST->isOpaque() || ST->getNumElements() == V.size()) &&
 686          "Incorrect # elements specified to ConstantStruct::get");
 687   return ConstantAggregateZero::get(ST);
 688 }
 689
 690 Constant *ConstantStruct::get(StructType *T, ...) {
 691   va_list ap;
 692   SmallVector<Constant*, 8> Values;
 693   va_start(ap, T);
 694   while (Constant *Val = va_arg(ap, llvm::Constant*))
 695     Values.push_back(Val);
 696   va_end(ap);
 697   return get(T, Values);
 698 }
 699
 700 ConstantVector::ConstantVector(VectorType *T, ArrayRef<Constant *> V)
 701   : Constant(T, ConstantVectorVal,
 702              OperandTraits<ConstantVector>::op_end(this) - V.size(),
 703              V.size()) {
 704   for (size_t i = 0, e = V.size(); i != e; i++)
 705     assert(V[i]->getType() == T->getElementType() &&
 706            "Initializer for vector element doesn't match vector element type!");
 707   std::copy(V.begin(), V.end(), op_begin());
 708 }
 709
 710 // ConstantVector accessors.
 711 Constant *ConstantVector::get(ArrayRef<Constant*> V) {
 712   assert(!V.empty() && "Vectors can't be empty");
 713   VectorType *T = VectorType::get(V.front()->getType(), V.size());
 714   LLVMContextImpl *pImpl = T->getContext().pImpl;
 715
 716   // If this is an all-undef or all-zero vector, return a
 717   // ConstantAggregateZero or UndefValue.
 718   Constant *C = V[0];
 719   bool isZero = C->isNullValue();
 720   bool isUndef = isa<UndefValue>(C);
 721
 722   if (isZero || isUndef) {
 723     for (unsigned i = 1, e = V.size(); i != e; ++i)
 724       if (V[i] != C) {
 725         isZero = isUndef = false;
 726         break;
 727       }
 728   }
 729
 730   if (isZero)
 731     return ConstantAggregateZero::get(T);
 732   if (isUndef)
 733     return UndefValue::get(T);
 734
 735   return pImpl->VectorConstants.getOrCreate(T, V);
 736 }
 737
 738 // Utility function for determining if a ConstantExpr is a CastOp or not. This
 739 // can't be inline because we don't want to #include Instruction.h into
 740 // Constant.h
 741 bool ConstantExpr::isCast() const {
 742   return Instruction::isCast(getOpcode());
 743 }
 744
 745 bool ConstantExpr::isCompare() const {
 746   return getOpcode() == Instruction::ICmp || getOpcode() == Instruction::FCmp;
 747 }
 748
 749 bool ConstantExpr::isGEPWithNoNotionalOverIndexing() const {
 750   if (getOpcode() != Instruction::GetElementPtr) return false;
 751
 752   gep_type_iterator GEPI = gep_type_begin(this), E = gep_type_end(this);
 753   User::const_op_iterator OI = llvm::next(this->op_begin());
 754
 755   // Skip the first index, as it has no static limit.
 756   ++GEPI;
 757   ++OI;
 758
 759   // The remaining indices must be compile-time known integers within the
 760   // bounds of the corresponding notional static array types.
 761   for (; GEPI != E; ++GEPI, ++OI) {
 762     ConstantInt *CI = dyn_cast<ConstantInt>(*OI);
 763     if (!CI) return false;
 764     if (ArrayType *ATy = dyn_cast<ArrayType>(*GEPI))
 765       if (CI->getValue().getActiveBits() > 64 ||
 766           CI->getZExtValue() >= ATy->getNumElements())
 767         return false;
 768   }
 769
 770   // All the indices checked out.
 771   return true;
 772 }
 773
 774 bool ConstantExpr::hasIndices() const {
 775   return getOpcode() == Instruction::ExtractValue ||
 776          getOpcode() == Instruction::InsertValue;
 777 }
 778
 779 ArrayRef<unsigned> ConstantExpr::getIndices() const {
 780   if (const ExtractValueConstantExpr *EVCE =
 781         dyn_cast<ExtractValueConstantExpr>(this))
 782     return EVCE->Indices;
 783
 784   return cast<InsertValueConstantExpr>(this)->Indices;
 785 }
 786
 787 unsigned ConstantExpr::getPredicate() const {
 788   assert(isCompare());
 789   return ((const CompareConstantExpr*)this)->predicate;
 790 }
 791
 792 /// getWithOperandReplaced - Return a constant expression identical to this
 793 /// one, but with the specified operand set to the specified value.
 794 Constant *
 795 ConstantExpr::getWithOperandReplaced(unsigned OpNo, Constant *Op) const {
 796   assert(OpNo < getNumOperands() && "Operand num is out of range!");
 797   assert(Op->getType() == getOperand(OpNo)->getType() &&
 798          "Replacing operand with value of different type!");
 799   if (getOperand(OpNo) == Op)
 800     return const_cast<ConstantExpr*>(this);
 801
 802   Constant *Op0, *Op1, *Op2;
 803   switch (getOpcode()) {
 804   case Instruction::Trunc:
 805   case Instruction::ZExt:
 806   case Instruction::SExt:
 807   case Instruction::FPTrunc:
 808   case Instruction::FPExt:
 809   case Instruction::UIToFP:
 810   case Instruction::SIToFP:
 811   case Instruction::FPToUI:
 812   case Instruction::FPToSI:
 813   case Instruction::PtrToInt:
 814   case Instruction::IntToPtr:
 815   case Instruction::BitCast:
 816     return ConstantExpr::getCast(getOpcode(), Op, getType());
 817   case Instruction::Select:
 818     Op0 = (OpNo == 0) ? Op : getOperand(0);
 819     Op1 = (OpNo == 1) ? Op : getOperand(1);
 820     Op2 = (OpNo == 2) ? Op : getOperand(2);
 821     return ConstantExpr::getSelect(Op0, Op1, Op2);
 822   case Instruction::InsertElement:
 823     Op0 = (OpNo == 0) ? Op : getOperand(0);
 824     Op1 = (OpNo == 1) ? Op : getOperand(1);
 825     Op2 = (OpNo == 2) ? Op : getOperand(2);
 826     return ConstantExpr::getInsertElement(Op0, Op1, Op2);
 827   case Instruction::ExtractElement:
 828     Op0 = (OpNo == 0) ? Op : getOperand(0);
 829     Op1 = (OpNo == 1) ? Op : getOperand(1);
 830     return ConstantExpr::getExtractElement(Op0, Op1);
 831   case Instruction::ShuffleVector:
 832     Op0 = (OpNo == 0) ? Op : getOperand(0);
 833     Op1 = (OpNo == 1) ? Op : getOperand(1);
 834     Op2 = (OpNo == 2) ? Op : getOperand(2);
 835     return ConstantExpr::getShuffleVector(Op0, Op1, Op2);
 836   case Instruction::GetElementPtr: {
 837     SmallVector<Constant*, 8> Ops;
 838     Ops.resize(getNumOperands()-1);
 839     for (unsigned i = 1, e = getNumOperands(); i != e; ++i)
 840       Ops[i-1] = getOperand(i);
 841     if (OpNo == 0)
 842       return
 843         ConstantExpr::getGetElementPtr(Op, Ops,
 844                                        cast<GEPOperator>(this)->isInBounds());
 845     Ops[OpNo-1] = Op;
 846     return
 847       ConstantExpr::getGetElementPtr(getOperand(0), Ops,
 848                                      cast<GEPOperator>(this)->isInBounds());
 849   }
 850   default:
 851     assert(getNumOperands() == 2 && "Must be binary operator?");
 852     Op0 = (OpNo == 0) ? Op : getOperand(0);
 853     Op1 = (OpNo == 1) ? Op : getOperand(1);
 854     return ConstantExpr::get(getOpcode(), Op0, Op1, SubclassOptionalData);
 855   }
 856 }
 857
 858 /// getWithOperands - This returns the current constant expression with the
 859 /// operands replaced with the specified values.  The specified array must
 860 /// have the same number of operands as our current one.
 861 Constant *ConstantExpr::
 862 getWithOperands(ArrayRef<Constant*> Ops, Type *Ty) const {
 863   assert(Ops.size() == getNumOperands() && "Operand count mismatch!");
 864   bool AnyChange = Ty != getType();
 865   for (unsigned i = 0; i != Ops.size(); ++i)
 866     AnyChange |= Ops[i] != getOperand(i);
 867
 868   if (!AnyChange)  // No operands changed, return self.
 869     return const_cast<ConstantExpr*>(this);
 870
 871   switch (getOpcode()) {
 872   case Instruction::Trunc:
 873   case Instruction::ZExt:
 874   case Instruction::SExt:
 875   case Instruction::FPTrunc:
 876   case Instruction::FPExt:
 877   case Instruction::UIToFP:
 878   case Instruction::SIToFP:
 879   case Instruction::FPToUI:
 880   case Instruction::FPToSI:
 881   case Instruction::PtrToInt:
 882   case Instruction::IntToPtr:
 883   case Instruction::BitCast:
 884     return ConstantExpr::getCast(getOpcode(), Ops[0], Ty);
 885   case Instruction::Select:
 886     return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2]);
 887   case Instruction::InsertElement:
 888     return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2]);
 889   case Instruction::ExtractElement:
 890     return ConstantExpr::getExtractElement(Ops[0], Ops[1]);
 891   case Instruction::ShuffleVector:
 892     return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]);
 893   case Instruction::GetElementPtr:
 894     return
 895       ConstantExpr::getGetElementPtr(Ops[0], Ops.slice(1),
 896                                      cast<GEPOperator>(this)->isInBounds());
 897   case Instruction::ICmp:
 898   case Instruction::FCmp:
 899     return ConstantExpr::getCompare(getPredicate(), Ops[0], Ops[1]);
 900   default:
 901     assert(getNumOperands() == 2 && "Must be binary operator?");
 902     return ConstantExpr::get(getOpcode(), Ops[0], Ops[1], SubclassOptionalData);
 903   }
 904 }
 905
 906
 907 //===----------------------------------------------------------------------===//
 908 //                      isValueValidForType implementations
 909
 910 bool ConstantInt::isValueValidForType(Type *Ty, uint64_t Val) {
 911   unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth(); // assert okay
 912   if (Ty == Type::getInt1Ty(Ty->getContext()))
 913     return Val == 0 || Val == 1;
 914   if (NumBits >= 64)
 915     return true; // always true, has to fit in largest type
 916   uint64_t Max = (1ll << NumBits) - 1;
 917   return Val <= Max;
 918 }
 919
 920 bool ConstantInt::isValueValidForType(Type *Ty, int64_t Val) {
 921   unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth(); // assert okay
 922   if (Ty == Type::getInt1Ty(Ty->getContext()))
 923     return Val == 0 || Val == 1 || Val == -1;
 924   if (NumBits >= 64)
 925     return true; // always true, has to fit in largest type
 926   int64_t Min = -(1ll << (NumBits-1));
 927   int64_t Max = (1ll << (NumBits-1)) - 1;
 928   return (Val >= Min && Val <= Max);
 929 }
 930
 931 bool ConstantFP::isValueValidForType(Type *Ty, const APFloat& Val) {
 932   // convert modifies in place, so make a copy.
 933   APFloat Val2 = APFloat(Val);
 934   bool losesInfo;
 935   switch (Ty->getTypeID()) {
 936   default:
 937     return false;         // These can't be represented as floating point!
 938
 939   // FIXME rounding mode needs to be more flexible
 940   case Type::FloatTyID: {
 941     if (&Val2.getSemantics() == &APFloat::IEEEsingle)
 942       return true;
 943     Val2.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo);
 944     return !losesInfo;
 945   }
 946   case Type::DoubleTyID: {
 947     if (&Val2.getSemantics() == &APFloat::IEEEsingle ||
 948         &Val2.getSemantics() == &APFloat::IEEEdouble)
 949       return true;
 950     Val2.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
 951     return !losesInfo;
 952   }
 953   case Type::X86_FP80TyID:
 954     return &Val2.getSemantics() == &APFloat::IEEEsingle ||
 955            &Val2.getSemantics() == &APFloat::IEEEdouble ||
 956            &Val2.getSemantics() == &APFloat::x87DoubleExtended;
 957   case Type::FP128TyID:
 958     return &Val2.getSemantics() == &APFloat::IEEEsingle ||
 959            &Val2.getSemantics() == &APFloat::IEEEdouble ||
 960            &Val2.getSemantics() == &APFloat::IEEEquad;
 961   case Type::PPC_FP128TyID:
 962     return &Val2.getSemantics() == &APFloat::IEEEsingle ||
 963            &Val2.getSemantics() == &APFloat::IEEEdouble ||
 964            &Val2.getSemantics() == &APFloat::PPCDoubleDouble;
 965   }
 966 }
 967
 968 //===----------------------------------------------------------------------===//
 969 //                      Factory Function Implementation
 970
 971 ConstantAggregateZero* ConstantAggregateZero::get(Type* Ty) {
 972   assert((Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()) &&
 973          "Cannot create an aggregate zero of non-aggregate type!");
 974
 975   LLVMContextImpl *pImpl = Ty->getContext().pImpl;
 976   return pImpl->AggZeroConstants.getOrCreate(Ty, 0);
 977 }
 978
 979 /// destroyConstant - Remove the constant from the constant table...
 980 ///
 981 void ConstantAggregateZero::destroyConstant() {
 982   getType()->getContext().pImpl->AggZeroConstants.remove(this);
 983   destroyConstantImpl();
 984 }
 985
 986 /// destroyConstant - Remove the constant from the constant table...
 987 ///
 988 void ConstantArray::destroyConstant() {
 989   getType()->getContext().pImpl->ArrayConstants.remove(this);
 990   destroyConstantImpl();
 991 }
 992
 993 /// isString - This method returns true if the array is an array of i8, and
 994 /// if the elements of the array are all ConstantInt's.
 995 bool ConstantArray::isString() const {
 996   // Check the element type for i8...
 997   if (!getType()->getElementType()->isIntegerTy(8))
 998     return false;
 999   // Check the elements to make sure they are all integers, not constant
1000   // expressions.
1001   for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
1002     if (!isa<ConstantInt>(getOperand(i)))
1003       return false;
1004   return true;
1005 }
1006
1007 /// isCString - This method returns true if the array is a string (see
1008 /// isString) and it ends in a null byte \\0 and does not contains any other
1009 /// null bytes except its terminator.
1010 bool ConstantArray::isCString() const {
1011   // Check the element type for i8...
1012   if (!getType()->getElementType()->isIntegerTy(8))
1013     return false;
1014
1015   // Last element must be a null.
1016   if (!getOperand(getNumOperands()-1)->isNullValue())
1017     return false;
1018   // Other elements must be non-null integers.
1019   for (unsigned i = 0, e = getNumOperands()-1; i != e; ++i) {
1020     if (!isa<ConstantInt>(getOperand(i)))
1021       return false;
1022     if (getOperand(i)->isNullValue())
1023       return false;
1024   }
1025   return true;
1026 }
1027
1028
1029 /// convertToString - Helper function for getAsString() and getAsCString().
1030 static std::string convertToString(const User *U, unsigned len) {
1031   std::string Result;
1032   Result.reserve(len);
1033   for (unsigned i = 0; i != len; ++i)
1034     Result.push_back((char)cast<ConstantInt>(U->getOperand(i))->getZExtValue());
1035   return Result;
1036 }
1037
1038 /// getAsString - If this array is isString(), then this method converts the
1039 /// array to an std::string and returns it.  Otherwise, it asserts out.
1040 ///
1041 std::string ConstantArray::getAsString() const {
1042   assert(isString() && "Not a string!");
1043   return convertToString(this, getNumOperands());
1044 }
1045
1046
1047 /// getAsCString - If this array is isCString(), then this method converts the
1048 /// array (without the trailing null byte) to an std::string and returns it.
1049 /// Otherwise, it asserts out.
1050 ///
1051 std::string ConstantArray::getAsCString() const {
1052   assert(isCString() && "Not a string!");
1053   return convertToString(this, getNumOperands() - 1);
1054 }
1055
1056
1057 //---- ConstantStruct::get() implementation...
1058 //
1059
1060 // destroyConstant - Remove the constant from the constant table...
1061 //
1062 void ConstantStruct::destroyConstant() {
1063   getType()->getContext().pImpl->StructConstants.remove(this);
1064   destroyConstantImpl();
1065 }
1066
1067 // destroyConstant - Remove the constant from the constant table...
1068 //
1069 void ConstantVector::destroyConstant() {
1070   getType()->getContext().pImpl->VectorConstants.remove(this);
1071   destroyConstantImpl();
1072 }
1073
1074 /// This function will return true iff every element in this vector constant
1075 /// is set to all ones.
1076 /// @returns true iff this constant's elements are all set to all ones.
1077 /// @brief Determine if the value is all ones.
1078 bool ConstantVector::isAllOnesValue() const {
1079   // Check out first element.
1080   const Constant *Elt = getOperand(0);
1081   const ConstantInt *CI = dyn_cast<ConstantInt>(Elt);
1082   const ConstantFP *CF = dyn_cast<ConstantFP>(Elt);
1083
1084   // Then make sure all remaining elements point to the same value.
1085   for (unsigned I = 1, E = getNumOperands(); I < E; ++I)
1086     if (getOperand(I) != Elt)
1087       return false;
1088
1089   // First value is all-ones.
1090   return (CI && CI->isAllOnesValue()) ||
1091          (CF && CF->isAllOnesValue());
1092 }
1093
1094 /// getSplatValue - If this is a splat constant, where all of the
1095 /// elements have the same value, return that value. Otherwise return null.
1096 Constant *ConstantVector::getSplatValue() const {
1097   // Check out first element.
1098   Constant *Elt = getOperand(0);
1099   // Then make sure all remaining elements point to the same value.
1100   for (unsigned I = 1, E = getNumOperands(); I < E; ++I)
1101     if (getOperand(I) != Elt)
1102       return 0;
1103   return Elt;
1104 }
1105
1106 //---- ConstantPointerNull::get() implementation.
1107 //
1108
1109 ConstantPointerNull *ConstantPointerNull::get(PointerType *Ty) {
1110   return Ty->getContext().pImpl->NullPtrConstants.getOrCreate(Ty, 0);
1111 }
1112
1113 // destroyConstant - Remove the constant from the constant table...
1114 //
1115 void ConstantPointerNull::destroyConstant() {
1116   getType()->getContext().pImpl->NullPtrConstants.remove(this);
1117   destroyConstantImpl();
1118 }
1119
1120
1121 //---- UndefValue::get() implementation.
1122 //
1123
1124 UndefValue *UndefValue::get(Type *Ty) {
1125   return Ty->getContext().pImpl->UndefValueConstants.getOrCreate(Ty, 0);
1126 }
1127
1128 // destroyConstant - Remove the constant from the constant table.
1129 //
1130 void UndefValue::destroyConstant() {
1131   getType()->getContext().pImpl->UndefValueConstants.remove(this);
1132   destroyConstantImpl();
1133 }
1134
1135 //---- BlockAddress::get() implementation.
1136 //
1137
1138 BlockAddress *BlockAddress::get(BasicBlock *BB) {
1139   assert(BB->getParent() != 0 && "Block must have a parent");
1140   return get(BB->getParent(), BB);
1141 }
1142
1143 BlockAddress *BlockAddress::get(Function *F, BasicBlock *BB) {
1144   BlockAddress *&BA =
1145     F->getContext().pImpl->BlockAddresses[std::make_pair(F, BB)];
1146   if (BA == 0)
1147     BA = new BlockAddress(F, BB);
1148
1149   assert(BA->getFunction() == F && "Basic block moved between functions");
1150   return BA;
1151 }
1152
1153 BlockAddress::BlockAddress(Function *F, BasicBlock *BB)
1154 : Constant(Type::getInt8PtrTy(F->getContext()), Value::BlockAddressVal,
1155            &Op<0>(), 2) {
1156   setOperand(0, F);
1157   setOperand(1, BB);
1158   BB->AdjustBlockAddressRefCount(1);
1159 }
1160
1161
1162 // destroyConstant - Remove the constant from the constant table.
1163 //
1164 void BlockAddress::destroyConstant() {
1165   getFunction()->getType()->getContext().pImpl
1166     ->BlockAddresses.erase(std::make_pair(getFunction(), getBasicBlock()));
1167   getBasicBlock()->AdjustBlockAddressRefCount(-1);
1168   destroyConstantImpl();
1169 }
1170
1171 void BlockAddress::replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U) {
1172   // This could be replacing either the Basic Block or the Function.  In either
1173   // case, we have to remove the map entry.
1174   Function *NewF = getFunction();
1175   BasicBlock *NewBB = getBasicBlock();
1176
1177   if (U == &Op<0>())
1178     NewF = cast<Function>(To);
1179   else
1180     NewBB = cast<BasicBlock>(To);
1181
1182   // See if the 'new' entry already exists, if not, just update this in place
1183   // and return early.
1184   BlockAddress *&NewBA =
1185     getContext().pImpl->BlockAddresses[std::make_pair(NewF, NewBB)];
1186   if (NewBA == 0) {
1187     getBasicBlock()->AdjustBlockAddressRefCount(-1);
1188
1189     // Remove the old entry, this can't cause the map to rehash (just a
1190     // tombstone will get added).
1191     getContext().pImpl->BlockAddresses.erase(std::make_pair(getFunction(),
1192                                                             getBasicBlock()));
1193     NewBA = this;
1194     setOperand(0, NewF);
1195     setOperand(1, NewBB);
1196     getBasicBlock()->AdjustBlockAddressRefCount(1);
1197     return;
1198   }
1199
1200   // Otherwise, I do need to replace this with an existing value.
1201   assert(NewBA != this && "I didn't contain From!");
1202
1203   // Everyone using this now uses the replacement.
1204   replaceAllUsesWith(NewBA);
1205
1206   destroyConstant();
1207 }
1208
1209 //---- ConstantExpr::get() implementations.
1210 //
1211
1212 /// This is a utility function to handle folding of casts and lookup of the
1213 /// cast in the ExprConstants map. It is used by the various get* methods below.
1214 static inline Constant *getFoldedCast(
1215   Instruction::CastOps opc, Constant *C, Type *Ty) {
1216   assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
1217   // Fold a few common cases
1218   if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty))
1219     return FC;
1220
1221   LLVMContextImpl *pImpl = Ty->getContext().pImpl;
1222
1223   // Look up the constant in the table first to ensure uniqueness
1224   std::vector<Constant*> argVec(1, C);
1225   ExprMapKeyType Key(opc, argVec);
1226
1227   return pImpl->ExprConstants.getOrCreate(Ty, Key);
1228 }
1229
1230 Constant *ConstantExpr::getCast(unsigned oc, Constant *C, Type *Ty) {
1231   Instruction::CastOps opc = Instruction::CastOps(oc);
1232   assert(Instruction::isCast(opc) && "opcode out of range");
1233   assert(C && Ty && "Null arguments to getCast");
1234   assert(CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!");
1235
1236   switch (opc) {
1237   default:
1238     llvm_unreachable("Invalid cast opcode");
1239     break;
1240   case Instruction::Trunc:    return getTrunc(C, Ty);
1241   case Instruction::ZExt:     return getZExt(C, Ty);
1242   case Instruction::SExt:     return getSExt(C, Ty);
1243   case Instruction::FPTrunc:  return getFPTrunc(C, Ty);
1244   case Instruction::FPExt:    return getFPExtend(C, Ty);
1245   case Instruction::UIToFP:   return getUIToFP(C, Ty);
1246   case Instruction::SIToFP:   return getSIToFP(C, Ty);
1247   case Instruction::FPToUI:   return getFPToUI(C, Ty);
1248   case Instruction::FPToSI:   return getFPToSI(C, Ty);
1249   case Instruction::PtrToInt: return getPtrToInt(C, Ty);
1250   case Instruction::IntToPtr: return getIntToPtr(C, Ty);
1251   case Instruction::BitCast:  return getBitCast(C, Ty);
1252   }
1253   return 0;
1254 }
1255
1256 Constant *ConstantExpr::getZExtOrBitCast(Constant *C, Type *Ty) {
1257   if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
1258     return getBitCast(C, Ty);
1259   return getZExt(C, Ty);
1260 }
1261
1262 Constant *ConstantExpr::getSExtOrBitCast(Constant *C, Type *Ty) {
1263   if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
1264     return getBitCast(C, Ty);
1265   return getSExt(C, Ty);
1266 }
1267
1268 Constant *ConstantExpr::getTruncOrBitCast(Constant *C, Type *Ty) {
1269   if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
1270     return getBitCast(C, Ty);
1271   return getTrunc(C, Ty);
1272 }
1273
1274 Constant *ConstantExpr::getPointerCast(Constant *S, Type *Ty) {
1275   assert(S->getType()->isPointerTy() && "Invalid cast");
1276   assert((Ty->isIntegerTy() || Ty->isPointerTy()) && "Invalid cast");
1277
1278   if (Ty->isIntegerTy())
1279     return getPtrToInt(S, Ty);
1280   return getBitCast(S, Ty);
1281 }
1282
1283 Constant *ConstantExpr::getIntegerCast(Constant *C, Type *Ty,
1284                                        bool isSigned) {
1285   assert(C->getType()->isIntOrIntVectorTy() &&
1286          Ty->isIntOrIntVectorTy() && "Invalid cast");
1287   unsigned SrcBits = C->getType()->getScalarSizeInBits();
1288   unsigned DstBits = Ty->getScalarSizeInBits();
1289   Instruction::CastOps opcode =
1290     (SrcBits == DstBits ? Instruction::BitCast :
1291      (SrcBits > DstBits ? Instruction::Trunc :
1292       (isSigned ? Instruction::SExt : Instruction::ZExt)));
1293   return getCast(opcode, C, Ty);
1294 }
1295
1296 Constant *ConstantExpr::getFPCast(Constant *C, Type *Ty) {
1297   assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
1298          "Invalid cast");
1299   unsigned SrcBits = C->getType()->getScalarSizeInBits();
1300   unsigned DstBits = Ty->getScalarSizeInBits();
1301   if (SrcBits == DstBits)
1302     return C; // Avoid a useless cast
1303   Instruction::CastOps opcode =
1304     (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt);
1305   return getCast(opcode, C, Ty);
1306 }
1307
1308 Constant *ConstantExpr::getTrunc(Constant *C, Type *Ty) {
1309 #ifndef NDEBUG
1310   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1311   bool toVec = Ty->getTypeID() == Type::VectorTyID;
1312 #endif
1313   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1314   assert(C->getType()->isIntOrIntVectorTy() && "Trunc operand must be integer");
1315   assert(Ty->isIntOrIntVectorTy() && "Trunc produces only integral");
1316   assert(C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
1317          "SrcTy must be larger than DestTy for Trunc!");
1318
1319   return getFoldedCast(Instruction::Trunc, C, Ty);
1320 }
1321
1322 Constant *ConstantExpr::getSExt(Constant *C, Type *Ty) {
1323 #ifndef NDEBUG
1324   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1325   bool toVec = Ty->getTypeID() == Type::VectorTyID;
1326 #endif
1327   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1328   assert(C->getType()->isIntOrIntVectorTy() && "SExt operand must be integral");
1329   assert(Ty->isIntOrIntVectorTy() && "SExt produces only integer");
1330   assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
1331          "SrcTy must be smaller than DestTy for SExt!");
1332
1333   return getFoldedCast(Instruction::SExt, C, Ty);
1334 }
1335
1336 Constant *ConstantExpr::getZExt(Constant *C, Type *Ty) {
1337 #ifndef NDEBUG
1338   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1339   bool toVec = Ty->getTypeID() == Type::VectorTyID;
1340 #endif
1341   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1342   assert(C->getType()->isIntOrIntVectorTy() && "ZEXt operand must be integral");
1343   assert(Ty->isIntOrIntVectorTy() && "ZExt produces only integer");
1344   assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
1345          "SrcTy must be smaller than DestTy for ZExt!");
1346
1347   return getFoldedCast(Instruction::ZExt, C, Ty);
1348 }
1349
1350 Constant *ConstantExpr::getFPTrunc(Constant *C, Type *Ty) {
1351 #ifndef NDEBUG
1352   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1353   bool toVec = Ty->getTypeID() == Type::VectorTyID;
1354 #endif
1355   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1356   assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
1357          C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
1358          "This is an illegal floating point truncation!");
1359   return getFoldedCast(Instruction::FPTrunc, C, Ty);
1360 }
1361
1362 Constant *ConstantExpr::getFPExtend(Constant *C, Type *Ty) {
1363 #ifndef NDEBUG
1364   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1365   bool toVec = Ty->getTypeID() == Type::VectorTyID;
1366 #endif
1367   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1368   assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
1369          C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
1370          "This is an illegal floating point extension!");
1371   return getFoldedCast(Instruction::FPExt, C, Ty);
1372 }
1373
1374 Constant *ConstantExpr::getUIToFP(Constant *C, Type *Ty) {
1375 #ifndef NDEBUG
1376   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1377   bool toVec = Ty->getTypeID() == Type::VectorTyID;
1378 #endif
1379   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1380   assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
1381          "This is an illegal uint to floating point cast!");
1382   return getFoldedCast(Instruction::UIToFP, C, Ty);
1383 }
1384
1385 Constant *ConstantExpr::getSIToFP(Constant *C, Type *Ty) {
1386 #ifndef NDEBUG
1387   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1388   bool toVec = Ty->getTypeID() == Type::VectorTyID;
1389 #endif
1390   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1391   assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
1392          "This is an illegal sint to floating point cast!");
1393   return getFoldedCast(Instruction::SIToFP, C, Ty);
1394 }
1395
1396 Constant *ConstantExpr::getFPToUI(Constant *C, Type *Ty) {
1397 #ifndef NDEBUG
1398   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1399   bool toVec = Ty->getTypeID() == Type::VectorTyID;
1400 #endif
1401   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1402   assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
1403          "This is an illegal floating point to uint cast!");
1404   return getFoldedCast(Instruction::FPToUI, C, Ty);
1405 }
1406
1407 Constant *ConstantExpr::getFPToSI(Constant *C, Type *Ty) {
1408 #ifndef NDEBUG
1409   bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1410   bool toVec = Ty->getTypeID() == Type::VectorTyID;
1411 #endif
1412   assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1413   assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
1414          "This is an illegal floating point to sint cast!");
1415   return getFoldedCast(Instruction::FPToSI, C, Ty);
1416 }
1417
1418 Constant *ConstantExpr::getPtrToInt(Constant *C, Type *DstTy) {
1419   assert(C->getType()->isPointerTy() && "PtrToInt source must be pointer");
1420   assert(DstTy->isIntegerTy() && "PtrToInt destination must be integral");
1421   return getFoldedCast(Instruction::PtrToInt, C, DstTy);
1422 }
1423
1424 Constant *ConstantExpr::getIntToPtr(Constant *C, Type *DstTy) {
1425   assert(C->getType()->isIntegerTy() && "IntToPtr source must be integral");
1426   assert(DstTy->isPointerTy() && "IntToPtr destination must be a pointer");
1427   return getFoldedCast(Instruction::IntToPtr, C, DstTy);
1428 }
1429
1430 Constant *ConstantExpr::getBitCast(Constant *C, Type *DstTy) {
1431   assert(CastInst::castIsValid(Instruction::BitCast, C, DstTy) &&
1432          "Invalid constantexpr bitcast!");
1433
1434   // It is common to ask for a bitcast of a value to its own type, handle this
1435   // speedily.
1436   if (C->getType() == DstTy) return C;
1437
1438   return getFoldedCast(Instruction::BitCast, C, DstTy);
1439 }
1440
1441 Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2,
1442                             unsigned Flags) {
1443   // Check the operands for consistency first.
1444   assert(Opcode >= Instruction::BinaryOpsBegin &&
1445          Opcode <  Instruction::BinaryOpsEnd   &&
1446          "Invalid opcode in binary constant expression");
1447   assert(C1->getType() == C2->getType() &&
1448          "Operand types in binary constant expression should match");
1449
1450 #ifndef NDEBUG
1451   switch (Opcode) {
1452   case Instruction::Add:
1453   case Instruction::Sub:
1454   case Instruction::Mul:
1455     assert(C1->getType() == C2->getType() && "Op types should be identical!");
1456     assert(C1->getType()->isIntOrIntVectorTy() &&
1457            "Tried to create an integer operation on a non-integer type!");
1458     break;
1459   case Instruction::FAdd:
1460   case Instruction::FSub:
1461   case Instruction::FMul:
1462     assert(C1->getType() == C2->getType() && "Op types should be identical!");
1463     assert(C1->getType()->isFPOrFPVectorTy() &&
1464            "Tried to create a floating-point operation on a "
1465            "non-floating-point type!");
1466     break;
1467   case Instruction::UDiv:
1468   case Instruction::SDiv:
1469     assert(C1->getType() == C2->getType() && "Op types should be identical!");
1470     assert(C1->getType()->isIntOrIntVectorTy() &&
1471            "Tried to create an arithmetic operation on a non-arithmetic type!");
1472     break;
1473   case Instruction::FDiv:
1474     assert(C1->getType() == C2->getType() && "Op types should be identical!");
1475     assert(C1->getType()->isFPOrFPVectorTy() &&
1476            "Tried to create an arithmetic operation on a non-arithmetic type!");
1477     break;
1478   case Instruction::URem:
1479   case Instruction::SRem:
1480     assert(C1->getType() == C2->getType() && "Op types should be identical!");
1481     assert(C1->getType()->isIntOrIntVectorTy() &&
1482            "Tried to create an arithmetic operation on a non-arithmetic type!");
1483     break;
1484   case Instruction::FRem:
1485     assert(C1->getType() == C2->getType() && "Op types should be identical!");
1486     assert(C1->getType()->isFPOrFPVectorTy() &&
1487            "Tried to create an arithmetic operation on a non-arithmetic type!");
1488     break;
1489   case Instruction::And:
1490   case Instruction::Or:
1491   case Instruction::Xor:
1492     assert(C1->getType() == C2->getType() && "Op types should be identical!");
1493     assert(C1->getType()->isIntOrIntVectorTy() &&
1494            "Tried to create a logical operation on a non-integral type!");
1495     break;
1496   case Instruction::Shl:
1497   case Instruction::LShr:
1498   case Instruction::AShr:
1499     assert(C1->getType() == C2->getType() && "Op types should be identical!");
1500     assert(C1->getType()->isIntOrIntVectorTy() &&
1501            "Tried to create a shift operation on a non-integer type!");
1502     break;
1503   default:
1504     break;
1505   }
1506 #endif
1507
1508   if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))
1509     return FC;          // Fold a few common cases.
1510
1511   std::vector<Constant*> argVec(1, C1);
1512   argVec.push_back(C2);
1513   ExprMapKeyType Key(Opcode, argVec, 0, Flags);
1514
1515   LLVMContextImpl *pImpl = C1->getContext().pImpl;
1516   return pImpl->ExprConstants.getOrCreate(C1->getType(), Key);
1517 }
1518
1519 Constant *ConstantExpr::getSizeOf(Type* Ty) {
1520   // sizeof is implemented as: (i64) gep (Ty*)null, 1
1521   // Note that a non-inbounds gep is used, as null isn't within any object.
1522   Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
1523   Constant *GEP = getGetElementPtr(
1524                  Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx);
1525   return getPtrToInt(GEP,
1526                      Type::getInt64Ty(Ty->getContext()));
1527 }
1528
1529 Constant *ConstantExpr::getAlignOf(Type* Ty) {
1530   // alignof is implemented as: (i64) gep ({i1,Ty}*)null, 0, 1
1531   // Note that a non-inbounds gep is used, as null isn't within any object.
1532   Type *AligningTy =
1533     StructType::get(Type::getInt1Ty(Ty->getContext()), Ty, NULL);
1534   Constant *NullPtr = Constant::getNullValue(AligningTy->getPointerTo());
1535   Constant *Zero = ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0);
1536   Constant *One = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
1537   Constant *Indices[2] = { Zero, One };
1538   Constant *GEP = getGetElementPtr(NullPtr, Indices);
1539   return getPtrToInt(GEP,
1540                      Type::getInt64Ty(Ty->getContext()));
1541 }
1542
1543 Constant *ConstantExpr::getOffsetOf(StructType* STy, unsigned FieldNo) {
1544   return getOffsetOf(STy, ConstantInt::get(Type::getInt32Ty(STy->getContext()),
1545                                            FieldNo));
1546 }
1547
1548 Constant *ConstantExpr::getOffsetOf(Type* Ty, Constant *FieldNo) {
1549   // offsetof is implemented as: (i64) gep (Ty*)null, 0, FieldNo
1550   // Note that a non-inbounds gep is used, as null isn't within any object.
1551   Constant *GEPIdx[] = {
1552     ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0),
1553     FieldNo
1554   };
1555   Constant *GEP = getGetElementPtr(
1556                 Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx);
1557   return getPtrToInt(GEP,
1558                      Type::getInt64Ty(Ty->getContext()));
1559 }
1560
1561 Constant *ConstantExpr::getCompare(unsigned short Predicate,
1562                                    Constant *C1, Constant *C2) {
1563   assert(C1->getType() == C2->getType() && "Op types should be identical!");
1564
1565   switch (Predicate) {
1566   default: llvm_unreachable("Invalid CmpInst predicate");
1567   case CmpInst::FCMP_FALSE: case CmpInst::FCMP_OEQ: case CmpInst::FCMP_OGT:
1568   case CmpInst::FCMP_OGE:   case CmpInst::FCMP_OLT: case CmpInst::FCMP_OLE:
1569   case CmpInst::FCMP_ONE:   case CmpInst::FCMP_ORD: case CmpInst::FCMP_UNO:
1570   case CmpInst::FCMP_UEQ:   case CmpInst::FCMP_UGT: case CmpInst::FCMP_UGE:
1571   case CmpInst::FCMP_ULT:   case CmpInst::FCMP_ULE: case CmpInst::FCMP_UNE:
1572   case CmpInst::FCMP_TRUE:
1573     return getFCmp(Predicate, C1, C2);
1574
1575   case CmpInst::ICMP_EQ:  case CmpInst::ICMP_NE:  case CmpInst::ICMP_UGT:
1576   case CmpInst::ICMP_UGE: case CmpInst::ICMP_ULT: case CmpInst::ICMP_ULE:
1577   case CmpInst::ICMP_SGT: case CmpInst::ICMP_SGE: case CmpInst::ICMP_SLT:
1578   case CmpInst::ICMP_SLE:
1579     return getICmp(Predicate, C1, C2);
1580   }
1581 }
1582
1583 Constant *ConstantExpr::getSelect(Constant *C, Constant *V1, Constant *V2) {
1584   assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands");
1585
1586   if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2))
1587     return SC;        // Fold common cases
1588
1589   std::vector<Constant*> argVec(3, C);
1590   argVec[1] = V1;
1591   argVec[2] = V2;
1592   ExprMapKeyType Key(Instruction::Select, argVec);
1593
1594   LLVMContextImpl *pImpl = C->getContext().pImpl;
1595   return pImpl->ExprConstants.getOrCreate(V1->getType(), Key);
1596 }
1597
1598 Constant *ConstantExpr::getGetElementPtr(Constant *C, ArrayRef<Value *> Idxs,
1599                                          bool InBounds) {
1600   if (Constant *FC = ConstantFoldGetElementPtr(C, InBounds, Idxs))
1601     return FC;          // Fold a few common cases.
1602
1603   // Get the result type of the getelementptr!
1604   Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), Idxs);
1605   assert(Ty && "GEP indices invalid!");
1606   unsigned AS = cast<PointerType>(C->getType())->getAddressSpace();
1607   Type *ReqTy = Ty->getPointerTo(AS);
1608
1609   assert(C->getType()->isPointerTy() &&
1610          "Non-pointer type for constant GetElementPtr expression");
1611   // Look up the constant in the table first to ensure uniqueness
1612   std::vector<Constant*> ArgVec;
1613   ArgVec.reserve(1 + Idxs.size());
1614   ArgVec.push_back(C);
1615   for (unsigned i = 0, e = Idxs.size(); i != e; ++i)
1616     ArgVec.push_back(cast<Constant>(Idxs[i]));
1617   const ExprMapKeyType Key(Instruction::GetElementPtr, ArgVec, 0,
1618                            InBounds ? GEPOperator::IsInBounds : 0);
1619
1620   LLVMContextImpl *pImpl = C->getContext().pImpl;
1621   return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
1622 }
1623
1624 Constant *
1625 ConstantExpr::getICmp(unsigned short pred, Constant *LHS, Constant *RHS) {
1626   assert(LHS->getType() == RHS->getType());
1627   assert(pred >= ICmpInst::FIRST_ICMP_PREDICATE &&
1628          pred <= ICmpInst::LAST_ICMP_PREDICATE && "Invalid ICmp Predicate");
1629
1630   if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
1631     return FC;          // Fold a few common cases...
1632
1633   // Look up the constant in the table first to ensure uniqueness
1634   std::vector<Constant*> ArgVec;
1635   ArgVec.push_back(LHS);
1636   ArgVec.push_back(RHS);
1637   // Get the key type with both the opcode and predicate
1638   const ExprMapKeyType Key(Instruction::ICmp, ArgVec, pred);
1639
1640   Type *ResultTy = Type::getInt1Ty(LHS->getContext());
1641   if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
1642     ResultTy = VectorType::get(ResultTy, VT->getNumElements());
1643
1644   LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
1645   return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
1646 }
1647
1648 Constant *
1649 ConstantExpr::getFCmp(unsigned short pred, Constant *LHS, Constant *RHS) {
1650   assert(LHS->getType() == RHS->getType());
1651   assert(pred <= FCmpInst::LAST_FCMP_PREDICATE && "Invalid FCmp Predicate");
1652
1653   if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
1654     return FC;          // Fold a few common cases...
1655
1656   // Look up the constant in the table first to ensure uniqueness
1657   std::vector<Constant*> ArgVec;
1658   ArgVec.push_back(LHS);
1659   ArgVec.push_back(RHS);
1660   // Get the key type with both the opcode and predicate
1661   const ExprMapKeyType Key(Instruction::FCmp, ArgVec, pred);
1662
1663   Type *ResultTy = Type::getInt1Ty(LHS->getContext());
1664   if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
1665     ResultTy = VectorType::get(ResultTy, VT->getNumElements());
1666
1667   LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
1668   return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
1669 }
1670
1671 Constant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx) {
1672   assert(Val->getType()->isVectorTy() &&
1673          "Tried to create extractelement operation on non-vector type!");
1674   assert(Idx->getType()->isIntegerTy(32) &&
1675          "Extractelement index must be i32 type!");
1676
1677   if (Constant *FC = ConstantFoldExtractElementInstruction(Val, Idx))
1678     return FC;          // Fold a few common cases.
1679
1680   // Look up the constant in the table first to ensure uniqueness
1681   std::vector<Constant*> ArgVec(1, Val);
1682   ArgVec.push_back(Idx);
1683   const ExprMapKeyType Key(Instruction::ExtractElement,ArgVec);
1684
1685   LLVMContextImpl *pImpl = Val->getContext().pImpl;
1686   Type *ReqTy = cast<VectorType>(Val->getType())->getElementType();
1687   return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
1688 }
1689
1690 Constant *ConstantExpr::getInsertElement(Constant *Val, Constant *Elt,
1691                                          Constant *Idx) {
1692   assert(Val->getType()->isVectorTy() &&
1693          "Tried to create insertelement operation on non-vector type!");
1694   assert(Elt->getType() == cast<VectorType>(Val->getType())->getElementType()
1695          && "Insertelement types must match!");
1696   assert(Idx->getType()->isIntegerTy(32) &&
1697          "Insertelement index must be i32 type!");
1698
1699   if (Constant *FC = ConstantFoldInsertElementInstruction(Val, Elt, Idx))
1700     return FC;          // Fold a few common cases.
1701   // Look up the constant in the table first to ensure uniqueness
1702   std::vector<Constant*> ArgVec(1, Val);
1703   ArgVec.push_back(Elt);
1704   ArgVec.push_back(Idx);
1705   const ExprMapKeyType Key(Instruction::InsertElement,ArgVec);
1706
1707   LLVMContextImpl *pImpl = Val->getContext().pImpl;
1708   return pImpl->ExprConstants.getOrCreate(Val->getType(), Key);
1709 }
1710
1711 Constant *ConstantExpr::getShuffleVector(Constant *V1, Constant *V2,
1712                                          Constant *Mask) {
1713   assert(ShuffleVectorInst::isValidOperands(V1, V2, Mask) &&
1714          "Invalid shuffle vector constant expr operands!");
1715
1716   if (Constant *FC = ConstantFoldShuffleVectorInstruction(V1, V2, Mask))
1717     return FC;          // Fold a few common cases.
1718
1719   unsigned NElts = cast<VectorType>(Mask->getType())->getNumElements();
1720   Type *EltTy = cast<VectorType>(V1->getType())->getElementType();
1721   Type *ShufTy = VectorType::get(EltTy, NElts);
1722
1723   // Look up the constant in the table first to ensure uniqueness
1724   std::vector<Constant*> ArgVec(1, V1);
1725   ArgVec.push_back(V2);
1726   ArgVec.push_back(Mask);
1727   const ExprMapKeyType Key(Instruction::ShuffleVector,ArgVec);
1728
1729   LLVMContextImpl *pImpl = ShufTy->getContext().pImpl;
1730   return pImpl->ExprConstants.getOrCreate(ShufTy, Key);
1731 }
1732
1733 Constant *ConstantExpr::getInsertValue(Constant *Agg, Constant *Val,
1734                                        ArrayRef<unsigned> Idxs) {
1735   assert(ExtractValueInst::getIndexedType(Agg->getType(),
1736                                           Idxs) == Val->getType() &&
1737          "insertvalue indices invalid!");
1738   assert(Agg->getType()->isFirstClassType() &&
1739          "Non-first-class type for constant insertvalue expression");
1740   Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs);
1741   assert(FC && "insertvalue constant expr couldn't be folded!");
1742   return FC;
1743 }
1744
1745 Constant *ConstantExpr::getExtractValue(Constant *Agg,
1746                                         ArrayRef<unsigned> Idxs) {
1747   assert(Agg->getType()->isFirstClassType() &&
1748          "Tried to create extractelement operation on non-first-class type!");
1749
1750   Type *ReqTy = ExtractValueInst::getIndexedType(Agg->getType(), Idxs);
1751   (void)ReqTy;
1752   assert(ReqTy && "extractvalue indices invalid!");
1753
1754   assert(Agg->getType()->isFirstClassType() &&
1755          "Non-first-class type for constant extractvalue expression");
1756   Constant *FC = ConstantFoldExtractValueInstruction(Agg, Idxs);
1757   assert(FC && "ExtractValue constant expr couldn't be folded!");
1758   return FC;
1759 }
1760
1761 Constant *ConstantExpr::getNeg(Constant *C, bool HasNUW, bool HasNSW) {
1762   assert(C->getType()->isIntOrIntVectorTy() &&
1763          "Cannot NEG a nonintegral value!");
1764   return getSub(ConstantFP::getZeroValueForNegation(C->getType()),
1765                 C, HasNUW, HasNSW);
1766 }
1767
1768 Constant *ConstantExpr::getFNeg(Constant *C) {
1769   assert(C->getType()->isFPOrFPVectorTy() &&
1770          "Cannot FNEG a non-floating-point value!");
1771   return getFSub(ConstantFP::getZeroValueForNegation(C->getType()), C);
1772 }
1773
1774 Constant *ConstantExpr::getNot(Constant *C) {
1775   assert(C->getType()->isIntOrIntVectorTy() &&
1776          "Cannot NOT a nonintegral value!");
1777   return get(Instruction::Xor, C, Constant::getAllOnesValue(C->getType()));
1778 }
1779
1780 Constant *ConstantExpr::getAdd(Constant *C1, Constant *C2,
1781                                bool HasNUW, bool HasNSW) {
1782   unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
1783                    (HasNSW ? OverflowingBinaryOperator::NoSignedWrap   : 0);
1784   return get(Instruction::Add, C1, C2, Flags);
1785 }
1786
1787 Constant *ConstantExpr::getFAdd(Constant *C1, Constant *C2) {
1788   return get(Instruction::FAdd, C1, C2);
1789 }
1790
1791 Constant *ConstantExpr::getSub(Constant *C1, Constant *C2,
1792                                bool HasNUW, bool HasNSW) {
1793   unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
1794                    (HasNSW ? OverflowingBinaryOperator::NoSignedWrap   : 0);
1795   return get(Instruction::Sub, C1, C2, Flags);
1796 }
1797
1798 Constant *ConstantExpr::getFSub(Constant *C1, Constant *C2) {
1799   return get(Instruction::FSub, C1, C2);
1800 }
1801
1802 Constant *ConstantExpr::getMul(Constant *C1, Constant *C2,
1803                                bool HasNUW, bool HasNSW) {
1804   unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
1805                    (HasNSW ? OverflowingBinaryOperator::NoSignedWrap   : 0);
1806   return get(Instruction::Mul, C1, C2, Flags);
1807 }
1808
1809 Constant *ConstantExpr::getFMul(Constant *C1, Constant *C2) {
1810   return get(Instruction::FMul, C1, C2);
1811 }
1812
1813 Constant *ConstantExpr::getUDiv(Constant *C1, Constant *C2, bool isExact) {
1814   return get(Instruction::UDiv, C1, C2,
1815              isExact ? PossiblyExactOperator::IsExact : 0);
1816 }
1817
1818 Constant *ConstantExpr::getSDiv(Constant *C1, Constant *C2, bool isExact) {
1819   return get(Instruction::SDiv, C1, C2,
1820              isExact ? PossiblyExactOperator::IsExact : 0);
1821 }
1822
1823 Constant *ConstantExpr::getFDiv(Constant *C1, Constant *C2) {
1824   return get(Instruction::FDiv, C1, C2);
1825 }
1826
1827 Constant *ConstantExpr::getURem(Constant *C1, Constant *C2) {
1828   return get(Instruction::URem, C1, C2);
1829 }
1830
1831 Constant *ConstantExpr::getSRem(Constant *C1, Constant *C2) {
1832   return get(Instruction::SRem, C1, C2);
1833 }
1834
1835 Constant *ConstantExpr::getFRem(Constant *C1, Constant *C2) {
1836   return get(Instruction::FRem, C1, C2);
1837 }
1838
1839 Constant *ConstantExpr::getAnd(Constant *C1, Constant *C2) {
1840   return get(Instruction::And, C1, C2);
1841 }
1842
1843 Constant *ConstantExpr::getOr(Constant *C1, Constant *C2) {
1844   return get(Instruction::Or, C1, C2);
1845 }
1846
1847 Constant *ConstantExpr::getXor(Constant *C1, Constant *C2) {
1848   return get(Instruction::Xor, C1, C2);
1849 }
1850
1851 Constant *ConstantExpr::getShl(Constant *C1, Constant *C2,
1852                                bool HasNUW, bool HasNSW) {
1853   unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
1854                    (HasNSW ? OverflowingBinaryOperator::NoSignedWrap   : 0);
1855   return get(Instruction::Shl, C1, C2, Flags);
1856 }
1857
1858 Constant *ConstantExpr::getLShr(Constant *C1, Constant *C2, bool isExact) {
1859   return get(Instruction::LShr, C1, C2,
1860              isExact ? PossiblyExactOperator::IsExact : 0);
1861 }
1862
1863 Constant *ConstantExpr::getAShr(Constant *C1, Constant *C2, bool isExact) {
1864   return get(Instruction::AShr, C1, C2,
1865              isExact ? PossiblyExactOperator::IsExact : 0);
1866 }
1867
1868 // destroyConstant - Remove the constant from the constant table...
1869 //
1870 void ConstantExpr::destroyConstant() {
1871   getType()->getContext().pImpl->ExprConstants.remove(this);
1872   destroyConstantImpl();
1873 }
1874
1875 const char *ConstantExpr::getOpcodeName() const {
1876   return Instruction::getOpcodeName(getOpcode());
1877 }
1878
1879
1880
1881 GetElementPtrConstantExpr::
1882 GetElementPtrConstantExpr(Constant *C, const std::vector<Constant*> &IdxList,
1883                           Type *DestTy)
1884   : ConstantExpr(DestTy, Instruction::GetElementPtr,
1885                  OperandTraits<GetElementPtrConstantExpr>::op_end(this)
1886                  - (IdxList.size()+1), IdxList.size()+1) {
1887   OperandList[0] = C;
1888   for (unsigned i = 0, E = IdxList.size(); i != E; ++i)
1889     OperandList[i+1] = IdxList[i];
1890 }
1891
1892
1893 //===----------------------------------------------------------------------===//
1894 //                replaceUsesOfWithOnConstant implementations
1895
1896 /// replaceUsesOfWithOnConstant - Update this constant array to change uses of
1897 /// 'From' to be uses of 'To'.  This must update the uniquing data structures
1898 /// etc.
1899 ///
1900 /// Note that we intentionally replace all uses of From with To here.  Consider
1901 /// a large array that uses 'From' 1000 times.  By handling this case all here,
1902 /// ConstantArray::replaceUsesOfWithOnConstant is only invoked once, and that
1903 /// single invocation handles all 1000 uses.  Handling them one at a time would
1904 /// work, but would be really slow because it would have to unique each updated
1905 /// array instance.
1906 ///
1907 void ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To,
1908                                                 Use *U) {
1909   assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
1910   Constant *ToC = cast<Constant>(To);
1911
1912   LLVMContextImpl *pImpl = getType()->getContext().pImpl;
1913
1914   std::pair<LLVMContextImpl::ArrayConstantsTy::MapKey, ConstantArray*> Lookup;
1915   Lookup.first.first = cast<ArrayType>(getType());
1916   Lookup.second = this;
1917
1918   std::vector<Constant*> &Values = Lookup.first.second;
1919   Values.reserve(getNumOperands());  // Build replacement array.
1920
1921   // Fill values with the modified operands of the constant array.  Also,
1922   // compute whether this turns into an all-zeros array.
1923   bool isAllZeros = false;
1924   unsigned NumUpdated = 0;
1925   if (!ToC->isNullValue()) {
1926     for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
1927       Constant *Val = cast<Constant>(O->get());
1928       if (Val == From) {
1929         Val = ToC;
1930         ++NumUpdated;
1931       }
1932       Values.push_back(Val);
1933     }
1934   } else {
1935     isAllZeros = true;
1936     for (Use *O = OperandList, *E = OperandList+getNumOperands();O != E; ++O) {
1937       Constant *Val = cast<Constant>(O->get());
1938       if (Val == From) {
1939         Val = ToC;
1940         ++NumUpdated;
1941       }
1942       Values.push_back(Val);
1943       if (isAllZeros) isAllZeros = Val->isNullValue();
1944     }
1945   }
1946
1947   Constant *Replacement = 0;
1948   if (isAllZeros) {
1949     Replacement = ConstantAggregateZero::get(getType());
1950   } else {
1951     // Check to see if we have this array type already.
1952     bool Exists;
1953     LLVMContextImpl::ArrayConstantsTy::MapTy::iterator I =
1954       pImpl->ArrayConstants.InsertOrGetItem(Lookup, Exists);
1955
1956     if (Exists) {
1957       Replacement = I->second;
1958     } else {
1959       // Okay, the new shape doesn't exist in the system yet.  Instead of
1960       // creating a new constant array, inserting it, replaceallusesof'ing the
1961       // old with the new, then deleting the old... just update the current one
1962       // in place!
1963       pImpl->ArrayConstants.MoveConstantToNewSlot(this, I);
1964
1965       // Update to the new value.  Optimize for the case when we have a single
1966       // operand that we're changing, but handle bulk updates efficiently.
1967       if (NumUpdated == 1) {
1968         unsigned OperandToUpdate = U - OperandList;
1969         assert(getOperand(OperandToUpdate) == From &&
1970                "ReplaceAllUsesWith broken!");
1971         setOperand(OperandToUpdate, ToC);
1972       } else {
1973         for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
1974           if (getOperand(i) == From)
1975             setOperand(i, ToC);
1976       }
1977       return;
1978     }
1979   }
1980
1981   // Otherwise, I do need to replace this with an existing value.
1982   assert(Replacement != this && "I didn't contain From!");
1983
1984   // Everyone using this now uses the replacement.
1985   replaceAllUsesWith(Replacement);
1986
1987   // Delete the old constant!
1988   destroyConstant();
1989 }
1990
1991 void ConstantStruct::replaceUsesOfWithOnConstant(Value *From, Value *To,
1992                                                  Use *U) {
1993   assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
1994   Constant *ToC = cast<Constant>(To);
1995
1996   unsigned OperandToUpdate = U-OperandList;
1997   assert(getOperand(OperandToUpdate) == From && "ReplaceAllUsesWith broken!");
1998
1999   std::pair<LLVMContextImpl::StructConstantsTy::MapKey, ConstantStruct*> Lookup;
2000   Lookup.first.first = cast<StructType>(getType());
2001   Lookup.second = this;
2002   std::vector<Constant*> &Values = Lookup.first.second;
2003   Values.reserve(getNumOperands());  // Build replacement struct.
2004
2005
2006   // Fill values with the modified operands of the constant struct.  Also,
2007   // compute whether this turns into an all-zeros struct.
2008   bool isAllZeros = false;
2009   if (!ToC->isNullValue()) {
2010     for (Use *O = OperandList, *E = OperandList + getNumOperands(); O != E; ++O)
2011       Values.push_back(cast<Constant>(O->get()));
2012   } else {
2013     isAllZeros = true;
2014     for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
2015       Constant *Val = cast<Constant>(O->get());
2016       Values.push_back(Val);
2017       if (isAllZeros) isAllZeros = Val->isNullValue();
2018     }
2019   }
2020   Values[OperandToUpdate] = ToC;
2021
2022   LLVMContextImpl *pImpl = getContext().pImpl;
2023
2024   Constant *Replacement = 0;
2025   if (isAllZeros) {
2026     Replacement = ConstantAggregateZero::get(getType());
2027   } else {
2028     // Check to see if we have this struct type already.
2029     bool Exists;
2030     LLVMContextImpl::StructConstantsTy::MapTy::iterator I =
2031       pImpl->StructConstants.InsertOrGetItem(Lookup, Exists);
2032
2033     if (Exists) {
2034       Replacement = I->second;
2035     } else {
2036       // Okay, the new shape doesn't exist in the system yet.  Instead of
2037       // creating a new constant struct, inserting it, replaceallusesof'ing the
2038       // old with the new, then deleting the old... just update the current one
2039       // in place!
2040       pImpl->StructConstants.MoveConstantToNewSlot(this, I);
2041
2042       // Update to the new value.
2043       setOperand(OperandToUpdate, ToC);
2044       return;
2045     }
2046   }
2047
2048   assert(Replacement != this && "I didn't contain From!");
2049
2050   // Everyone using this now uses the replacement.
2051   replaceAllUsesWith(Replacement);
2052
2053   // Delete the old constant!
2054   destroyConstant();
2055 }
2056
2057 void ConstantVector::replaceUsesOfWithOnConstant(Value *From, Value *To,
2058                                                  Use *U) {
2059   assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
2060
2061   std::vector<Constant*> Values;
2062   Values.reserve(getNumOperands());  // Build replacement array...
2063   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
2064     Constant *Val = getOperand(i);
2065     if (Val == From) Val = cast<Constant>(To);
2066     Values.push_back(Val);
2067   }
2068
2069   Constant *Replacement = get(Values);
2070   assert(Replacement != this && "I didn't contain From!");
2071
2072   // Everyone using this now uses the replacement.
2073   replaceAllUsesWith(Replacement);
2074
2075   // Delete the old constant!
2076   destroyConstant();
2077 }
2078
2079 void ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV,
2080                                                Use *U) {
2081   assert(isa<Constant>(ToV) && "Cannot make Constant refer to non-constant!");
2082   Constant *To = cast<Constant>(ToV);
2083
2084   Constant *Replacement = 0;
2085   if (getOpcode() == Instruction::GetElementPtr) {
2086     SmallVector<Constant*, 8> Indices;
2087     Constant *Pointer = getOperand(0);
2088     Indices.reserve(getNumOperands()-1);
2089     if (Pointer == From) Pointer = To;
2090
2091     for (unsigned i = 1, e = getNumOperands(); i != e; ++i) {
2092       Constant *Val = getOperand(i);
2093       if (Val == From) Val = To;
2094       Indices.push_back(Val);
2095     }
2096     Replacement = ConstantExpr::getGetElementPtr(Pointer, Indices,
2097                                          cast<GEPOperator>(this)->isInBounds());
2098   } else if (getOpcode() == Instruction::ExtractValue) {
2099     Constant *Agg = getOperand(0);
2100     if (Agg == From) Agg = To;
2101
2102     ArrayRef<unsigned> Indices = getIndices();
2103     Replacement = ConstantExpr::getExtractValue(Agg, Indices);
2104   } else if (getOpcode() == Instruction::InsertValue) {
2105     Constant *Agg = getOperand(0);
2106     Constant *Val = getOperand(1);
2107     if (Agg == From) Agg = To;
2108     if (Val == From) Val = To;
2109
2110     ArrayRef<unsigned> Indices = getIndices();
2111     Replacement = ConstantExpr::getInsertValue(Agg, Val, Indices);
2112   } else if (isCast()) {
2113     assert(getOperand(0) == From && "Cast only has one use!");
2114     Replacement = ConstantExpr::getCast(getOpcode(), To, getType());
2115   } else if (getOpcode() == Instruction::Select) {
2116     Constant *C1 = getOperand(0);
2117     Constant *C2 = getOperand(1);
2118     Constant *C3 = getOperand(2);
2119     if (C1 == From) C1 = To;
2120     if (C2 == From) C2 = To;
2121     if (C3 == From) C3 = To;
2122     Replacement = ConstantExpr::getSelect(C1, C2, C3);
2123   } else if (getOpcode() == Instruction::ExtractElement) {
2124     Constant *C1 = getOperand(0);
2125     Constant *C2 = getOperand(1);
2126     if (C1 == From) C1 = To;
2127     if (C2 == From) C2 = To;
2128     Replacement = ConstantExpr::getExtractElement(C1, C2);
2129   } else if (getOpcode() == Instruction::InsertElement) {
2130     Constant *C1 = getOperand(0);
2131     Constant *C2 = getOperand(1);
2132     Constant *C3 = getOperand(1);
2133     if (C1 == From) C1 = To;
2134     if (C2 == From) C2 = To;
2135     if (C3 == From) C3 = To;
2136     Replacement = ConstantExpr::getInsertElement(C1, C2, C3);
2137   } else if (getOpcode() == Instruction::ShuffleVector) {
2138     Constant *C1 = getOperand(0);
2139     Constant *C2 = getOperand(1);
2140     Constant *C3 = getOperand(2);
2141     if (C1 == From) C1 = To;
2142     if (C2 == From) C2 = To;
2143     if (C3 == From) C3 = To;
2144     Replacement = ConstantExpr::getShuffleVector(C1, C2, C3);
2145   } else if (isCompare()) {
2146     Constant *C1 = getOperand(0);
2147     Constant *C2 = getOperand(1);
2148     if (C1 == From) C1 = To;
2149     if (C2 == From) C2 = To;
2150     if (getOpcode() == Instruction::ICmp)
2151       Replacement = ConstantExpr::getICmp(getPredicate(), C1, C2);
2152     else {
2153       assert(getOpcode() == Instruction::FCmp);
2154       Replacement = ConstantExpr::getFCmp(getPredicate(), C1, C2);
2155     }
2156   } else if (getNumOperands() == 2) {
2157     Constant *C1 = getOperand(0);
2158     Constant *C2 = getOperand(1);
2159     if (C1 == From) C1 = To;
2160     if (C2 == From) C2 = To;
2161     Replacement = ConstantExpr::get(getOpcode(), C1, C2, SubclassOptionalData);
2162   } else {
2163     llvm_unreachable("Unknown ConstantExpr type!");
2164     return;
2165   }
2166
2167   assert(Replacement != this && "I didn't contain From!");
2168
2169   // Everyone using this now uses the replacement.
2170   replaceAllUsesWith(Replacement);
2171
2172   // Delete the old constant!
2173   destroyConstant();
2174 }