1 //===-- Constants.cpp - Implement Constant nodes --------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Constant* classes.
12 //===----------------------------------------------------------------------===//
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"
38 //===----------------------------------------------------------------------===//
40 //===----------------------------------------------------------------------===//
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);
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));
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:
66 case Type::VectorTyID:
67 return ConstantAggregateZero::get(Ty);
69 // Function, Label, or Opaque type?
70 assert(!"Cannot create a null constant of that type!");
75 Constant *Constant::getIntegerValue(const Type *Ty, const APInt &V) {
76 const Type *ScalarTy = Ty->getScalarType();
78 // Create the base integer constant.
79 Constant *C = ConstantInt::get(Ty->getContext(), V);
81 // Convert an integer to a pointer, if necessary.
82 if (const PointerType *PTy = dyn_cast<PointerType>(ScalarTy))
83 C = ConstantExpr::getIntToPtr(C, PTy);
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));
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()));
97 SmallVector<Constant*, 16> 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));
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.
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: "
121 assert(isa<Constant>(V) && "References remain to Constant being destroyed");
122 Constant *CV = cast<Constant>(V);
123 CV->destroyConstant();
125 // The constant should remove itself from our use list...
126 assert((use_empty() || use_back() != V) && "Constant not removed!");
129 // Value has no outstanding references it is safe to delete it now...
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;
141 // ConstantExpr traps if any operands can trap.
142 for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
143 if (CE->getOperand(i)->canTrap())
146 // Otherwise, only specific operations can trap.
147 switch (CE->getOpcode()) {
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())
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))
171 if (UC->isConstantUsed())
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:
184 /// NoRelocation: This constant pool entry is guaranteed to never have a
185 /// relocation applied to it (because it holds a simple constant like
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.
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.
200 if (const BlockAddress *BA = dyn_cast<BlockAddress>(this))
201 return BA->getFunction()->getRelocationInfo();
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));
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())
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());
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!");
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));
243 const VectorType *VT = cast<VectorType>(getType());
244 if (isa<ConstantAggregateZero>(this)) {
245 Elts.assign(VT->getNumElements(),
246 Constant::getNullValue(VT->getElementType()));
250 if (isa<UndefValue>(this)) {
251 Elts.assign(VT->getNumElements(), UndefValue::get(VT->getElementType()));
255 // Unknown type, must be constant expr etc.
260 //===----------------------------------------------------------------------===//
262 //===----------------------------------------------------------------------===//
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");
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;
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;
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);
299 Constant *ConstantInt::get(const Type* Ty, uint64_t V, bool isSigned) {
300 Constant *C = get(cast<IntegerType>(Ty->getScalarType()),
303 // For vectors, broadcast the value.
304 if (const VectorType *VTy = dyn_cast<VectorType>(Ty))
305 return ConstantVector::get(SmallVector<Constant*,
306 16>(VTy->getNumElements(), C));
311 ConstantInt* ConstantInt::get(const IntegerType* Ty, uint64_t V,
313 return get(Ty->getContext(), APInt(Ty->getBitWidth(), V, isSigned));
316 ConstantInt* ConstantInt::getSigned(const IntegerType* Ty, int64_t V) {
317 return get(Ty, V, true);
320 Constant *ConstantInt::getSigned(const Type *Ty, int64_t V) {
321 return get(Ty, V, true);
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!");
329 // For vectors, broadcast the value.
330 if (const VectorType *VTy = dyn_cast<VectorType>(Ty))
331 return ConstantVector::get(
332 SmallVector<Constant *, 16>(VTy->getNumElements(), C));
337 ConstantInt* ConstantInt::get(const IntegerType* Ty, StringRef Str,
339 return get(Ty->getContext(), APInt(Ty->getBitWidth(), Str, radix));
342 //===----------------------------------------------------------------------===//
344 //===----------------------------------------------------------------------===//
346 static const fltSemantics *TypeToFloatSemantics(const Type *Ty) {
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;
356 assert(Ty->isPPC_FP128Ty() && "Unknown FP format");
357 return &APFloat::PPCDoubleDouble;
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();
368 FV.convert(*TypeToFloatSemantics(Ty->getScalarType()),
369 APFloat::rmNearestTiesToEven, &ignored);
370 Constant *C = get(Context, FV);
372 // For vectors, broadcast the value.
373 if (const VectorType *VTy = dyn_cast<VectorType>(Ty))
374 return ConstantVector::get(
375 SmallVector<Constant *, 16>(VTy->getNumElements(), C));
381 Constant *ConstantFP::get(const Type* Ty, StringRef Str) {
382 LLVMContext &Context = Ty->getContext();
384 APFloat FV(*TypeToFloatSemantics(Ty->getScalarType()), Str);
385 Constant *C = get(Context, FV);
387 // For vectors, broadcast the value.
388 if (const VectorType *VTy = dyn_cast<VectorType>(Ty))
389 return ConstantVector::get(
390 SmallVector<Constant *, 16>(VTy->getNumElements(), C));
396 ConstantFP* ConstantFP::getNegativeZero(const Type* Ty) {
397 LLVMContext &Context = Ty->getContext();
398 APFloat apf = cast <ConstantFP>(Constant::getNullValue(Ty))->getValueAPF();
400 return get(Context, apf);
404 Constant *ConstantFP::getZeroValueForNegation(const Type* Ty) {
405 if (const VectorType *PTy = dyn_cast<VectorType>(Ty))
406 if (PTy->getElementType()->isFloatingPointTy()) {
407 SmallVector<Constant*, 16> zeros(PTy->getNumElements(),
408 getNegativeZero(PTy->getElementType()));
409 return ConstantVector::get(zeros);
412 if (Ty->isFloatingPointTy())
413 return getNegativeZero(Ty);
415 return Constant::getNullValue(Ty);
419 // ConstantFP accessors.
420 ConstantFP* ConstantFP::get(LLVMContext &Context, const APFloat& V) {
421 DenseMapAPFloatKeyInfo::KeyTy Key(V);
423 LLVMContextImpl* pImpl = Context.pImpl;
425 ConstantFP *&Slot = pImpl->FPConstants[Key];
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);
438 assert(&V.getSemantics() == &APFloat::PPCDoubleDouble &&
439 "Unknown FP format");
440 Ty = Type::getPPC_FP128Ty(Context);
442 Slot = new ConstantFP(Ty, V);
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));
454 ConstantFP::ConstantFP(const Type *Ty, const APFloat& V)
455 : Constant(Ty, ConstantFPVal, 0, 0), Val(V) {
456 assert(&V.getSemantics() == TypeToFloatSemantics(Ty) &&
460 bool ConstantFP::isNullValue() const {
461 return Val.isZero() && !Val.isNegative();
464 bool ConstantFP::isExactlyValue(const APFloat& V) const {
465 return Val.bitwiseIsEqual(V);
468 //===----------------------------------------------------------------------===//
469 // ConstantXXX Classes
470 //===----------------------------------------------------------------------===//
473 ConstantArray::ConstantArray(const ArrayType *T,
474 const std::vector<Constant*> &V)
475 : Constant(T, ConstantArrayVal,
476 OperandTraits<ConstantArray>::op_end(this) - 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();
484 assert(C->getType() == T->getElementType() &&
485 "Initializer for array element doesn't match array element type!");
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");
496 LLVMContextImpl *pImpl = Ty->getContext().pImpl;
497 // If this is an all-zero array, return a ConstantAggregateZero object
500 if (!C->isNullValue())
501 return pImpl->ArrayConstants.getOrCreate(Ty, V);
503 for (unsigned i = 1, e = V.size(); i != e; ++i)
505 return pImpl->ArrayConstants.getOrCreate(Ty, V);
508 return ConstantAggregateZero::get(Ty);
512 Constant *ConstantArray::get(const ArrayType* T, Constant *const* Vals,
514 // FIXME: make this the primary ctor method.
515 return get(T, std::vector<Constant*>(Vals, Vals+NumVals));
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.
524 Constant *ConstantArray::get(LLVMContext &Context, StringRef Str,
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]));
531 // Add a null terminator to the string...
533 ElementVals.push_back(ConstantInt::get(Type::getInt8Ty(Context), 0));
536 ArrayType *ATy = ArrayType::get(Type::getInt8Ty(Context), ElementVals.size());
537 return get(ATy, ElementVals);
542 ConstantStruct::ConstantStruct(const StructType *T,
543 const std::vector<Constant*> &V)
544 : Constant(T, ConstantStructVal,
545 OperandTraits<ConstantStruct>::op_end(this) - 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();
553 assert(C->getType() == T->getElementType(I-V.begin()) &&
554 "Initializer for struct element doesn't match struct element type!");
559 // ConstantStruct accessors.
560 Constant *ConstantStruct::get(const StructType* T,
561 const std::vector<Constant*>& V) {
562 LLVMContextImpl* pImpl = T->getContext().pImpl;
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);
569 return ConstantAggregateZero::get(T);
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);
581 Constant *ConstantStruct::get(LLVMContext &Context,
582 Constant *const *Vals, unsigned NumVals,
584 // FIXME: make this the primary ctor method.
585 return get(Context, std::vector<Constant*>(Vals, Vals+NumVals), Packed);
588 ConstantVector::ConstantVector(const VectorType *T,
589 const std::vector<Constant*> &V)
590 : Constant(T, ConstantVectorVal,
591 OperandTraits<ConstantVector>::op_end(this) - V.size(),
593 Use *OL = OperandList;
594 for (std::vector<Constant*>::const_iterator I = V.begin(), E = V.end();
597 assert(C->getType() == T->getElementType() &&
598 "Initializer for vector element doesn't match vector element type!");
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 LLVMContextImpl *pImpl = T->getContext().pImpl;
609 // If this is an all-undef or all-zero vector, return a
610 // ConstantAggregateZero or UndefValue.
612 bool isZero = C->isNullValue();
613 bool isUndef = isa<UndefValue>(C);
615 if (isZero || isUndef) {
616 for (unsigned i = 1, e = V.size(); i != e; ++i)
618 isZero = isUndef = false;
624 return ConstantAggregateZero::get(T);
626 return UndefValue::get(T);
628 return pImpl->VectorConstants.getOrCreate(T, V);
631 Constant *ConstantVector::get(ArrayRef<Constant*> V) {
632 // FIXME: make this the primary ctor method.
633 assert(!V.empty() && "Vectors cannot be empty");
634 return get(VectorType::get(V.front()->getType(), V.size()), V.vec());
637 // Utility function for determining if a ConstantExpr is a CastOp or not. This
638 // can't be inline because we don't want to #include Instruction.h into
640 bool ConstantExpr::isCast() const {
641 return Instruction::isCast(getOpcode());
644 bool ConstantExpr::isCompare() const {
645 return getOpcode() == Instruction::ICmp || getOpcode() == Instruction::FCmp;
648 bool ConstantExpr::isGEPWithNoNotionalOverIndexing() const {
649 if (getOpcode() != Instruction::GetElementPtr) return false;
651 gep_type_iterator GEPI = gep_type_begin(this), E = gep_type_end(this);
652 User::const_op_iterator OI = llvm::next(this->op_begin());
654 // Skip the first index, as it has no static limit.
658 // The remaining indices must be compile-time known integers within the
659 // bounds of the corresponding notional static array types.
660 for (; GEPI != E; ++GEPI, ++OI) {
661 ConstantInt *CI = dyn_cast<ConstantInt>(*OI);
662 if (!CI) return false;
663 if (const ArrayType *ATy = dyn_cast<ArrayType>(*GEPI))
664 if (CI->getValue().getActiveBits() > 64 ||
665 CI->getZExtValue() >= ATy->getNumElements())
669 // All the indices checked out.
673 bool ConstantExpr::hasIndices() const {
674 return getOpcode() == Instruction::ExtractValue ||
675 getOpcode() == Instruction::InsertValue;
678 const SmallVector<unsigned, 4> &ConstantExpr::getIndices() const {
679 if (const ExtractValueConstantExpr *EVCE =
680 dyn_cast<ExtractValueConstantExpr>(this))
681 return EVCE->Indices;
683 return cast<InsertValueConstantExpr>(this)->Indices;
686 unsigned ConstantExpr::getPredicate() const {
687 assert(getOpcode() == Instruction::FCmp ||
688 getOpcode() == Instruction::ICmp);
689 return ((const CompareConstantExpr*)this)->predicate;
692 /// getWithOperandReplaced - Return a constant expression identical to this
693 /// one, but with the specified operand set to the specified value.
695 ConstantExpr::getWithOperandReplaced(unsigned OpNo, Constant *Op) const {
696 assert(OpNo < getNumOperands() && "Operand num is out of range!");
697 assert(Op->getType() == getOperand(OpNo)->getType() &&
698 "Replacing operand with value of different type!");
699 if (getOperand(OpNo) == Op)
700 return const_cast<ConstantExpr*>(this);
702 Constant *Op0, *Op1, *Op2;
703 switch (getOpcode()) {
704 case Instruction::Trunc:
705 case Instruction::ZExt:
706 case Instruction::SExt:
707 case Instruction::FPTrunc:
708 case Instruction::FPExt:
709 case Instruction::UIToFP:
710 case Instruction::SIToFP:
711 case Instruction::FPToUI:
712 case Instruction::FPToSI:
713 case Instruction::PtrToInt:
714 case Instruction::IntToPtr:
715 case Instruction::BitCast:
716 return ConstantExpr::getCast(getOpcode(), Op, getType());
717 case Instruction::Select:
718 Op0 = (OpNo == 0) ? Op : getOperand(0);
719 Op1 = (OpNo == 1) ? Op : getOperand(1);
720 Op2 = (OpNo == 2) ? Op : getOperand(2);
721 return ConstantExpr::getSelect(Op0, Op1, Op2);
722 case Instruction::InsertElement:
723 Op0 = (OpNo == 0) ? Op : getOperand(0);
724 Op1 = (OpNo == 1) ? Op : getOperand(1);
725 Op2 = (OpNo == 2) ? Op : getOperand(2);
726 return ConstantExpr::getInsertElement(Op0, Op1, Op2);
727 case Instruction::ExtractElement:
728 Op0 = (OpNo == 0) ? Op : getOperand(0);
729 Op1 = (OpNo == 1) ? Op : getOperand(1);
730 return ConstantExpr::getExtractElement(Op0, Op1);
731 case Instruction::ShuffleVector:
732 Op0 = (OpNo == 0) ? Op : getOperand(0);
733 Op1 = (OpNo == 1) ? Op : getOperand(1);
734 Op2 = (OpNo == 2) ? Op : getOperand(2);
735 return ConstantExpr::getShuffleVector(Op0, Op1, Op2);
736 case Instruction::GetElementPtr: {
737 SmallVector<Constant*, 8> Ops;
738 Ops.resize(getNumOperands()-1);
739 for (unsigned i = 1, e = getNumOperands(); i != e; ++i)
740 Ops[i-1] = getOperand(i);
742 return cast<GEPOperator>(this)->isInBounds() ?
743 ConstantExpr::getInBoundsGetElementPtr(Op, &Ops[0], Ops.size()) :
744 ConstantExpr::getGetElementPtr(Op, &Ops[0], Ops.size());
746 return cast<GEPOperator>(this)->isInBounds() ?
747 ConstantExpr::getInBoundsGetElementPtr(getOperand(0), &Ops[0],Ops.size()):
748 ConstantExpr::getGetElementPtr(getOperand(0), &Ops[0], Ops.size());
751 assert(getNumOperands() == 2 && "Must be binary operator?");
752 Op0 = (OpNo == 0) ? Op : getOperand(0);
753 Op1 = (OpNo == 1) ? Op : getOperand(1);
754 return ConstantExpr::get(getOpcode(), Op0, Op1, SubclassOptionalData);
758 /// getWithOperands - This returns the current constant expression with the
759 /// operands replaced with the specified values. The specified operands must
760 /// match count and type with the existing ones.
761 Constant *ConstantExpr::
762 getWithOperands(Constant *const *Ops, unsigned NumOps) const {
763 assert(NumOps == getNumOperands() && "Operand count mismatch!");
764 bool AnyChange = false;
765 for (unsigned i = 0; i != NumOps; ++i) {
766 assert(Ops[i]->getType() == getOperand(i)->getType() &&
767 "Operand type mismatch!");
768 AnyChange |= Ops[i] != getOperand(i);
770 if (!AnyChange) // No operands changed, return self.
771 return const_cast<ConstantExpr*>(this);
773 switch (getOpcode()) {
774 case Instruction::Trunc:
775 case Instruction::ZExt:
776 case Instruction::SExt:
777 case Instruction::FPTrunc:
778 case Instruction::FPExt:
779 case Instruction::UIToFP:
780 case Instruction::SIToFP:
781 case Instruction::FPToUI:
782 case Instruction::FPToSI:
783 case Instruction::PtrToInt:
784 case Instruction::IntToPtr:
785 case Instruction::BitCast:
786 return ConstantExpr::getCast(getOpcode(), Ops[0], getType());
787 case Instruction::Select:
788 return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2]);
789 case Instruction::InsertElement:
790 return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2]);
791 case Instruction::ExtractElement:
792 return ConstantExpr::getExtractElement(Ops[0], Ops[1]);
793 case Instruction::ShuffleVector:
794 return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]);
795 case Instruction::GetElementPtr:
796 return cast<GEPOperator>(this)->isInBounds() ?
797 ConstantExpr::getInBoundsGetElementPtr(Ops[0], &Ops[1], NumOps-1) :
798 ConstantExpr::getGetElementPtr(Ops[0], &Ops[1], NumOps-1);
799 case Instruction::ICmp:
800 case Instruction::FCmp:
801 return ConstantExpr::getCompare(getPredicate(), Ops[0], Ops[1]);
803 assert(getNumOperands() == 2 && "Must be binary operator?");
804 return ConstantExpr::get(getOpcode(), Ops[0], Ops[1], SubclassOptionalData);
809 //===----------------------------------------------------------------------===//
810 // isValueValidForType implementations
812 bool ConstantInt::isValueValidForType(const Type *Ty, uint64_t Val) {
813 unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth(); // assert okay
814 if (Ty == Type::getInt1Ty(Ty->getContext()))
815 return Val == 0 || Val == 1;
817 return true; // always true, has to fit in largest type
818 uint64_t Max = (1ll << NumBits) - 1;
822 bool ConstantInt::isValueValidForType(const Type *Ty, int64_t Val) {
823 unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth(); // assert okay
824 if (Ty == Type::getInt1Ty(Ty->getContext()))
825 return Val == 0 || Val == 1 || Val == -1;
827 return true; // always true, has to fit in largest type
828 int64_t Min = -(1ll << (NumBits-1));
829 int64_t Max = (1ll << (NumBits-1)) - 1;
830 return (Val >= Min && Val <= Max);
833 bool ConstantFP::isValueValidForType(const Type *Ty, const APFloat& Val) {
834 // convert modifies in place, so make a copy.
835 APFloat Val2 = APFloat(Val);
837 switch (Ty->getTypeID()) {
839 return false; // These can't be represented as floating point!
841 // FIXME rounding mode needs to be more flexible
842 case Type::FloatTyID: {
843 if (&Val2.getSemantics() == &APFloat::IEEEsingle)
845 Val2.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo);
848 case Type::DoubleTyID: {
849 if (&Val2.getSemantics() == &APFloat::IEEEsingle ||
850 &Val2.getSemantics() == &APFloat::IEEEdouble)
852 Val2.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
855 case Type::X86_FP80TyID:
856 return &Val2.getSemantics() == &APFloat::IEEEsingle ||
857 &Val2.getSemantics() == &APFloat::IEEEdouble ||
858 &Val2.getSemantics() == &APFloat::x87DoubleExtended;
859 case Type::FP128TyID:
860 return &Val2.getSemantics() == &APFloat::IEEEsingle ||
861 &Val2.getSemantics() == &APFloat::IEEEdouble ||
862 &Val2.getSemantics() == &APFloat::IEEEquad;
863 case Type::PPC_FP128TyID:
864 return &Val2.getSemantics() == &APFloat::IEEEsingle ||
865 &Val2.getSemantics() == &APFloat::IEEEdouble ||
866 &Val2.getSemantics() == &APFloat::PPCDoubleDouble;
870 //===----------------------------------------------------------------------===//
871 // Factory Function Implementation
873 ConstantAggregateZero* ConstantAggregateZero::get(const Type* Ty) {
874 assert((Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()) &&
875 "Cannot create an aggregate zero of non-aggregate type!");
877 LLVMContextImpl *pImpl = Ty->getContext().pImpl;
878 return pImpl->AggZeroConstants.getOrCreate(Ty, 0);
881 /// destroyConstant - Remove the constant from the constant table...
883 void ConstantAggregateZero::destroyConstant() {
884 getRawType()->getContext().pImpl->AggZeroConstants.remove(this);
885 destroyConstantImpl();
888 /// destroyConstant - Remove the constant from the constant table...
890 void ConstantArray::destroyConstant() {
891 getRawType()->getContext().pImpl->ArrayConstants.remove(this);
892 destroyConstantImpl();
895 /// isString - This method returns true if the array is an array of i8, and
896 /// if the elements of the array are all ConstantInt's.
897 bool ConstantArray::isString() const {
898 // Check the element type for i8...
899 if (!getType()->getElementType()->isIntegerTy(8))
901 // Check the elements to make sure they are all integers, not constant
903 for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
904 if (!isa<ConstantInt>(getOperand(i)))
909 /// isCString - This method returns true if the array is a string (see
910 /// isString) and it ends in a null byte \\0 and does not contains any other
911 /// null bytes except its terminator.
912 bool ConstantArray::isCString() const {
913 // Check the element type for i8...
914 if (!getType()->getElementType()->isIntegerTy(8))
917 // Last element must be a null.
918 if (!getOperand(getNumOperands()-1)->isNullValue())
920 // Other elements must be non-null integers.
921 for (unsigned i = 0, e = getNumOperands()-1; i != e; ++i) {
922 if (!isa<ConstantInt>(getOperand(i)))
924 if (getOperand(i)->isNullValue())
931 /// getAsString - If the sub-element type of this array is i8
932 /// then this method converts the array to an std::string and returns it.
933 /// Otherwise, it asserts out.
935 std::string ConstantArray::getAsString() const {
936 assert(isString() && "Not a string!");
938 Result.reserve(getNumOperands());
939 for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
940 Result.push_back((char)cast<ConstantInt>(getOperand(i))->getZExtValue());
945 //---- ConstantStruct::get() implementation...
952 // destroyConstant - Remove the constant from the constant table...
954 void ConstantStruct::destroyConstant() {
955 getRawType()->getContext().pImpl->StructConstants.remove(this);
956 destroyConstantImpl();
959 // destroyConstant - Remove the constant from the constant table...
961 void ConstantVector::destroyConstant() {
962 getRawType()->getContext().pImpl->VectorConstants.remove(this);
963 destroyConstantImpl();
966 /// This function will return true iff every element in this vector constant
967 /// is set to all ones.
968 /// @returns true iff this constant's emements are all set to all ones.
969 /// @brief Determine if the value is all ones.
970 bool ConstantVector::isAllOnesValue() const {
971 // Check out first element.
972 const Constant *Elt = getOperand(0);
973 const ConstantInt *CI = dyn_cast<ConstantInt>(Elt);
974 if (!CI || !CI->isAllOnesValue()) return false;
975 // Then make sure all remaining elements point to the same value.
976 for (unsigned I = 1, E = getNumOperands(); I < E; ++I) {
977 if (getOperand(I) != Elt) return false;
982 /// getSplatValue - If this is a splat constant, where all of the
983 /// elements have the same value, return that value. Otherwise return null.
984 Constant *ConstantVector::getSplatValue() const {
985 // Check out first element.
986 Constant *Elt = getOperand(0);
987 // Then make sure all remaining elements point to the same value.
988 for (unsigned I = 1, E = getNumOperands(); I < E; ++I)
989 if (getOperand(I) != Elt) return 0;
993 //---- ConstantPointerNull::get() implementation.
996 ConstantPointerNull *ConstantPointerNull::get(const PointerType *Ty) {
997 return Ty->getContext().pImpl->NullPtrConstants.getOrCreate(Ty, 0);
1000 // destroyConstant - Remove the constant from the constant table...
1002 void ConstantPointerNull::destroyConstant() {
1003 getRawType()->getContext().pImpl->NullPtrConstants.remove(this);
1004 destroyConstantImpl();
1008 //---- UndefValue::get() implementation.
1011 UndefValue *UndefValue::get(const Type *Ty) {
1012 return Ty->getContext().pImpl->UndefValueConstants.getOrCreate(Ty, 0);
1015 // destroyConstant - Remove the constant from the constant table.
1017 void UndefValue::destroyConstant() {
1018 getRawType()->getContext().pImpl->UndefValueConstants.remove(this);
1019 destroyConstantImpl();
1022 //---- BlockAddress::get() implementation.
1025 BlockAddress *BlockAddress::get(BasicBlock *BB) {
1026 assert(BB->getParent() != 0 && "Block must have a parent");
1027 return get(BB->getParent(), BB);
1030 BlockAddress *BlockAddress::get(Function *F, BasicBlock *BB) {
1032 F->getContext().pImpl->BlockAddresses[std::make_pair(F, BB)];
1034 BA = new BlockAddress(F, BB);
1036 assert(BA->getFunction() == F && "Basic block moved between functions");
1040 BlockAddress::BlockAddress(Function *F, BasicBlock *BB)
1041 : Constant(Type::getInt8PtrTy(F->getContext()), Value::BlockAddressVal,
1045 BB->AdjustBlockAddressRefCount(1);
1049 // destroyConstant - Remove the constant from the constant table.
1051 void BlockAddress::destroyConstant() {
1052 getFunction()->getRawType()->getContext().pImpl
1053 ->BlockAddresses.erase(std::make_pair(getFunction(), getBasicBlock()));
1054 getBasicBlock()->AdjustBlockAddressRefCount(-1);
1055 destroyConstantImpl();
1058 void BlockAddress::replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U) {
1059 // This could be replacing either the Basic Block or the Function. In either
1060 // case, we have to remove the map entry.
1061 Function *NewF = getFunction();
1062 BasicBlock *NewBB = getBasicBlock();
1065 NewF = cast<Function>(To);
1067 NewBB = cast<BasicBlock>(To);
1069 // See if the 'new' entry already exists, if not, just update this in place
1070 // and return early.
1071 BlockAddress *&NewBA =
1072 getContext().pImpl->BlockAddresses[std::make_pair(NewF, NewBB)];
1074 getBasicBlock()->AdjustBlockAddressRefCount(-1);
1076 // Remove the old entry, this can't cause the map to rehash (just a
1077 // tombstone will get added).
1078 getContext().pImpl->BlockAddresses.erase(std::make_pair(getFunction(),
1081 setOperand(0, NewF);
1082 setOperand(1, NewBB);
1083 getBasicBlock()->AdjustBlockAddressRefCount(1);
1087 // Otherwise, I do need to replace this with an existing value.
1088 assert(NewBA != this && "I didn't contain From!");
1090 // Everyone using this now uses the replacement.
1091 uncheckedReplaceAllUsesWith(NewBA);
1096 //---- ConstantExpr::get() implementations.
1099 /// This is a utility function to handle folding of casts and lookup of the
1100 /// cast in the ExprConstants map. It is used by the various get* methods below.
1101 static inline Constant *getFoldedCast(
1102 Instruction::CastOps opc, Constant *C, const Type *Ty) {
1103 assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
1104 // Fold a few common cases
1105 if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty))
1108 LLVMContextImpl *pImpl = Ty->getContext().pImpl;
1110 // Look up the constant in the table first to ensure uniqueness
1111 std::vector<Constant*> argVec(1, C);
1112 ExprMapKeyType Key(opc, argVec);
1114 return pImpl->ExprConstants.getOrCreate(Ty, Key);
1117 Constant *ConstantExpr::getCast(unsigned oc, Constant *C, const Type *Ty) {
1118 Instruction::CastOps opc = Instruction::CastOps(oc);
1119 assert(Instruction::isCast(opc) && "opcode out of range");
1120 assert(C && Ty && "Null arguments to getCast");
1121 assert(CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!");
1125 llvm_unreachable("Invalid cast opcode");
1127 case Instruction::Trunc: return getTrunc(C, Ty);
1128 case Instruction::ZExt: return getZExt(C, Ty);
1129 case Instruction::SExt: return getSExt(C, Ty);
1130 case Instruction::FPTrunc: return getFPTrunc(C, Ty);
1131 case Instruction::FPExt: return getFPExtend(C, Ty);
1132 case Instruction::UIToFP: return getUIToFP(C, Ty);
1133 case Instruction::SIToFP: return getSIToFP(C, Ty);
1134 case Instruction::FPToUI: return getFPToUI(C, Ty);
1135 case Instruction::FPToSI: return getFPToSI(C, Ty);
1136 case Instruction::PtrToInt: return getPtrToInt(C, Ty);
1137 case Instruction::IntToPtr: return getIntToPtr(C, Ty);
1138 case Instruction::BitCast: return getBitCast(C, Ty);
1143 Constant *ConstantExpr::getZExtOrBitCast(Constant *C, const Type *Ty) {
1144 if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
1145 return getBitCast(C, Ty);
1146 return getZExt(C, Ty);
1149 Constant *ConstantExpr::getSExtOrBitCast(Constant *C, const Type *Ty) {
1150 if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
1151 return getBitCast(C, Ty);
1152 return getSExt(C, Ty);
1155 Constant *ConstantExpr::getTruncOrBitCast(Constant *C, const Type *Ty) {
1156 if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
1157 return getBitCast(C, Ty);
1158 return getTrunc(C, Ty);
1161 Constant *ConstantExpr::getPointerCast(Constant *S, const Type *Ty) {
1162 assert(S->getType()->isPointerTy() && "Invalid cast");
1163 assert((Ty->isIntegerTy() || Ty->isPointerTy()) && "Invalid cast");
1165 if (Ty->isIntegerTy())
1166 return getPtrToInt(S, Ty);
1167 return getBitCast(S, Ty);
1170 Constant *ConstantExpr::getIntegerCast(Constant *C, const Type *Ty,
1172 assert(C->getType()->isIntOrIntVectorTy() &&
1173 Ty->isIntOrIntVectorTy() && "Invalid cast");
1174 unsigned SrcBits = C->getType()->getScalarSizeInBits();
1175 unsigned DstBits = Ty->getScalarSizeInBits();
1176 Instruction::CastOps opcode =
1177 (SrcBits == DstBits ? Instruction::BitCast :
1178 (SrcBits > DstBits ? Instruction::Trunc :
1179 (isSigned ? Instruction::SExt : Instruction::ZExt)));
1180 return getCast(opcode, C, Ty);
1183 Constant *ConstantExpr::getFPCast(Constant *C, const Type *Ty) {
1184 assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
1186 unsigned SrcBits = C->getType()->getScalarSizeInBits();
1187 unsigned DstBits = Ty->getScalarSizeInBits();
1188 if (SrcBits == DstBits)
1189 return C; // Avoid a useless cast
1190 Instruction::CastOps opcode =
1191 (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt);
1192 return getCast(opcode, C, Ty);
1195 Constant *ConstantExpr::getTrunc(Constant *C, const Type *Ty) {
1197 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1198 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1200 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1201 assert(C->getType()->isIntOrIntVectorTy() && "Trunc operand must be integer");
1202 assert(Ty->isIntOrIntVectorTy() && "Trunc produces only integral");
1203 assert(C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
1204 "SrcTy must be larger than DestTy for Trunc!");
1206 return getFoldedCast(Instruction::Trunc, C, Ty);
1209 Constant *ConstantExpr::getSExt(Constant *C, const Type *Ty) {
1211 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1212 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1214 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1215 assert(C->getType()->isIntOrIntVectorTy() && "SExt operand must be integral");
1216 assert(Ty->isIntOrIntVectorTy() && "SExt produces only integer");
1217 assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
1218 "SrcTy must be smaller than DestTy for SExt!");
1220 return getFoldedCast(Instruction::SExt, C, Ty);
1223 Constant *ConstantExpr::getZExt(Constant *C, const Type *Ty) {
1225 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1226 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1228 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1229 assert(C->getType()->isIntOrIntVectorTy() && "ZEXt operand must be integral");
1230 assert(Ty->isIntOrIntVectorTy() && "ZExt produces only integer");
1231 assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
1232 "SrcTy must be smaller than DestTy for ZExt!");
1234 return getFoldedCast(Instruction::ZExt, C, Ty);
1237 Constant *ConstantExpr::getFPTrunc(Constant *C, const Type *Ty) {
1239 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1240 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1242 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1243 assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
1244 C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
1245 "This is an illegal floating point truncation!");
1246 return getFoldedCast(Instruction::FPTrunc, C, Ty);
1249 Constant *ConstantExpr::getFPExtend(Constant *C, const Type *Ty) {
1251 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1252 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1254 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1255 assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
1256 C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
1257 "This is an illegal floating point extension!");
1258 return getFoldedCast(Instruction::FPExt, C, Ty);
1261 Constant *ConstantExpr::getUIToFP(Constant *C, const Type *Ty) {
1263 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1264 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1266 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1267 assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
1268 "This is an illegal uint to floating point cast!");
1269 return getFoldedCast(Instruction::UIToFP, C, Ty);
1272 Constant *ConstantExpr::getSIToFP(Constant *C, const Type *Ty) {
1274 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1275 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1277 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1278 assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
1279 "This is an illegal sint to floating point cast!");
1280 return getFoldedCast(Instruction::SIToFP, C, Ty);
1283 Constant *ConstantExpr::getFPToUI(Constant *C, const Type *Ty) {
1285 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1286 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1288 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1289 assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
1290 "This is an illegal floating point to uint cast!");
1291 return getFoldedCast(Instruction::FPToUI, C, Ty);
1294 Constant *ConstantExpr::getFPToSI(Constant *C, const Type *Ty) {
1296 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1297 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1299 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
1300 assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
1301 "This is an illegal floating point to sint cast!");
1302 return getFoldedCast(Instruction::FPToSI, C, Ty);
1305 Constant *ConstantExpr::getPtrToInt(Constant *C, const Type *DstTy) {
1306 assert(C->getType()->isPointerTy() && "PtrToInt source must be pointer");
1307 assert(DstTy->isIntegerTy() && "PtrToInt destination must be integral");
1308 return getFoldedCast(Instruction::PtrToInt, C, DstTy);
1311 Constant *ConstantExpr::getIntToPtr(Constant *C, const Type *DstTy) {
1312 assert(C->getType()->isIntegerTy() && "IntToPtr source must be integral");
1313 assert(DstTy->isPointerTy() && "IntToPtr destination must be a pointer");
1314 return getFoldedCast(Instruction::IntToPtr, C, DstTy);
1317 Constant *ConstantExpr::getBitCast(Constant *C, const Type *DstTy) {
1318 assert(CastInst::castIsValid(Instruction::BitCast, C, DstTy) &&
1319 "Invalid constantexpr bitcast!");
1321 // It is common to ask for a bitcast of a value to its own type, handle this
1323 if (C->getType() == DstTy) return C;
1325 return getFoldedCast(Instruction::BitCast, C, DstTy);
1328 Constant *ConstantExpr::getTy(const Type *ReqTy, unsigned Opcode,
1329 Constant *C1, Constant *C2,
1331 // Check the operands for consistency first
1332 assert(Opcode >= Instruction::BinaryOpsBegin &&
1333 Opcode < Instruction::BinaryOpsEnd &&
1334 "Invalid opcode in binary constant expression");
1335 assert(C1->getType() == C2->getType() &&
1336 "Operand types in binary constant expression should match");
1338 if (ReqTy == C1->getType() || ReqTy == Type::getInt1Ty(ReqTy->getContext()))
1339 if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))
1340 return FC; // Fold a few common cases...
1342 std::vector<Constant*> argVec(1, C1); argVec.push_back(C2);
1343 ExprMapKeyType Key(Opcode, argVec, 0, Flags);
1345 LLVMContextImpl *pImpl = ReqTy->getContext().pImpl;
1346 return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
1349 Constant *ConstantExpr::getCompareTy(unsigned short predicate,
1350 Constant *C1, Constant *C2) {
1351 switch (predicate) {
1352 default: llvm_unreachable("Invalid CmpInst predicate");
1353 case CmpInst::FCMP_FALSE: case CmpInst::FCMP_OEQ: case CmpInst::FCMP_OGT:
1354 case CmpInst::FCMP_OGE: case CmpInst::FCMP_OLT: case CmpInst::FCMP_OLE:
1355 case CmpInst::FCMP_ONE: case CmpInst::FCMP_ORD: case CmpInst::FCMP_UNO:
1356 case CmpInst::FCMP_UEQ: case CmpInst::FCMP_UGT: case CmpInst::FCMP_UGE:
1357 case CmpInst::FCMP_ULT: case CmpInst::FCMP_ULE: case CmpInst::FCMP_UNE:
1358 case CmpInst::FCMP_TRUE:
1359 return getFCmp(predicate, C1, C2);
1361 case CmpInst::ICMP_EQ: case CmpInst::ICMP_NE: case CmpInst::ICMP_UGT:
1362 case CmpInst::ICMP_UGE: case CmpInst::ICMP_ULT: case CmpInst::ICMP_ULE:
1363 case CmpInst::ICMP_SGT: case CmpInst::ICMP_SGE: case CmpInst::ICMP_SLT:
1364 case CmpInst::ICMP_SLE:
1365 return getICmp(predicate, C1, C2);
1369 Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2,
1373 case Instruction::Add:
1374 case Instruction::Sub:
1375 case Instruction::Mul:
1376 assert(C1->getType() == C2->getType() && "Op types should be identical!");
1377 assert(C1->getType()->isIntOrIntVectorTy() &&
1378 "Tried to create an integer operation on a non-integer type!");
1380 case Instruction::FAdd:
1381 case Instruction::FSub:
1382 case Instruction::FMul:
1383 assert(C1->getType() == C2->getType() && "Op types should be identical!");
1384 assert(C1->getType()->isFPOrFPVectorTy() &&
1385 "Tried to create a floating-point operation on a "
1386 "non-floating-point type!");
1388 case Instruction::UDiv:
1389 case Instruction::SDiv:
1390 assert(C1->getType() == C2->getType() && "Op types should be identical!");
1391 assert(C1->getType()->isIntOrIntVectorTy() &&
1392 "Tried to create an arithmetic operation on a non-arithmetic type!");
1394 case Instruction::FDiv:
1395 assert(C1->getType() == C2->getType() && "Op types should be identical!");
1396 assert(C1->getType()->isFPOrFPVectorTy() &&
1397 "Tried to create an arithmetic operation on a non-arithmetic type!");
1399 case Instruction::URem:
1400 case Instruction::SRem:
1401 assert(C1->getType() == C2->getType() && "Op types should be identical!");
1402 assert(C1->getType()->isIntOrIntVectorTy() &&
1403 "Tried to create an arithmetic operation on a non-arithmetic type!");
1405 case Instruction::FRem:
1406 assert(C1->getType() == C2->getType() && "Op types should be identical!");
1407 assert(C1->getType()->isFPOrFPVectorTy() &&
1408 "Tried to create an arithmetic operation on a non-arithmetic type!");
1410 case Instruction::And:
1411 case Instruction::Or:
1412 case Instruction::Xor:
1413 assert(C1->getType() == C2->getType() && "Op types should be identical!");
1414 assert(C1->getType()->isIntOrIntVectorTy() &&
1415 "Tried to create a logical operation on a non-integral type!");
1417 case Instruction::Shl:
1418 case Instruction::LShr:
1419 case Instruction::AShr:
1420 assert(C1->getType() == C2->getType() && "Op types should be identical!");
1421 assert(C1->getType()->isIntOrIntVectorTy() &&
1422 "Tried to create a shift operation on a non-integer type!");
1429 return getTy(C1->getType(), Opcode, C1, C2, Flags);
1432 Constant *ConstantExpr::getSizeOf(const Type* Ty) {
1433 // sizeof is implemented as: (i64) gep (Ty*)null, 1
1434 // Note that a non-inbounds gep is used, as null isn't within any object.
1435 Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
1436 Constant *GEP = getGetElementPtr(
1437 Constant::getNullValue(PointerType::getUnqual(Ty)), &GEPIdx, 1);
1438 return getPtrToInt(GEP,
1439 Type::getInt64Ty(Ty->getContext()));
1442 Constant *ConstantExpr::getAlignOf(const Type* Ty) {
1443 // alignof is implemented as: (i64) gep ({i1,Ty}*)null, 0, 1
1444 // Note that a non-inbounds gep is used, as null isn't within any object.
1445 const Type *AligningTy = StructType::get(Ty->getContext(),
1446 Type::getInt1Ty(Ty->getContext()), Ty, NULL);
1447 Constant *NullPtr = Constant::getNullValue(AligningTy->getPointerTo());
1448 Constant *Zero = ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0);
1449 Constant *One = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
1450 Constant *Indices[2] = { Zero, One };
1451 Constant *GEP = getGetElementPtr(NullPtr, Indices, 2);
1452 return getPtrToInt(GEP,
1453 Type::getInt64Ty(Ty->getContext()));
1456 Constant *ConstantExpr::getOffsetOf(const StructType* STy, unsigned FieldNo) {
1457 return getOffsetOf(STy, ConstantInt::get(Type::getInt32Ty(STy->getContext()),
1461 Constant *ConstantExpr::getOffsetOf(const Type* Ty, Constant *FieldNo) {
1462 // offsetof is implemented as: (i64) gep (Ty*)null, 0, FieldNo
1463 // Note that a non-inbounds gep is used, as null isn't within any object.
1464 Constant *GEPIdx[] = {
1465 ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0),
1468 Constant *GEP = getGetElementPtr(
1469 Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx, 2);
1470 return getPtrToInt(GEP,
1471 Type::getInt64Ty(Ty->getContext()));
1474 Constant *ConstantExpr::getCompare(unsigned short pred,
1475 Constant *C1, Constant *C2) {
1476 assert(C1->getType() == C2->getType() && "Op types should be identical!");
1477 return getCompareTy(pred, C1, C2);
1480 Constant *ConstantExpr::getSelectTy(const Type *ReqTy, Constant *C,
1481 Constant *V1, Constant *V2) {
1482 assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands");
1484 if (ReqTy == V1->getType())
1485 if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2))
1486 return SC; // Fold common cases
1488 std::vector<Constant*> argVec(3, C);
1491 ExprMapKeyType Key(Instruction::Select, argVec);
1493 LLVMContextImpl *pImpl = ReqTy->getContext().pImpl;
1494 return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
1497 template<typename IndexTy>
1498 Constant *ConstantExpr::getGetElementPtrTy(const Type *ReqTy, Constant *C,
1499 IndexTy const *Idxs,
1500 unsigned NumIdx, bool InBounds) {
1501 assert(GetElementPtrInst::getIndexedType(C->getType(), Idxs,
1503 cast<PointerType>(ReqTy)->getElementType() &&
1504 "GEP indices invalid!");
1506 if (Constant *FC = ConstantFoldGetElementPtr(C, InBounds, Idxs, NumIdx))
1507 return FC; // Fold a few common cases.
1509 assert(C->getType()->isPointerTy() &&
1510 "Non-pointer type for constant GetElementPtr expression");
1511 // Look up the constant in the table first to ensure uniqueness
1512 std::vector<Constant*> ArgVec;
1513 ArgVec.reserve(NumIdx+1);
1514 ArgVec.push_back(C);
1515 for (unsigned i = 0; i != NumIdx; ++i)
1516 ArgVec.push_back(cast<Constant>(Idxs[i]));
1517 const ExprMapKeyType Key(Instruction::GetElementPtr, ArgVec, 0,
1518 InBounds ? GEPOperator::IsInBounds : 0);
1520 LLVMContextImpl *pImpl = ReqTy->getContext().pImpl;
1521 return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
1524 template<typename IndexTy>
1525 Constant *ConstantExpr::getGetElementPtrImpl(Constant *C, IndexTy const *Idxs,
1526 unsigned NumIdx, bool InBounds) {
1527 // Get the result type of the getelementptr!
1529 GetElementPtrInst::getIndexedType(C->getType(), Idxs, Idxs+NumIdx);
1530 assert(Ty && "GEP indices invalid!");
1531 unsigned As = cast<PointerType>(C->getType())->getAddressSpace();
1532 return getGetElementPtrTy(PointerType::get(Ty, As), C, Idxs, NumIdx,InBounds);
1535 Constant *ConstantExpr::getGetElementPtr(Constant *C, Value* const *Idxs,
1536 unsigned NumIdx, bool InBounds) {
1537 return getGetElementPtrImpl(C, Idxs, NumIdx, InBounds);
1540 Constant *ConstantExpr::getGetElementPtr(Constant *C, Constant *const *Idxs,
1541 unsigned NumIdx, bool InBounds) {
1542 return getGetElementPtrImpl(C, Idxs, NumIdx, InBounds);
1546 ConstantExpr::getICmp(unsigned short pred, Constant *LHS, Constant *RHS) {
1547 assert(LHS->getType() == RHS->getType());
1548 assert(pred >= ICmpInst::FIRST_ICMP_PREDICATE &&
1549 pred <= ICmpInst::LAST_ICMP_PREDICATE && "Invalid ICmp Predicate");
1551 if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
1552 return FC; // Fold a few common cases...
1554 // Look up the constant in the table first to ensure uniqueness
1555 std::vector<Constant*> ArgVec;
1556 ArgVec.push_back(LHS);
1557 ArgVec.push_back(RHS);
1558 // Get the key type with both the opcode and predicate
1559 const ExprMapKeyType Key(Instruction::ICmp, ArgVec, pred);
1561 const Type *ResultTy = Type::getInt1Ty(LHS->getContext());
1562 if (const VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
1563 ResultTy = VectorType::get(ResultTy, VT->getNumElements());
1565 LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
1566 return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
1570 ConstantExpr::getFCmp(unsigned short pred, Constant *LHS, Constant *RHS) {
1571 assert(LHS->getType() == RHS->getType());
1572 assert(pred <= FCmpInst::LAST_FCMP_PREDICATE && "Invalid FCmp Predicate");
1574 if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
1575 return FC; // Fold a few common cases...
1577 // Look up the constant in the table first to ensure uniqueness
1578 std::vector<Constant*> ArgVec;
1579 ArgVec.push_back(LHS);
1580 ArgVec.push_back(RHS);
1581 // Get the key type with both the opcode and predicate
1582 const ExprMapKeyType Key(Instruction::FCmp, ArgVec, pred);
1584 const Type *ResultTy = Type::getInt1Ty(LHS->getContext());
1585 if (const VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
1586 ResultTy = VectorType::get(ResultTy, VT->getNumElements());
1588 LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
1589 return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
1592 Constant *ConstantExpr::getExtractElementTy(const Type *ReqTy, Constant *Val,
1594 if (Constant *FC = ConstantFoldExtractElementInstruction(Val, Idx))
1595 return FC; // Fold a few common cases.
1596 // Look up the constant in the table first to ensure uniqueness
1597 std::vector<Constant*> ArgVec(1, Val);
1598 ArgVec.push_back(Idx);
1599 const ExprMapKeyType Key(Instruction::ExtractElement,ArgVec);
1601 LLVMContextImpl *pImpl = ReqTy->getContext().pImpl;
1602 return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
1605 Constant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx) {
1606 assert(Val->getType()->isVectorTy() &&
1607 "Tried to create extractelement operation on non-vector type!");
1608 assert(Idx->getType()->isIntegerTy(32) &&
1609 "Extractelement index must be i32 type!");
1610 return getExtractElementTy(cast<VectorType>(Val->getType())->getElementType(),
1614 Constant *ConstantExpr::getInsertElementTy(const Type *ReqTy, Constant *Val,
1615 Constant *Elt, Constant *Idx) {
1616 if (Constant *FC = ConstantFoldInsertElementInstruction(Val, Elt, Idx))
1617 return FC; // Fold a few common cases.
1618 // Look up the constant in the table first to ensure uniqueness
1619 std::vector<Constant*> ArgVec(1, Val);
1620 ArgVec.push_back(Elt);
1621 ArgVec.push_back(Idx);
1622 const ExprMapKeyType Key(Instruction::InsertElement,ArgVec);
1624 LLVMContextImpl *pImpl = ReqTy->getContext().pImpl;
1625 return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
1628 Constant *ConstantExpr::getInsertElement(Constant *Val, Constant *Elt,
1630 assert(Val->getType()->isVectorTy() &&
1631 "Tried to create insertelement operation on non-vector type!");
1632 assert(Elt->getType() == cast<VectorType>(Val->getType())->getElementType()
1633 && "Insertelement types must match!");
1634 assert(Idx->getType()->isIntegerTy(32) &&
1635 "Insertelement index must be i32 type!");
1636 return getInsertElementTy(Val->getType(), Val, Elt, Idx);
1639 Constant *ConstantExpr::getShuffleVectorTy(const Type *ReqTy, Constant *V1,
1640 Constant *V2, Constant *Mask) {
1641 if (Constant *FC = ConstantFoldShuffleVectorInstruction(V1, V2, Mask))
1642 return FC; // Fold a few common cases...
1643 // Look up the constant in the table first to ensure uniqueness
1644 std::vector<Constant*> ArgVec(1, V1);
1645 ArgVec.push_back(V2);
1646 ArgVec.push_back(Mask);
1647 const ExprMapKeyType Key(Instruction::ShuffleVector,ArgVec);
1649 LLVMContextImpl *pImpl = ReqTy->getContext().pImpl;
1650 return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
1653 Constant *ConstantExpr::getShuffleVector(Constant *V1, Constant *V2,
1655 assert(ShuffleVectorInst::isValidOperands(V1, V2, Mask) &&
1656 "Invalid shuffle vector constant expr operands!");
1658 unsigned NElts = cast<VectorType>(Mask->getType())->getNumElements();
1659 const Type *EltTy = cast<VectorType>(V1->getType())->getElementType();
1660 const Type *ShufTy = VectorType::get(EltTy, NElts);
1661 return getShuffleVectorTy(ShufTy, V1, V2, Mask);
1664 Constant *ConstantExpr::getInsertValueTy(const Type *ReqTy, Constant *Agg,
1666 const unsigned *Idxs, unsigned NumIdx) {
1667 assert(ExtractValueInst::getIndexedType(Agg->getType(), Idxs,
1668 Idxs+NumIdx) == Val->getType() &&
1669 "insertvalue indices invalid!");
1670 assert(Agg->getType() == ReqTy &&
1671 "insertvalue type invalid!");
1672 assert(Agg->getType()->isFirstClassType() &&
1673 "Non-first-class type for constant InsertValue expression");
1674 Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs, NumIdx);
1675 assert(FC && "InsertValue constant expr couldn't be folded!");
1679 Constant *ConstantExpr::getInsertValue(Constant *Agg, Constant *Val,
1680 const unsigned *IdxList, unsigned NumIdx) {
1681 assert(Agg->getType()->isFirstClassType() &&
1682 "Tried to create insertelement operation on non-first-class type!");
1684 const Type *ReqTy = Agg->getType();
1687 ExtractValueInst::getIndexedType(Agg->getType(), IdxList, IdxList+NumIdx);
1689 assert(ValTy == Val->getType() && "insertvalue indices invalid!");
1690 return getInsertValueTy(ReqTy, Agg, Val, IdxList, NumIdx);
1693 Constant *ConstantExpr::getExtractValueTy(const Type *ReqTy, Constant *Agg,
1694 const unsigned *Idxs, unsigned NumIdx) {
1695 assert(ExtractValueInst::getIndexedType(Agg->getType(), Idxs,
1696 Idxs+NumIdx) == ReqTy &&
1697 "extractvalue indices invalid!");
1698 assert(Agg->getType()->isFirstClassType() &&
1699 "Non-first-class type for constant extractvalue expression");
1700 Constant *FC = ConstantFoldExtractValueInstruction(Agg, Idxs, NumIdx);
1701 assert(FC && "ExtractValue constant expr couldn't be folded!");
1705 Constant *ConstantExpr::getExtractValue(Constant *Agg,
1706 const unsigned *IdxList, unsigned NumIdx) {
1707 assert(Agg->getType()->isFirstClassType() &&
1708 "Tried to create extractelement operation on non-first-class type!");
1711 ExtractValueInst::getIndexedType(Agg->getType(), IdxList, IdxList+NumIdx);
1712 assert(ReqTy && "extractvalue indices invalid!");
1713 return getExtractValueTy(ReqTy, Agg, IdxList, NumIdx);
1716 Constant *ConstantExpr::getNeg(Constant *C, bool HasNUW, bool HasNSW) {
1717 assert(C->getType()->isIntOrIntVectorTy() &&
1718 "Cannot NEG a nonintegral value!");
1719 return getSub(ConstantFP::getZeroValueForNegation(C->getType()),
1723 Constant *ConstantExpr::getFNeg(Constant *C) {
1724 assert(C->getType()->isFPOrFPVectorTy() &&
1725 "Cannot FNEG a non-floating-point value!");
1726 return getFSub(ConstantFP::getZeroValueForNegation(C->getType()), C);
1729 Constant *ConstantExpr::getNot(Constant *C) {
1730 assert(C->getType()->isIntOrIntVectorTy() &&
1731 "Cannot NOT a nonintegral value!");
1732 return get(Instruction::Xor, C, Constant::getAllOnesValue(C->getType()));
1735 Constant *ConstantExpr::getAdd(Constant *C1, Constant *C2,
1736 bool HasNUW, bool HasNSW) {
1737 unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
1738 (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0);
1739 return get(Instruction::Add, C1, C2, Flags);
1742 Constant *ConstantExpr::getFAdd(Constant *C1, Constant *C2) {
1743 return get(Instruction::FAdd, C1, C2);
1746 Constant *ConstantExpr::getSub(Constant *C1, Constant *C2,
1747 bool HasNUW, bool HasNSW) {
1748 unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
1749 (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0);
1750 return get(Instruction::Sub, C1, C2, Flags);
1753 Constant *ConstantExpr::getFSub(Constant *C1, Constant *C2) {
1754 return get(Instruction::FSub, C1, C2);
1757 Constant *ConstantExpr::getMul(Constant *C1, Constant *C2,
1758 bool HasNUW, bool HasNSW) {
1759 unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
1760 (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0);
1761 return get(Instruction::Mul, C1, C2, Flags);
1764 Constant *ConstantExpr::getFMul(Constant *C1, Constant *C2) {
1765 return get(Instruction::FMul, C1, C2);
1768 Constant *ConstantExpr::getUDiv(Constant *C1, Constant *C2, bool isExact) {
1769 return get(Instruction::UDiv, C1, C2,
1770 isExact ? PossiblyExactOperator::IsExact : 0);
1773 Constant *ConstantExpr::getSDiv(Constant *C1, Constant *C2, bool isExact) {
1774 return get(Instruction::SDiv, C1, C2,
1775 isExact ? PossiblyExactOperator::IsExact : 0);
1778 Constant *ConstantExpr::getFDiv(Constant *C1, Constant *C2) {
1779 return get(Instruction::FDiv, C1, C2);
1782 Constant *ConstantExpr::getURem(Constant *C1, Constant *C2) {
1783 return get(Instruction::URem, C1, C2);
1786 Constant *ConstantExpr::getSRem(Constant *C1, Constant *C2) {
1787 return get(Instruction::SRem, C1, C2);
1790 Constant *ConstantExpr::getFRem(Constant *C1, Constant *C2) {
1791 return get(Instruction::FRem, C1, C2);
1794 Constant *ConstantExpr::getAnd(Constant *C1, Constant *C2) {
1795 return get(Instruction::And, C1, C2);
1798 Constant *ConstantExpr::getOr(Constant *C1, Constant *C2) {
1799 return get(Instruction::Or, C1, C2);
1802 Constant *ConstantExpr::getXor(Constant *C1, Constant *C2) {
1803 return get(Instruction::Xor, C1, C2);
1806 Constant *ConstantExpr::getShl(Constant *C1, Constant *C2,
1807 bool HasNUW, bool HasNSW) {
1808 unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
1809 (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0);
1810 return get(Instruction::Shl, C1, C2, Flags);
1813 Constant *ConstantExpr::getLShr(Constant *C1, Constant *C2, bool isExact) {
1814 return get(Instruction::LShr, C1, C2,
1815 isExact ? PossiblyExactOperator::IsExact : 0);
1818 Constant *ConstantExpr::getAShr(Constant *C1, Constant *C2, bool isExact) {
1819 return get(Instruction::AShr, C1, C2,
1820 isExact ? PossiblyExactOperator::IsExact : 0);
1823 // destroyConstant - Remove the constant from the constant table...
1825 void ConstantExpr::destroyConstant() {
1826 getRawType()->getContext().pImpl->ExprConstants.remove(this);
1827 destroyConstantImpl();
1830 const char *ConstantExpr::getOpcodeName() const {
1831 return Instruction::getOpcodeName(getOpcode());
1836 GetElementPtrConstantExpr::
1837 GetElementPtrConstantExpr(Constant *C, const std::vector<Constant*> &IdxList,
1839 : ConstantExpr(DestTy, Instruction::GetElementPtr,
1840 OperandTraits<GetElementPtrConstantExpr>::op_end(this)
1841 - (IdxList.size()+1), IdxList.size()+1) {
1843 for (unsigned i = 0, E = IdxList.size(); i != E; ++i)
1844 OperandList[i+1] = IdxList[i];
1848 //===----------------------------------------------------------------------===//
1849 // replaceUsesOfWithOnConstant implementations
1851 /// replaceUsesOfWithOnConstant - Update this constant array to change uses of
1852 /// 'From' to be uses of 'To'. This must update the uniquing data structures
1855 /// Note that we intentionally replace all uses of From with To here. Consider
1856 /// a large array that uses 'From' 1000 times. By handling this case all here,
1857 /// ConstantArray::replaceUsesOfWithOnConstant is only invoked once, and that
1858 /// single invocation handles all 1000 uses. Handling them one at a time would
1859 /// work, but would be really slow because it would have to unique each updated
1862 void ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To,
1864 assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
1865 Constant *ToC = cast<Constant>(To);
1867 LLVMContextImpl *pImpl = getRawType()->getContext().pImpl;
1869 std::pair<LLVMContextImpl::ArrayConstantsTy::MapKey, ConstantArray*> Lookup;
1870 Lookup.first.first = cast<ArrayType>(getRawType());
1871 Lookup.second = this;
1873 std::vector<Constant*> &Values = Lookup.first.second;
1874 Values.reserve(getNumOperands()); // Build replacement array.
1876 // Fill values with the modified operands of the constant array. Also,
1877 // compute whether this turns into an all-zeros array.
1878 bool isAllZeros = false;
1879 unsigned NumUpdated = 0;
1880 if (!ToC->isNullValue()) {
1881 for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
1882 Constant *Val = cast<Constant>(O->get());
1887 Values.push_back(Val);
1891 for (Use *O = OperandList, *E = OperandList+getNumOperands();O != E; ++O) {
1892 Constant *Val = cast<Constant>(O->get());
1897 Values.push_back(Val);
1898 if (isAllZeros) isAllZeros = Val->isNullValue();
1902 Constant *Replacement = 0;
1904 Replacement = ConstantAggregateZero::get(getRawType());
1906 // Check to see if we have this array type already.
1908 LLVMContextImpl::ArrayConstantsTy::MapTy::iterator I =
1909 pImpl->ArrayConstants.InsertOrGetItem(Lookup, Exists);
1912 Replacement = I->second;
1914 // Okay, the new shape doesn't exist in the system yet. Instead of
1915 // creating a new constant array, inserting it, replaceallusesof'ing the
1916 // old with the new, then deleting the old... just update the current one
1918 pImpl->ArrayConstants.MoveConstantToNewSlot(this, I);
1920 // Update to the new value. Optimize for the case when we have a single
1921 // operand that we're changing, but handle bulk updates efficiently.
1922 if (NumUpdated == 1) {
1923 unsigned OperandToUpdate = U - OperandList;
1924 assert(getOperand(OperandToUpdate) == From &&
1925 "ReplaceAllUsesWith broken!");
1926 setOperand(OperandToUpdate, ToC);
1928 for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
1929 if (getOperand(i) == From)
1936 // Otherwise, I do need to replace this with an existing value.
1937 assert(Replacement != this && "I didn't contain From!");
1939 // Everyone using this now uses the replacement.
1940 uncheckedReplaceAllUsesWith(Replacement);
1942 // Delete the old constant!
1946 void ConstantStruct::replaceUsesOfWithOnConstant(Value *From, Value *To,
1948 assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
1949 Constant *ToC = cast<Constant>(To);
1951 unsigned OperandToUpdate = U-OperandList;
1952 assert(getOperand(OperandToUpdate) == From && "ReplaceAllUsesWith broken!");
1954 std::pair<LLVMContextImpl::StructConstantsTy::MapKey, ConstantStruct*> Lookup;
1955 Lookup.first.first = cast<StructType>(getRawType());
1956 Lookup.second = this;
1957 std::vector<Constant*> &Values = Lookup.first.second;
1958 Values.reserve(getNumOperands()); // Build replacement struct.
1961 // Fill values with the modified operands of the constant struct. Also,
1962 // compute whether this turns into an all-zeros struct.
1963 bool isAllZeros = false;
1964 if (!ToC->isNullValue()) {
1965 for (Use *O = OperandList, *E = OperandList + getNumOperands(); O != E; ++O)
1966 Values.push_back(cast<Constant>(O->get()));
1969 for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
1970 Constant *Val = cast<Constant>(O->get());
1971 Values.push_back(Val);
1972 if (isAllZeros) isAllZeros = Val->isNullValue();
1975 Values[OperandToUpdate] = ToC;
1977 LLVMContextImpl *pImpl = getRawType()->getContext().pImpl;
1979 Constant *Replacement = 0;
1981 Replacement = ConstantAggregateZero::get(getRawType());
1983 // Check to see if we have this struct type already.
1985 LLVMContextImpl::StructConstantsTy::MapTy::iterator I =
1986 pImpl->StructConstants.InsertOrGetItem(Lookup, Exists);
1989 Replacement = I->second;
1991 // Okay, the new shape doesn't exist in the system yet. Instead of
1992 // creating a new constant struct, inserting it, replaceallusesof'ing the
1993 // old with the new, then deleting the old... just update the current one
1995 pImpl->StructConstants.MoveConstantToNewSlot(this, I);
1997 // Update to the new value.
1998 setOperand(OperandToUpdate, ToC);
2003 assert(Replacement != this && "I didn't contain From!");
2005 // Everyone using this now uses the replacement.
2006 uncheckedReplaceAllUsesWith(Replacement);
2008 // Delete the old constant!
2012 void ConstantVector::replaceUsesOfWithOnConstant(Value *From, Value *To,
2014 assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
2016 std::vector<Constant*> Values;
2017 Values.reserve(getNumOperands()); // Build replacement array...
2018 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
2019 Constant *Val = getOperand(i);
2020 if (Val == From) Val = cast<Constant>(To);
2021 Values.push_back(Val);
2024 Constant *Replacement = get(cast<VectorType>(getRawType()), Values);
2025 assert(Replacement != this && "I didn't contain From!");
2027 // Everyone using this now uses the replacement.
2028 uncheckedReplaceAllUsesWith(Replacement);
2030 // Delete the old constant!
2034 void ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV,
2036 assert(isa<Constant>(ToV) && "Cannot make Constant refer to non-constant!");
2037 Constant *To = cast<Constant>(ToV);
2039 Constant *Replacement = 0;
2040 if (getOpcode() == Instruction::GetElementPtr) {
2041 SmallVector<Constant*, 8> Indices;
2042 Constant *Pointer = getOperand(0);
2043 Indices.reserve(getNumOperands()-1);
2044 if (Pointer == From) Pointer = To;
2046 for (unsigned i = 1, e = getNumOperands(); i != e; ++i) {
2047 Constant *Val = getOperand(i);
2048 if (Val == From) Val = To;
2049 Indices.push_back(Val);
2051 Replacement = ConstantExpr::getGetElementPtr(Pointer,
2052 &Indices[0], Indices.size(),
2053 cast<GEPOperator>(this)->isInBounds());
2054 } else if (getOpcode() == Instruction::ExtractValue) {
2055 Constant *Agg = getOperand(0);
2056 if (Agg == From) Agg = To;
2058 const SmallVector<unsigned, 4> &Indices = getIndices();
2059 Replacement = ConstantExpr::getExtractValue(Agg,
2060 &Indices[0], Indices.size());
2061 } else if (getOpcode() == Instruction::InsertValue) {
2062 Constant *Agg = getOperand(0);
2063 Constant *Val = getOperand(1);
2064 if (Agg == From) Agg = To;
2065 if (Val == From) Val = To;
2067 const SmallVector<unsigned, 4> &Indices = getIndices();
2068 Replacement = ConstantExpr::getInsertValue(Agg, Val,
2069 &Indices[0], Indices.size());
2070 } else if (isCast()) {
2071 assert(getOperand(0) == From && "Cast only has one use!");
2072 Replacement = ConstantExpr::getCast(getOpcode(), To, getRawType());
2073 } else if (getOpcode() == Instruction::Select) {
2074 Constant *C1 = getOperand(0);
2075 Constant *C2 = getOperand(1);
2076 Constant *C3 = getOperand(2);
2077 if (C1 == From) C1 = To;
2078 if (C2 == From) C2 = To;
2079 if (C3 == From) C3 = To;
2080 Replacement = ConstantExpr::getSelect(C1, C2, C3);
2081 } else if (getOpcode() == Instruction::ExtractElement) {
2082 Constant *C1 = getOperand(0);
2083 Constant *C2 = getOperand(1);
2084 if (C1 == From) C1 = To;
2085 if (C2 == From) C2 = To;
2086 Replacement = ConstantExpr::getExtractElement(C1, C2);
2087 } else if (getOpcode() == Instruction::InsertElement) {
2088 Constant *C1 = getOperand(0);
2089 Constant *C2 = getOperand(1);
2090 Constant *C3 = getOperand(1);
2091 if (C1 == From) C1 = To;
2092 if (C2 == From) C2 = To;
2093 if (C3 == From) C3 = To;
2094 Replacement = ConstantExpr::getInsertElement(C1, C2, C3);
2095 } else if (getOpcode() == Instruction::ShuffleVector) {
2096 Constant *C1 = getOperand(0);
2097 Constant *C2 = getOperand(1);
2098 Constant *C3 = getOperand(2);
2099 if (C1 == From) C1 = To;
2100 if (C2 == From) C2 = To;
2101 if (C3 == From) C3 = To;
2102 Replacement = ConstantExpr::getShuffleVector(C1, C2, C3);
2103 } else if (isCompare()) {
2104 Constant *C1 = getOperand(0);
2105 Constant *C2 = getOperand(1);
2106 if (C1 == From) C1 = To;
2107 if (C2 == From) C2 = To;
2108 if (getOpcode() == Instruction::ICmp)
2109 Replacement = ConstantExpr::getICmp(getPredicate(), C1, C2);
2111 assert(getOpcode() == Instruction::FCmp);
2112 Replacement = ConstantExpr::getFCmp(getPredicate(), C1, C2);
2114 } else if (getNumOperands() == 2) {
2115 Constant *C1 = getOperand(0);
2116 Constant *C2 = getOperand(1);
2117 if (C1 == From) C1 = To;
2118 if (C2 == From) C2 = To;
2119 Replacement = ConstantExpr::get(getOpcode(), C1, C2, SubclassOptionalData);
2121 llvm_unreachable("Unknown ConstantExpr type!");
2125 assert(Replacement != this && "I didn't contain From!");
2127 // Everyone using this now uses the replacement.
2128 uncheckedReplaceAllUsesWith(Replacement);
2130 // Delete the old constant!