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