1 //===- ConstantFold.cpp - LLVM constant folder ----------------------------===//
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 folding of constants for LLVM. This implements the
11 // (internal) ConstantFold.h interface, which is used by the
12 // ConstantExpr::get* methods to automatically fold constants when possible.
14 // The current constant folding implementation is implemented in two pieces: the
15 // pieces that don't need TargetData, and the pieces that do. This is to avoid
16 // a dependence in VMCore on Target.
18 //===----------------------------------------------------------------------===//
20 #include "ConstantFold.h"
21 #include "llvm/Constants.h"
22 #include "llvm/Instructions.h"
23 #include "llvm/DerivedTypes.h"
24 #include "llvm/Function.h"
25 #include "llvm/GlobalAlias.h"
26 #include "llvm/GlobalVariable.h"
27 #include "llvm/ADT/SmallVector.h"
28 #include "llvm/Support/Compiler.h"
29 #include "llvm/Support/ErrorHandling.h"
30 #include "llvm/Support/GetElementPtrTypeIterator.h"
31 #include "llvm/Support/ManagedStatic.h"
32 #include "llvm/Support/MathExtras.h"
36 //===----------------------------------------------------------------------===//
37 // ConstantFold*Instruction Implementations
38 //===----------------------------------------------------------------------===//
40 /// BitCastConstantVector - Convert the specified ConstantVector node to the
41 /// specified vector type. At this point, we know that the elements of the
42 /// input vector constant are all simple integer or FP values.
43 static Constant
*BitCastConstantVector(ConstantVector
*CV
,
44 const VectorType
*DstTy
) {
45 // If this cast changes element count then we can't handle it here:
46 // doing so requires endianness information. This should be handled by
47 // Analysis/ConstantFolding.cpp
48 unsigned NumElts
= DstTy
->getNumElements();
49 if (NumElts
!= CV
->getNumOperands())
52 // Check to verify that all elements of the input are simple.
53 for (unsigned i
= 0; i
!= NumElts
; ++i
) {
54 if (!isa
<ConstantInt
>(CV
->getOperand(i
)) &&
55 !isa
<ConstantFP
>(CV
->getOperand(i
)))
59 // Bitcast each element now.
60 std::vector
<Constant
*> Result
;
61 const Type
*DstEltTy
= DstTy
->getElementType();
62 for (unsigned i
= 0; i
!= NumElts
; ++i
)
63 Result
.push_back(ConstantExpr::getBitCast(CV
->getOperand(i
),
65 return ConstantVector::get(Result
);
68 /// This function determines which opcode to use to fold two constant cast
69 /// expressions together. It uses CastInst::isEliminableCastPair to determine
70 /// the opcode. Consequently its just a wrapper around that function.
71 /// @brief Determine if it is valid to fold a cast of a cast
74 unsigned opc
, ///< opcode of the second cast constant expression
75 ConstantExpr
*Op
, ///< the first cast constant expression
76 const Type
*DstTy
///< desintation type of the first cast
78 assert(Op
&& Op
->isCast() && "Can't fold cast of cast without a cast!");
79 assert(DstTy
&& DstTy
->isFirstClassType() && "Invalid cast destination type");
80 assert(CastInst::isCast(opc
) && "Invalid cast opcode");
82 // The the types and opcodes for the two Cast constant expressions
83 const Type
*SrcTy
= Op
->getOperand(0)->getType();
84 const Type
*MidTy
= Op
->getType();
85 Instruction::CastOps firstOp
= Instruction::CastOps(Op
->getOpcode());
86 Instruction::CastOps secondOp
= Instruction::CastOps(opc
);
88 // Let CastInst::isEliminableCastPair do the heavy lifting.
89 return CastInst::isEliminableCastPair(firstOp
, secondOp
, SrcTy
, MidTy
, DstTy
,
90 Type::getInt64Ty(DstTy
->getContext()));
93 static Constant
*FoldBitCast(Constant
*V
, const Type
*DestTy
) {
94 const Type
*SrcTy
= V
->getType();
96 return V
; // no-op cast
98 // Check to see if we are casting a pointer to an aggregate to a pointer to
99 // the first element. If so, return the appropriate GEP instruction.
100 if (const PointerType
*PTy
= dyn_cast
<PointerType
>(V
->getType()))
101 if (const PointerType
*DPTy
= dyn_cast
<PointerType
>(DestTy
))
102 if (PTy
->getAddressSpace() == DPTy
->getAddressSpace()) {
103 SmallVector
<Value
*, 8> IdxList
;
105 Constant::getNullValue(Type::getInt32Ty(DPTy
->getContext()));
106 IdxList
.push_back(Zero
);
107 const Type
*ElTy
= PTy
->getElementType();
108 while (ElTy
!= DPTy
->getElementType()) {
109 if (const StructType
*STy
= dyn_cast
<StructType
>(ElTy
)) {
110 if (STy
->getNumElements() == 0) break;
111 ElTy
= STy
->getElementType(0);
112 IdxList
.push_back(Zero
);
113 } else if (const SequentialType
*STy
=
114 dyn_cast
<SequentialType
>(ElTy
)) {
115 if (ElTy
->isPointerTy()) break; // Can't index into pointers!
116 ElTy
= STy
->getElementType();
117 IdxList
.push_back(Zero
);
123 if (ElTy
== DPTy
->getElementType())
124 // This GEP is inbounds because all indices are zero.
125 return ConstantExpr::getInBoundsGetElementPtr(V
, &IdxList
[0],
129 // Handle casts from one vector constant to another. We know that the src
130 // and dest type have the same size (otherwise its an illegal cast).
131 if (const VectorType
*DestPTy
= dyn_cast
<VectorType
>(DestTy
)) {
132 if (const VectorType
*SrcTy
= dyn_cast
<VectorType
>(V
->getType())) {
133 assert(DestPTy
->getBitWidth() == SrcTy
->getBitWidth() &&
134 "Not cast between same sized vectors!");
136 // First, check for null. Undef is already handled.
137 if (isa
<ConstantAggregateZero
>(V
))
138 return Constant::getNullValue(DestTy
);
140 if (ConstantVector
*CV
= dyn_cast
<ConstantVector
>(V
))
141 return BitCastConstantVector(CV
, DestPTy
);
144 // Canonicalize scalar-to-vector bitcasts into vector-to-vector bitcasts
145 // This allows for other simplifications (although some of them
146 // can only be handled by Analysis/ConstantFolding.cpp).
147 if (isa
<ConstantInt
>(V
) || isa
<ConstantFP
>(V
))
148 return ConstantExpr::getBitCast(ConstantVector::get(&V
, 1), DestPTy
);
151 // Finally, implement bitcast folding now. The code below doesn't handle
153 if (isa
<ConstantPointerNull
>(V
)) // ptr->ptr cast.
154 return ConstantPointerNull::get(cast
<PointerType
>(DestTy
));
156 // Handle integral constant input.
157 if (ConstantInt
*CI
= dyn_cast
<ConstantInt
>(V
)) {
158 if (DestTy
->isIntegerTy())
159 // Integral -> Integral. This is a no-op because the bit widths must
160 // be the same. Consequently, we just fold to V.
163 if (DestTy
->isFloatingPointTy())
164 return ConstantFP::get(DestTy
->getContext(),
165 APFloat(CI
->getValue(),
166 !DestTy
->isPPC_FP128Ty()));
168 // Otherwise, can't fold this (vector?)
172 // Handle ConstantFP input: FP -> Integral.
173 if (ConstantFP
*FP
= dyn_cast
<ConstantFP
>(V
))
174 return ConstantInt::get(FP
->getContext(),
175 FP
->getValueAPF().bitcastToAPInt());
181 /// ExtractConstantBytes - V is an integer constant which only has a subset of
182 /// its bytes used. The bytes used are indicated by ByteStart (which is the
183 /// first byte used, counting from the least significant byte) and ByteSize,
184 /// which is the number of bytes used.
186 /// This function analyzes the specified constant to see if the specified byte
187 /// range can be returned as a simplified constant. If so, the constant is
188 /// returned, otherwise null is returned.
190 static Constant
*ExtractConstantBytes(Constant
*C
, unsigned ByteStart
,
192 assert(C
->getType()->isIntegerTy() &&
193 (cast
<IntegerType
>(C
->getType())->getBitWidth() & 7) == 0 &&
194 "Non-byte sized integer input");
195 unsigned CSize
= cast
<IntegerType
>(C
->getType())->getBitWidth()/8;
196 assert(ByteSize
&& "Must be accessing some piece");
197 assert(ByteStart
+ByteSize
<= CSize
&& "Extracting invalid piece from input");
198 assert(ByteSize
!= CSize
&& "Should not extract everything");
200 // Constant Integers are simple.
201 if (ConstantInt
*CI
= dyn_cast
<ConstantInt
>(C
)) {
202 APInt V
= CI
->getValue();
204 V
= V
.lshr(ByteStart
*8);
205 V
= V
.trunc(ByteSize
*8);
206 return ConstantInt::get(CI
->getContext(), V
);
209 // In the input is a constant expr, we might be able to recursively simplify.
210 // If not, we definitely can't do anything.
211 ConstantExpr
*CE
= dyn_cast
<ConstantExpr
>(C
);
212 if (CE
== 0) return 0;
214 switch (CE
->getOpcode()) {
216 case Instruction::Or
: {
217 Constant
*RHS
= ExtractConstantBytes(CE
->getOperand(1), ByteStart
,ByteSize
);
222 if (ConstantInt
*RHSC
= dyn_cast
<ConstantInt
>(RHS
))
223 if (RHSC
->isAllOnesValue())
226 Constant
*LHS
= ExtractConstantBytes(CE
->getOperand(0), ByteStart
,ByteSize
);
229 return ConstantExpr::getOr(LHS
, RHS
);
231 case Instruction::And
: {
232 Constant
*RHS
= ExtractConstantBytes(CE
->getOperand(1), ByteStart
,ByteSize
);
237 if (RHS
->isNullValue())
240 Constant
*LHS
= ExtractConstantBytes(CE
->getOperand(0), ByteStart
,ByteSize
);
243 return ConstantExpr::getAnd(LHS
, RHS
);
245 case Instruction::LShr
: {
246 ConstantInt
*Amt
= dyn_cast
<ConstantInt
>(CE
->getOperand(1));
249 unsigned ShAmt
= Amt
->getZExtValue();
250 // Cannot analyze non-byte shifts.
251 if ((ShAmt
& 7) != 0)
255 // If the extract is known to be all zeros, return zero.
256 if (ByteStart
>= CSize
-ShAmt
)
257 return Constant::getNullValue(IntegerType::get(CE
->getContext(),
259 // If the extract is known to be fully in the input, extract it.
260 if (ByteStart
+ByteSize
+ShAmt
<= CSize
)
261 return ExtractConstantBytes(CE
->getOperand(0), ByteStart
+ShAmt
, ByteSize
);
263 // TODO: Handle the 'partially zero' case.
267 case Instruction::Shl
: {
268 ConstantInt
*Amt
= dyn_cast
<ConstantInt
>(CE
->getOperand(1));
271 unsigned ShAmt
= Amt
->getZExtValue();
272 // Cannot analyze non-byte shifts.
273 if ((ShAmt
& 7) != 0)
277 // If the extract is known to be all zeros, return zero.
278 if (ByteStart
+ByteSize
<= ShAmt
)
279 return Constant::getNullValue(IntegerType::get(CE
->getContext(),
281 // If the extract is known to be fully in the input, extract it.
282 if (ByteStart
>= ShAmt
)
283 return ExtractConstantBytes(CE
->getOperand(0), ByteStart
-ShAmt
, ByteSize
);
285 // TODO: Handle the 'partially zero' case.
289 case Instruction::ZExt
: {
290 unsigned SrcBitSize
=
291 cast
<IntegerType
>(CE
->getOperand(0)->getType())->getBitWidth();
293 // If extracting something that is completely zero, return 0.
294 if (ByteStart
*8 >= SrcBitSize
)
295 return Constant::getNullValue(IntegerType::get(CE
->getContext(),
298 // If exactly extracting the input, return it.
299 if (ByteStart
== 0 && ByteSize
*8 == SrcBitSize
)
300 return CE
->getOperand(0);
302 // If extracting something completely in the input, if if the input is a
303 // multiple of 8 bits, recurse.
304 if ((SrcBitSize
&7) == 0 && (ByteStart
+ByteSize
)*8 <= SrcBitSize
)
305 return ExtractConstantBytes(CE
->getOperand(0), ByteStart
, ByteSize
);
307 // Otherwise, if extracting a subset of the input, which is not multiple of
308 // 8 bits, do a shift and trunc to get the bits.
309 if ((ByteStart
+ByteSize
)*8 < SrcBitSize
) {
310 assert((SrcBitSize
&7) && "Shouldn't get byte sized case here");
311 Constant
*Res
= CE
->getOperand(0);
313 Res
= ConstantExpr::getLShr(Res
,
314 ConstantInt::get(Res
->getType(), ByteStart
*8));
315 return ConstantExpr::getTrunc(Res
, IntegerType::get(C
->getContext(),
319 // TODO: Handle the 'partially zero' case.
325 /// getFoldedSizeOf - Return a ConstantExpr with type DestTy for sizeof
326 /// on Ty, with any known factors factored out. If Folded is false,
327 /// return null if no factoring was possible, to avoid endlessly
328 /// bouncing an unfoldable expression back into the top-level folder.
330 static Constant
*getFoldedSizeOf(const Type
*Ty
, const Type
*DestTy
,
332 if (const ArrayType
*ATy
= dyn_cast
<ArrayType
>(Ty
)) {
333 Constant
*N
= ConstantInt::get(DestTy
, ATy
->getNumElements());
334 Constant
*E
= getFoldedSizeOf(ATy
->getElementType(), DestTy
, true);
335 return ConstantExpr::getNUWMul(E
, N
);
338 if (const StructType
*STy
= dyn_cast
<StructType
>(Ty
))
339 if (!STy
->isPacked()) {
340 unsigned NumElems
= STy
->getNumElements();
341 // An empty struct has size zero.
343 return ConstantExpr::getNullValue(DestTy
);
344 // Check for a struct with all members having the same size.
345 Constant
*MemberSize
=
346 getFoldedSizeOf(STy
->getElementType(0), DestTy
, true);
348 for (unsigned i
= 1; i
!= NumElems
; ++i
)
350 getFoldedSizeOf(STy
->getElementType(i
), DestTy
, true)) {
355 Constant
*N
= ConstantInt::get(DestTy
, NumElems
);
356 return ConstantExpr::getNUWMul(MemberSize
, N
);
360 // Pointer size doesn't depend on the pointee type, so canonicalize them
361 // to an arbitrary pointee.
362 if (const PointerType
*PTy
= dyn_cast
<PointerType
>(Ty
))
363 if (!PTy
->getElementType()->isIntegerTy(1))
365 getFoldedSizeOf(PointerType::get(IntegerType::get(PTy
->getContext(), 1),
366 PTy
->getAddressSpace()),
369 // If there's no interesting folding happening, bail so that we don't create
370 // a constant that looks like it needs folding but really doesn't.
374 // Base case: Get a regular sizeof expression.
375 Constant
*C
= ConstantExpr::getSizeOf(Ty
);
376 C
= ConstantExpr::getCast(CastInst::getCastOpcode(C
, false,
382 /// getFoldedAlignOf - Return a ConstantExpr with type DestTy for alignof
383 /// on Ty, with any known factors factored out. If Folded is false,
384 /// return null if no factoring was possible, to avoid endlessly
385 /// bouncing an unfoldable expression back into the top-level folder.
387 static Constant
*getFoldedAlignOf(const Type
*Ty
, const Type
*DestTy
,
389 // The alignment of an array is equal to the alignment of the
390 // array element. Note that this is not always true for vectors.
391 if (const ArrayType
*ATy
= dyn_cast
<ArrayType
>(Ty
)) {
392 Constant
*C
= ConstantExpr::getAlignOf(ATy
->getElementType());
393 C
= ConstantExpr::getCast(CastInst::getCastOpcode(C
, false,
400 if (const StructType
*STy
= dyn_cast
<StructType
>(Ty
)) {
401 // Packed structs always have an alignment of 1.
403 return ConstantInt::get(DestTy
, 1);
405 // Otherwise, struct alignment is the maximum alignment of any member.
406 // Without target data, we can't compare much, but we can check to see
407 // if all the members have the same alignment.
408 unsigned NumElems
= STy
->getNumElements();
409 // An empty struct has minimal alignment.
411 return ConstantInt::get(DestTy
, 1);
412 // Check for a struct with all members having the same alignment.
413 Constant
*MemberAlign
=
414 getFoldedAlignOf(STy
->getElementType(0), DestTy
, true);
416 for (unsigned i
= 1; i
!= NumElems
; ++i
)
417 if (MemberAlign
!= getFoldedAlignOf(STy
->getElementType(i
), DestTy
, true)) {
425 // Pointer alignment doesn't depend on the pointee type, so canonicalize them
426 // to an arbitrary pointee.
427 if (const PointerType
*PTy
= dyn_cast
<PointerType
>(Ty
))
428 if (!PTy
->getElementType()->isIntegerTy(1))
430 getFoldedAlignOf(PointerType::get(IntegerType::get(PTy
->getContext(),
432 PTy
->getAddressSpace()),
435 // If there's no interesting folding happening, bail so that we don't create
436 // a constant that looks like it needs folding but really doesn't.
440 // Base case: Get a regular alignof expression.
441 Constant
*C
= ConstantExpr::getAlignOf(Ty
);
442 C
= ConstantExpr::getCast(CastInst::getCastOpcode(C
, false,
448 /// getFoldedOffsetOf - Return a ConstantExpr with type DestTy for offsetof
449 /// on Ty and FieldNo, with any known factors factored out. If Folded is false,
450 /// return null if no factoring was possible, to avoid endlessly
451 /// bouncing an unfoldable expression back into the top-level folder.
453 static Constant
*getFoldedOffsetOf(const Type
*Ty
, Constant
*FieldNo
,
456 if (const ArrayType
*ATy
= dyn_cast
<ArrayType
>(Ty
)) {
457 Constant
*N
= ConstantExpr::getCast(CastInst::getCastOpcode(FieldNo
, false,
460 Constant
*E
= getFoldedSizeOf(ATy
->getElementType(), DestTy
, true);
461 return ConstantExpr::getNUWMul(E
, N
);
464 if (const StructType
*STy
= dyn_cast
<StructType
>(Ty
))
465 if (!STy
->isPacked()) {
466 unsigned NumElems
= STy
->getNumElements();
467 // An empty struct has no members.
470 // Check for a struct with all members having the same size.
471 Constant
*MemberSize
=
472 getFoldedSizeOf(STy
->getElementType(0), DestTy
, true);
474 for (unsigned i
= 1; i
!= NumElems
; ++i
)
476 getFoldedSizeOf(STy
->getElementType(i
), DestTy
, true)) {
481 Constant
*N
= ConstantExpr::getCast(CastInst::getCastOpcode(FieldNo
,
486 return ConstantExpr::getNUWMul(MemberSize
, N
);
490 // If there's no interesting folding happening, bail so that we don't create
491 // a constant that looks like it needs folding but really doesn't.
495 // Base case: Get a regular offsetof expression.
496 Constant
*C
= ConstantExpr::getOffsetOf(Ty
, FieldNo
);
497 C
= ConstantExpr::getCast(CastInst::getCastOpcode(C
, false,
503 Constant
*llvm::ConstantFoldCastInstruction(unsigned opc
, Constant
*V
,
504 const Type
*DestTy
) {
505 if (isa
<UndefValue
>(V
)) {
506 // zext(undef) = 0, because the top bits will be zero.
507 // sext(undef) = 0, because the top bits will all be the same.
508 // [us]itofp(undef) = 0, because the result value is bounded.
509 if (opc
== Instruction::ZExt
|| opc
== Instruction::SExt
||
510 opc
== Instruction::UIToFP
|| opc
== Instruction::SIToFP
)
511 return Constant::getNullValue(DestTy
);
512 return UndefValue::get(DestTy
);
515 // No compile-time operations on this type yet.
516 if (V
->getType()->isPPC_FP128Ty() || DestTy
->isPPC_FP128Ty())
519 if (V
->isNullValue() && !DestTy
->isX86_MMXTy())
520 return Constant::getNullValue(DestTy
);
522 // If the cast operand is a constant expression, there's a few things we can
523 // do to try to simplify it.
524 if (ConstantExpr
*CE
= dyn_cast
<ConstantExpr
>(V
)) {
526 // Try hard to fold cast of cast because they are often eliminable.
527 if (unsigned newOpc
= foldConstantCastPair(opc
, CE
, DestTy
))
528 return ConstantExpr::getCast(newOpc
, CE
->getOperand(0), DestTy
);
529 } else if (CE
->getOpcode() == Instruction::GetElementPtr
) {
530 // If all of the indexes in the GEP are null values, there is no pointer
531 // adjustment going on. We might as well cast the source pointer.
532 bool isAllNull
= true;
533 for (unsigned i
= 1, e
= CE
->getNumOperands(); i
!= e
; ++i
)
534 if (!CE
->getOperand(i
)->isNullValue()) {
539 // This is casting one pointer type to another, always BitCast
540 return ConstantExpr::getPointerCast(CE
->getOperand(0), DestTy
);
544 // If the cast operand is a constant vector, perform the cast by
545 // operating on each element. In the cast of bitcasts, the element
546 // count may be mismatched; don't attempt to handle that here.
547 if (ConstantVector
*CV
= dyn_cast
<ConstantVector
>(V
))
548 if (DestTy
->isVectorTy() &&
549 cast
<VectorType
>(DestTy
)->getNumElements() ==
550 CV
->getType()->getNumElements()) {
551 std::vector
<Constant
*> res
;
552 const VectorType
*DestVecTy
= cast
<VectorType
>(DestTy
);
553 const Type
*DstEltTy
= DestVecTy
->getElementType();
554 for (unsigned i
= 0, e
= CV
->getType()->getNumElements(); i
!= e
; ++i
)
555 res
.push_back(ConstantExpr::getCast(opc
,
556 CV
->getOperand(i
), DstEltTy
));
557 return ConstantVector::get(DestVecTy
, res
);
560 // We actually have to do a cast now. Perform the cast according to the
564 llvm_unreachable("Failed to cast constant expression");
565 case Instruction::FPTrunc
:
566 case Instruction::FPExt
:
567 if (ConstantFP
*FPC
= dyn_cast
<ConstantFP
>(V
)) {
569 APFloat Val
= FPC
->getValueAPF();
570 Val
.convert(DestTy
->isFloatTy() ? APFloat::IEEEsingle
:
571 DestTy
->isDoubleTy() ? APFloat::IEEEdouble
:
572 DestTy
->isX86_FP80Ty() ? APFloat::x87DoubleExtended
:
573 DestTy
->isFP128Ty() ? APFloat::IEEEquad
:
575 APFloat::rmNearestTiesToEven
, &ignored
);
576 return ConstantFP::get(V
->getContext(), Val
);
578 return 0; // Can't fold.
579 case Instruction::FPToUI
:
580 case Instruction::FPToSI
:
581 if (ConstantFP
*FPC
= dyn_cast
<ConstantFP
>(V
)) {
582 const APFloat
&V
= FPC
->getValueAPF();
585 uint32_t DestBitWidth
= cast
<IntegerType
>(DestTy
)->getBitWidth();
586 (void) V
.convertToInteger(x
, DestBitWidth
, opc
==Instruction::FPToSI
,
587 APFloat::rmTowardZero
, &ignored
);
588 APInt
Val(DestBitWidth
, 2, x
);
589 return ConstantInt::get(FPC
->getContext(), Val
);
591 return 0; // Can't fold.
592 case Instruction::IntToPtr
: //always treated as unsigned
593 if (V
->isNullValue()) // Is it an integral null value?
594 return ConstantPointerNull::get(cast
<PointerType
>(DestTy
));
595 return 0; // Other pointer types cannot be casted
596 case Instruction::PtrToInt
: // always treated as unsigned
597 // Is it a null pointer value?
598 if (V
->isNullValue())
599 return ConstantInt::get(DestTy
, 0);
600 // If this is a sizeof-like expression, pull out multiplications by
601 // known factors to expose them to subsequent folding. If it's an
602 // alignof-like expression, factor out known factors.
603 if (ConstantExpr
*CE
= dyn_cast
<ConstantExpr
>(V
))
604 if (CE
->getOpcode() == Instruction::GetElementPtr
&&
605 CE
->getOperand(0)->isNullValue()) {
607 cast
<PointerType
>(CE
->getOperand(0)->getType())->getElementType();
608 if (CE
->getNumOperands() == 2) {
609 // Handle a sizeof-like expression.
610 Constant
*Idx
= CE
->getOperand(1);
611 bool isOne
= isa
<ConstantInt
>(Idx
) && cast
<ConstantInt
>(Idx
)->isOne();
612 if (Constant
*C
= getFoldedSizeOf(Ty
, DestTy
, !isOne
)) {
613 Idx
= ConstantExpr::getCast(CastInst::getCastOpcode(Idx
, true,
616 return ConstantExpr::getMul(C
, Idx
);
618 } else if (CE
->getNumOperands() == 3 &&
619 CE
->getOperand(1)->isNullValue()) {
620 // Handle an alignof-like expression.
621 if (const StructType
*STy
= dyn_cast
<StructType
>(Ty
))
622 if (!STy
->isPacked()) {
623 ConstantInt
*CI
= cast
<ConstantInt
>(CE
->getOperand(2));
625 STy
->getNumElements() == 2 &&
626 STy
->getElementType(0)->isIntegerTy(1)) {
627 return getFoldedAlignOf(STy
->getElementType(1), DestTy
, false);
630 // Handle an offsetof-like expression.
631 if (Ty
->isStructTy() || Ty
->isArrayTy()) {
632 if (Constant
*C
= getFoldedOffsetOf(Ty
, CE
->getOperand(2),
638 // Other pointer types cannot be casted
640 case Instruction::UIToFP
:
641 case Instruction::SIToFP
:
642 if (ConstantInt
*CI
= dyn_cast
<ConstantInt
>(V
)) {
643 APInt api
= CI
->getValue();
644 APFloat
apf(APInt::getNullValue(DestTy
->getPrimitiveSizeInBits()), true);
645 (void)apf
.convertFromAPInt(api
,
646 opc
==Instruction::SIToFP
,
647 APFloat::rmNearestTiesToEven
);
648 return ConstantFP::get(V
->getContext(), apf
);
651 case Instruction::ZExt
:
652 if (ConstantInt
*CI
= dyn_cast
<ConstantInt
>(V
)) {
653 uint32_t BitWidth
= cast
<IntegerType
>(DestTy
)->getBitWidth();
654 return ConstantInt::get(V
->getContext(),
655 CI
->getValue().zext(BitWidth
));
658 case Instruction::SExt
:
659 if (ConstantInt
*CI
= dyn_cast
<ConstantInt
>(V
)) {
660 uint32_t BitWidth
= cast
<IntegerType
>(DestTy
)->getBitWidth();
661 return ConstantInt::get(V
->getContext(),
662 CI
->getValue().sext(BitWidth
));
665 case Instruction::Trunc
: {
666 uint32_t DestBitWidth
= cast
<IntegerType
>(DestTy
)->getBitWidth();
667 if (ConstantInt
*CI
= dyn_cast
<ConstantInt
>(V
)) {
668 return ConstantInt::get(V
->getContext(),
669 CI
->getValue().trunc(DestBitWidth
));
672 // The input must be a constantexpr. See if we can simplify this based on
673 // the bytes we are demanding. Only do this if the source and dest are an
674 // even multiple of a byte.
675 if ((DestBitWidth
& 7) == 0 &&
676 (cast
<IntegerType
>(V
->getType())->getBitWidth() & 7) == 0)
677 if (Constant
*Res
= ExtractConstantBytes(V
, 0, DestBitWidth
/ 8))
682 case Instruction::BitCast
:
683 return FoldBitCast(V
, DestTy
);
687 Constant
*llvm::ConstantFoldSelectInstruction(Constant
*Cond
,
688 Constant
*V1
, Constant
*V2
) {
689 if (ConstantInt
*CB
= dyn_cast
<ConstantInt
>(Cond
))
690 return CB
->getZExtValue() ? V1
: V2
;
692 if (isa
<UndefValue
>(V1
)) return V2
;
693 if (isa
<UndefValue
>(V2
)) return V1
;
694 if (isa
<UndefValue
>(Cond
)) return V1
;
695 if (V1
== V2
) return V1
;
699 Constant
*llvm::ConstantFoldExtractElementInstruction(Constant
*Val
,
701 if (isa
<UndefValue
>(Val
)) // ee(undef, x) -> undef
702 return UndefValue::get(cast
<VectorType
>(Val
->getType())->getElementType());
703 if (Val
->isNullValue()) // ee(zero, x) -> zero
704 return Constant::getNullValue(
705 cast
<VectorType
>(Val
->getType())->getElementType());
707 if (ConstantVector
*CVal
= dyn_cast
<ConstantVector
>(Val
)) {
708 if (ConstantInt
*CIdx
= dyn_cast
<ConstantInt
>(Idx
)) {
709 return CVal
->getOperand(CIdx
->getZExtValue());
710 } else if (isa
<UndefValue
>(Idx
)) {
711 // ee({w,x,y,z}, undef) -> w (an arbitrary value).
712 return CVal
->getOperand(0);
718 Constant
*llvm::ConstantFoldInsertElementInstruction(Constant
*Val
,
721 ConstantInt
*CIdx
= dyn_cast
<ConstantInt
>(Idx
);
723 APInt idxVal
= CIdx
->getValue();
724 if (isa
<UndefValue
>(Val
)) {
725 // Insertion of scalar constant into vector undef
726 // Optimize away insertion of undef
727 if (isa
<UndefValue
>(Elt
))
729 // Otherwise break the aggregate undef into multiple undefs and do
732 cast
<VectorType
>(Val
->getType())->getNumElements();
733 std::vector
<Constant
*> Ops
;
735 for (unsigned i
= 0; i
< numOps
; ++i
) {
737 (idxVal
== i
) ? Elt
: UndefValue::get(Elt
->getType());
740 return ConstantVector::get(Ops
);
742 if (isa
<ConstantAggregateZero
>(Val
)) {
743 // Insertion of scalar constant into vector aggregate zero
744 // Optimize away insertion of zero
745 if (Elt
->isNullValue())
747 // Otherwise break the aggregate zero into multiple zeros and do
750 cast
<VectorType
>(Val
->getType())->getNumElements();
751 std::vector
<Constant
*> Ops
;
753 for (unsigned i
= 0; i
< numOps
; ++i
) {
755 (idxVal
== i
) ? Elt
: Constant::getNullValue(Elt
->getType());
758 return ConstantVector::get(Ops
);
760 if (ConstantVector
*CVal
= dyn_cast
<ConstantVector
>(Val
)) {
761 // Insertion of scalar constant into vector constant
762 std::vector
<Constant
*> Ops
;
763 Ops
.reserve(CVal
->getNumOperands());
764 for (unsigned i
= 0; i
< CVal
->getNumOperands(); ++i
) {
766 (idxVal
== i
) ? Elt
: cast
<Constant
>(CVal
->getOperand(i
));
769 return ConstantVector::get(Ops
);
775 /// GetVectorElement - If C is a ConstantVector, ConstantAggregateZero or Undef
776 /// return the specified element value. Otherwise return null.
777 static Constant
*GetVectorElement(Constant
*C
, unsigned EltNo
) {
778 if (ConstantVector
*CV
= dyn_cast
<ConstantVector
>(C
))
779 return CV
->getOperand(EltNo
);
781 const Type
*EltTy
= cast
<VectorType
>(C
->getType())->getElementType();
782 if (isa
<ConstantAggregateZero
>(C
))
783 return Constant::getNullValue(EltTy
);
784 if (isa
<UndefValue
>(C
))
785 return UndefValue::get(EltTy
);
789 Constant
*llvm::ConstantFoldShuffleVectorInstruction(Constant
*V1
,
792 // Undefined shuffle mask -> undefined value.
793 if (isa
<UndefValue
>(Mask
)) return UndefValue::get(V1
->getType());
795 unsigned MaskNumElts
= cast
<VectorType
>(Mask
->getType())->getNumElements();
796 unsigned SrcNumElts
= cast
<VectorType
>(V1
->getType())->getNumElements();
797 const Type
*EltTy
= cast
<VectorType
>(V1
->getType())->getElementType();
799 // Loop over the shuffle mask, evaluating each element.
800 SmallVector
<Constant
*, 32> Result
;
801 for (unsigned i
= 0; i
!= MaskNumElts
; ++i
) {
802 Constant
*InElt
= GetVectorElement(Mask
, i
);
803 if (InElt
== 0) return 0;
805 if (isa
<UndefValue
>(InElt
))
806 InElt
= UndefValue::get(EltTy
);
807 else if (ConstantInt
*CI
= dyn_cast
<ConstantInt
>(InElt
)) {
808 unsigned Elt
= CI
->getZExtValue();
809 if (Elt
>= SrcNumElts
*2)
810 InElt
= UndefValue::get(EltTy
);
811 else if (Elt
>= SrcNumElts
)
812 InElt
= GetVectorElement(V2
, Elt
- SrcNumElts
);
814 InElt
= GetVectorElement(V1
, Elt
);
815 if (InElt
== 0) return 0;
820 Result
.push_back(InElt
);
823 return ConstantVector::get(&Result
[0], Result
.size());
826 Constant
*llvm::ConstantFoldExtractValueInstruction(Constant
*Agg
,
827 const unsigned *Idxs
,
829 // Base case: no indices, so return the entire value.
833 if (isa
<UndefValue
>(Agg
)) // ev(undef, x) -> undef
834 return UndefValue::get(ExtractValueInst::getIndexedType(Agg
->getType(),
838 if (isa
<ConstantAggregateZero
>(Agg
)) // ev(0, x) -> 0
840 Constant::getNullValue(ExtractValueInst::getIndexedType(Agg
->getType(),
844 // Otherwise recurse.
845 if (ConstantStruct
*CS
= dyn_cast
<ConstantStruct
>(Agg
))
846 return ConstantFoldExtractValueInstruction(CS
->getOperand(*Idxs
),
849 if (ConstantArray
*CA
= dyn_cast
<ConstantArray
>(Agg
))
850 return ConstantFoldExtractValueInstruction(CA
->getOperand(*Idxs
),
852 ConstantVector
*CV
= cast
<ConstantVector
>(Agg
);
853 return ConstantFoldExtractValueInstruction(CV
->getOperand(*Idxs
),
857 Constant
*llvm::ConstantFoldInsertValueInstruction(Constant
*Agg
,
859 const unsigned *Idxs
,
861 // Base case: no indices, so replace the entire value.
865 if (isa
<UndefValue
>(Agg
)) {
866 // Insertion of constant into aggregate undef
867 // Optimize away insertion of undef.
868 if (isa
<UndefValue
>(Val
))
871 // Otherwise break the aggregate undef into multiple undefs and do
873 const CompositeType
*AggTy
= cast
<CompositeType
>(Agg
->getType());
875 if (const ArrayType
*AR
= dyn_cast
<ArrayType
>(AggTy
))
876 numOps
= AR
->getNumElements();
878 numOps
= cast
<StructType
>(AggTy
)->getNumElements();
880 std::vector
<Constant
*> Ops(numOps
);
881 for (unsigned i
= 0; i
< numOps
; ++i
) {
882 const Type
*MemberTy
= AggTy
->getTypeAtIndex(i
);
885 ConstantFoldInsertValueInstruction(UndefValue::get(MemberTy
),
886 Val
, Idxs
+1, NumIdx
-1) :
887 UndefValue::get(MemberTy
);
891 if (const StructType
* ST
= dyn_cast
<StructType
>(AggTy
))
892 return ConstantStruct::get(ST
->getContext(), Ops
, ST
->isPacked());
893 return ConstantArray::get(cast
<ArrayType
>(AggTy
), Ops
);
896 if (isa
<ConstantAggregateZero
>(Agg
)) {
897 // Insertion of constant into aggregate zero
898 // Optimize away insertion of zero.
899 if (Val
->isNullValue())
902 // Otherwise break the aggregate zero into multiple zeros and do
904 const CompositeType
*AggTy
= cast
<CompositeType
>(Agg
->getType());
906 if (const ArrayType
*AR
= dyn_cast
<ArrayType
>(AggTy
))
907 numOps
= AR
->getNumElements();
909 numOps
= cast
<StructType
>(AggTy
)->getNumElements();
911 std::vector
<Constant
*> Ops(numOps
);
912 for (unsigned i
= 0; i
< numOps
; ++i
) {
913 const Type
*MemberTy
= AggTy
->getTypeAtIndex(i
);
916 ConstantFoldInsertValueInstruction(Constant::getNullValue(MemberTy
),
917 Val
, Idxs
+1, NumIdx
-1) :
918 Constant::getNullValue(MemberTy
);
922 if (const StructType
*ST
= dyn_cast
<StructType
>(AggTy
))
923 return ConstantStruct::get(ST
->getContext(), Ops
, ST
->isPacked());
924 return ConstantArray::get(cast
<ArrayType
>(AggTy
), Ops
);
927 if (isa
<ConstantStruct
>(Agg
) || isa
<ConstantArray
>(Agg
)) {
928 // Insertion of constant into aggregate constant.
929 std::vector
<Constant
*> Ops(Agg
->getNumOperands());
930 for (unsigned i
= 0; i
< Agg
->getNumOperands(); ++i
) {
931 Constant
*Op
= cast
<Constant
>(Agg
->getOperand(i
));
933 Op
= ConstantFoldInsertValueInstruction(Op
, Val
, Idxs
+1, NumIdx
-1);
937 if (const StructType
* ST
= dyn_cast
<StructType
>(Agg
->getType()))
938 return ConstantStruct::get(ST
->getContext(), Ops
, ST
->isPacked());
939 return ConstantArray::get(cast
<ArrayType
>(Agg
->getType()), Ops
);
946 Constant
*llvm::ConstantFoldBinaryInstruction(unsigned Opcode
,
947 Constant
*C1
, Constant
*C2
) {
948 // No compile-time operations on this type yet.
949 if (C1
->getType()->isPPC_FP128Ty())
952 // Handle UndefValue up front.
953 if (isa
<UndefValue
>(C1
) || isa
<UndefValue
>(C2
)) {
955 case Instruction::Xor
:
956 if (isa
<UndefValue
>(C1
) && isa
<UndefValue
>(C2
))
957 // Handle undef ^ undef -> 0 special case. This is a common
959 return Constant::getNullValue(C1
->getType());
961 case Instruction::Add
:
962 case Instruction::Sub
:
963 return UndefValue::get(C1
->getType());
964 case Instruction::Mul
:
965 case Instruction::And
:
966 return Constant::getNullValue(C1
->getType());
967 case Instruction::UDiv
:
968 case Instruction::SDiv
:
969 case Instruction::URem
:
970 case Instruction::SRem
:
971 if (!isa
<UndefValue
>(C2
)) // undef / X -> 0
972 return Constant::getNullValue(C1
->getType());
973 return C2
; // X / undef -> undef
974 case Instruction::Or
: // X | undef -> -1
975 if (const VectorType
*PTy
= dyn_cast
<VectorType
>(C1
->getType()))
976 return Constant::getAllOnesValue(PTy
);
977 return Constant::getAllOnesValue(C1
->getType());
978 case Instruction::LShr
:
979 if (isa
<UndefValue
>(C2
) && isa
<UndefValue
>(C1
))
980 return C1
; // undef lshr undef -> undef
981 return Constant::getNullValue(C1
->getType()); // X lshr undef -> 0
983 case Instruction::AShr
:
984 if (!isa
<UndefValue
>(C2
)) // undef ashr X --> all ones
985 return Constant::getAllOnesValue(C1
->getType());
986 else if (isa
<UndefValue
>(C1
))
987 return C1
; // undef ashr undef -> undef
989 return C1
; // X ashr undef --> X
990 case Instruction::Shl
:
991 // undef << X -> 0 or X << undef -> 0
992 return Constant::getNullValue(C1
->getType());
996 // Handle simplifications when the RHS is a constant int.
997 if (ConstantInt
*CI2
= dyn_cast
<ConstantInt
>(C2
)) {
999 case Instruction::Add
:
1000 if (CI2
->equalsInt(0)) return C1
; // X + 0 == X
1002 case Instruction::Sub
:
1003 if (CI2
->equalsInt(0)) return C1
; // X - 0 == X
1005 case Instruction::Mul
:
1006 if (CI2
->equalsInt(0)) return C2
; // X * 0 == 0
1007 if (CI2
->equalsInt(1))
1008 return C1
; // X * 1 == X
1010 case Instruction::UDiv
:
1011 case Instruction::SDiv
:
1012 if (CI2
->equalsInt(1))
1013 return C1
; // X / 1 == X
1014 if (CI2
->equalsInt(0))
1015 return UndefValue::get(CI2
->getType()); // X / 0 == undef
1017 case Instruction::URem
:
1018 case Instruction::SRem
:
1019 if (CI2
->equalsInt(1))
1020 return Constant::getNullValue(CI2
->getType()); // X % 1 == 0
1021 if (CI2
->equalsInt(0))
1022 return UndefValue::get(CI2
->getType()); // X % 0 == undef
1024 case Instruction::And
:
1025 if (CI2
->isZero()) return C2
; // X & 0 == 0
1026 if (CI2
->isAllOnesValue())
1027 return C1
; // X & -1 == X
1029 if (ConstantExpr
*CE1
= dyn_cast
<ConstantExpr
>(C1
)) {
1030 // (zext i32 to i64) & 4294967295 -> (zext i32 to i64)
1031 if (CE1
->getOpcode() == Instruction::ZExt
) {
1032 unsigned DstWidth
= CI2
->getType()->getBitWidth();
1034 CE1
->getOperand(0)->getType()->getPrimitiveSizeInBits();
1035 APInt
PossiblySetBits(APInt::getLowBitsSet(DstWidth
, SrcWidth
));
1036 if ((PossiblySetBits
& CI2
->getValue()) == PossiblySetBits
)
1040 // If and'ing the address of a global with a constant, fold it.
1041 if (CE1
->getOpcode() == Instruction::PtrToInt
&&
1042 isa
<GlobalValue
>(CE1
->getOperand(0))) {
1043 GlobalValue
*GV
= cast
<GlobalValue
>(CE1
->getOperand(0));
1045 // Functions are at least 4-byte aligned.
1046 unsigned GVAlign
= GV
->getAlignment();
1047 if (isa
<Function
>(GV
))
1048 GVAlign
= std::max(GVAlign
, 4U);
1051 unsigned DstWidth
= CI2
->getType()->getBitWidth();
1052 unsigned SrcWidth
= std::min(DstWidth
, Log2_32(GVAlign
));
1053 APInt
BitsNotSet(APInt::getLowBitsSet(DstWidth
, SrcWidth
));
1055 // If checking bits we know are clear, return zero.
1056 if ((CI2
->getValue() & BitsNotSet
) == CI2
->getValue())
1057 return Constant::getNullValue(CI2
->getType());
1062 case Instruction::Or
:
1063 if (CI2
->equalsInt(0)) return C1
; // X | 0 == X
1064 if (CI2
->isAllOnesValue())
1065 return C2
; // X | -1 == -1
1067 case Instruction::Xor
:
1068 if (CI2
->equalsInt(0)) return C1
; // X ^ 0 == X
1070 if (ConstantExpr
*CE1
= dyn_cast
<ConstantExpr
>(C1
)) {
1071 switch (CE1
->getOpcode()) {
1073 case Instruction::ICmp
:
1074 case Instruction::FCmp
:
1075 // cmp pred ^ true -> cmp !pred
1076 assert(CI2
->equalsInt(1));
1077 CmpInst::Predicate pred
= (CmpInst::Predicate
)CE1
->getPredicate();
1078 pred
= CmpInst::getInversePredicate(pred
);
1079 return ConstantExpr::getCompare(pred
, CE1
->getOperand(0),
1080 CE1
->getOperand(1));
1084 case Instruction::AShr
:
1085 // ashr (zext C to Ty), C2 -> lshr (zext C, CSA), C2
1086 if (ConstantExpr
*CE1
= dyn_cast
<ConstantExpr
>(C1
))
1087 if (CE1
->getOpcode() == Instruction::ZExt
) // Top bits known zero.
1088 return ConstantExpr::getLShr(C1
, C2
);
1091 } else if (isa
<ConstantInt
>(C1
)) {
1092 // If C1 is a ConstantInt and C2 is not, swap the operands.
1093 if (Instruction::isCommutative(Opcode
))
1094 return ConstantExpr::get(Opcode
, C2
, C1
);
1097 // At this point we know neither constant is an UndefValue.
1098 if (ConstantInt
*CI1
= dyn_cast
<ConstantInt
>(C1
)) {
1099 if (ConstantInt
*CI2
= dyn_cast
<ConstantInt
>(C2
)) {
1100 using namespace APIntOps
;
1101 const APInt
&C1V
= CI1
->getValue();
1102 const APInt
&C2V
= CI2
->getValue();
1106 case Instruction::Add
:
1107 return ConstantInt::get(CI1
->getContext(), C1V
+ C2V
);
1108 case Instruction::Sub
:
1109 return ConstantInt::get(CI1
->getContext(), C1V
- C2V
);
1110 case Instruction::Mul
:
1111 return ConstantInt::get(CI1
->getContext(), C1V
* C2V
);
1112 case Instruction::UDiv
:
1113 assert(!CI2
->isNullValue() && "Div by zero handled above");
1114 return ConstantInt::get(CI1
->getContext(), C1V
.udiv(C2V
));
1115 case Instruction::SDiv
:
1116 assert(!CI2
->isNullValue() && "Div by zero handled above");
1117 if (C2V
.isAllOnesValue() && C1V
.isMinSignedValue())
1118 return UndefValue::get(CI1
->getType()); // MIN_INT / -1 -> undef
1119 return ConstantInt::get(CI1
->getContext(), C1V
.sdiv(C2V
));
1120 case Instruction::URem
:
1121 assert(!CI2
->isNullValue() && "Div by zero handled above");
1122 return ConstantInt::get(CI1
->getContext(), C1V
.urem(C2V
));
1123 case Instruction::SRem
:
1124 assert(!CI2
->isNullValue() && "Div by zero handled above");
1125 if (C2V
.isAllOnesValue() && C1V
.isMinSignedValue())
1126 return UndefValue::get(CI1
->getType()); // MIN_INT % -1 -> undef
1127 return ConstantInt::get(CI1
->getContext(), C1V
.srem(C2V
));
1128 case Instruction::And
:
1129 return ConstantInt::get(CI1
->getContext(), C1V
& C2V
);
1130 case Instruction::Or
:
1131 return ConstantInt::get(CI1
->getContext(), C1V
| C2V
);
1132 case Instruction::Xor
:
1133 return ConstantInt::get(CI1
->getContext(), C1V
^ C2V
);
1134 case Instruction::Shl
: {
1135 uint32_t shiftAmt
= C2V
.getZExtValue();
1136 if (shiftAmt
< C1V
.getBitWidth())
1137 return ConstantInt::get(CI1
->getContext(), C1V
.shl(shiftAmt
));
1139 return UndefValue::get(C1
->getType()); // too big shift is undef
1141 case Instruction::LShr
: {
1142 uint32_t shiftAmt
= C2V
.getZExtValue();
1143 if (shiftAmt
< C1V
.getBitWidth())
1144 return ConstantInt::get(CI1
->getContext(), C1V
.lshr(shiftAmt
));
1146 return UndefValue::get(C1
->getType()); // too big shift is undef
1148 case Instruction::AShr
: {
1149 uint32_t shiftAmt
= C2V
.getZExtValue();
1150 if (shiftAmt
< C1V
.getBitWidth())
1151 return ConstantInt::get(CI1
->getContext(), C1V
.ashr(shiftAmt
));
1153 return UndefValue::get(C1
->getType()); // too big shift is undef
1159 case Instruction::SDiv
:
1160 case Instruction::UDiv
:
1161 case Instruction::URem
:
1162 case Instruction::SRem
:
1163 case Instruction::LShr
:
1164 case Instruction::AShr
:
1165 case Instruction::Shl
:
1166 if (CI1
->equalsInt(0)) return C1
;
1171 } else if (ConstantFP
*CFP1
= dyn_cast
<ConstantFP
>(C1
)) {
1172 if (ConstantFP
*CFP2
= dyn_cast
<ConstantFP
>(C2
)) {
1173 APFloat C1V
= CFP1
->getValueAPF();
1174 APFloat C2V
= CFP2
->getValueAPF();
1175 APFloat C3V
= C1V
; // copy for modification
1179 case Instruction::FAdd
:
1180 (void)C3V
.add(C2V
, APFloat::rmNearestTiesToEven
);
1181 return ConstantFP::get(C1
->getContext(), C3V
);
1182 case Instruction::FSub
:
1183 (void)C3V
.subtract(C2V
, APFloat::rmNearestTiesToEven
);
1184 return ConstantFP::get(C1
->getContext(), C3V
);
1185 case Instruction::FMul
:
1186 (void)C3V
.multiply(C2V
, APFloat::rmNearestTiesToEven
);
1187 return ConstantFP::get(C1
->getContext(), C3V
);
1188 case Instruction::FDiv
:
1189 (void)C3V
.divide(C2V
, APFloat::rmNearestTiesToEven
);
1190 return ConstantFP::get(C1
->getContext(), C3V
);
1191 case Instruction::FRem
:
1192 (void)C3V
.mod(C2V
, APFloat::rmNearestTiesToEven
);
1193 return ConstantFP::get(C1
->getContext(), C3V
);
1196 } else if (const VectorType
*VTy
= dyn_cast
<VectorType
>(C1
->getType())) {
1197 ConstantVector
*CP1
= dyn_cast
<ConstantVector
>(C1
);
1198 ConstantVector
*CP2
= dyn_cast
<ConstantVector
>(C2
);
1199 if ((CP1
!= NULL
|| isa
<ConstantAggregateZero
>(C1
)) &&
1200 (CP2
!= NULL
|| isa
<ConstantAggregateZero
>(C2
))) {
1201 std::vector
<Constant
*> Res
;
1202 const Type
* EltTy
= VTy
->getElementType();
1208 case Instruction::Add
:
1209 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1210 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1211 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1212 Res
.push_back(ConstantExpr::getAdd(C1
, C2
));
1214 return ConstantVector::get(Res
);
1215 case Instruction::FAdd
:
1216 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1217 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1218 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1219 Res
.push_back(ConstantExpr::getFAdd(C1
, C2
));
1221 return ConstantVector::get(Res
);
1222 case Instruction::Sub
:
1223 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1224 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1225 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1226 Res
.push_back(ConstantExpr::getSub(C1
, C2
));
1228 return ConstantVector::get(Res
);
1229 case Instruction::FSub
:
1230 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1231 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1232 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1233 Res
.push_back(ConstantExpr::getFSub(C1
, C2
));
1235 return ConstantVector::get(Res
);
1236 case Instruction::Mul
:
1237 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1238 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1239 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1240 Res
.push_back(ConstantExpr::getMul(C1
, C2
));
1242 return ConstantVector::get(Res
);
1243 case Instruction::FMul
:
1244 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1245 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1246 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1247 Res
.push_back(ConstantExpr::getFMul(C1
, C2
));
1249 return ConstantVector::get(Res
);
1250 case Instruction::UDiv
:
1251 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1252 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1253 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1254 Res
.push_back(ConstantExpr::getUDiv(C1
, C2
));
1256 return ConstantVector::get(Res
);
1257 case Instruction::SDiv
:
1258 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1259 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1260 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1261 Res
.push_back(ConstantExpr::getSDiv(C1
, C2
));
1263 return ConstantVector::get(Res
);
1264 case Instruction::FDiv
:
1265 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1266 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1267 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1268 Res
.push_back(ConstantExpr::getFDiv(C1
, C2
));
1270 return ConstantVector::get(Res
);
1271 case Instruction::URem
:
1272 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1273 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1274 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1275 Res
.push_back(ConstantExpr::getURem(C1
, C2
));
1277 return ConstantVector::get(Res
);
1278 case Instruction::SRem
:
1279 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1280 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1281 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1282 Res
.push_back(ConstantExpr::getSRem(C1
, C2
));
1284 return ConstantVector::get(Res
);
1285 case Instruction::FRem
:
1286 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1287 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1288 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1289 Res
.push_back(ConstantExpr::getFRem(C1
, C2
));
1291 return ConstantVector::get(Res
);
1292 case Instruction::And
:
1293 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1294 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1295 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1296 Res
.push_back(ConstantExpr::getAnd(C1
, C2
));
1298 return ConstantVector::get(Res
);
1299 case Instruction::Or
:
1300 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1301 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1302 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1303 Res
.push_back(ConstantExpr::getOr(C1
, C2
));
1305 return ConstantVector::get(Res
);
1306 case Instruction::Xor
:
1307 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1308 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1309 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1310 Res
.push_back(ConstantExpr::getXor(C1
, C2
));
1312 return ConstantVector::get(Res
);
1313 case Instruction::LShr
:
1314 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1315 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1316 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1317 Res
.push_back(ConstantExpr::getLShr(C1
, C2
));
1319 return ConstantVector::get(Res
);
1320 case Instruction::AShr
:
1321 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1322 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1323 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1324 Res
.push_back(ConstantExpr::getAShr(C1
, C2
));
1326 return ConstantVector::get(Res
);
1327 case Instruction::Shl
:
1328 for (unsigned i
= 0, e
= VTy
->getNumElements(); i
!= e
; ++i
) {
1329 C1
= CP1
? CP1
->getOperand(i
) : Constant::getNullValue(EltTy
);
1330 C2
= CP2
? CP2
->getOperand(i
) : Constant::getNullValue(EltTy
);
1331 Res
.push_back(ConstantExpr::getShl(C1
, C2
));
1333 return ConstantVector::get(Res
);
1338 if (ConstantExpr
*CE1
= dyn_cast
<ConstantExpr
>(C1
)) {
1339 // There are many possible foldings we could do here. We should probably
1340 // at least fold add of a pointer with an integer into the appropriate
1341 // getelementptr. This will improve alias analysis a bit.
1343 // Given ((a + b) + c), if (b + c) folds to something interesting, return
1345 if (Instruction::isAssociative(Opcode
) && CE1
->getOpcode() == Opcode
) {
1346 Constant
*T
= ConstantExpr::get(Opcode
, CE1
->getOperand(1), C2
);
1347 if (!isa
<ConstantExpr
>(T
) || cast
<ConstantExpr
>(T
)->getOpcode() != Opcode
)
1348 return ConstantExpr::get(Opcode
, CE1
->getOperand(0), T
);
1350 } else if (isa
<ConstantExpr
>(C2
)) {
1351 // If C2 is a constant expr and C1 isn't, flop them around and fold the
1352 // other way if possible.
1353 if (Instruction::isCommutative(Opcode
))
1354 return ConstantFoldBinaryInstruction(Opcode
, C2
, C1
);
1357 // i1 can be simplified in many cases.
1358 if (C1
->getType()->isIntegerTy(1)) {
1360 case Instruction::Add
:
1361 case Instruction::Sub
:
1362 return ConstantExpr::getXor(C1
, C2
);
1363 case Instruction::Mul
:
1364 return ConstantExpr::getAnd(C1
, C2
);
1365 case Instruction::Shl
:
1366 case Instruction::LShr
:
1367 case Instruction::AShr
:
1368 // We can assume that C2 == 0. If it were one the result would be
1369 // undefined because the shift value is as large as the bitwidth.
1371 case Instruction::SDiv
:
1372 case Instruction::UDiv
:
1373 // We can assume that C2 == 1. If it were zero the result would be
1374 // undefined through division by zero.
1376 case Instruction::URem
:
1377 case Instruction::SRem
:
1378 // We can assume that C2 == 1. If it were zero the result would be
1379 // undefined through division by zero.
1380 return ConstantInt::getFalse(C1
->getContext());
1386 // We don't know how to fold this.
1390 /// isZeroSizedType - This type is zero sized if its an array or structure of
1391 /// zero sized types. The only leaf zero sized type is an empty structure.
1392 static bool isMaybeZeroSizedType(const Type
*Ty
) {
1393 if (Ty
->isOpaqueTy()) return true; // Can't say.
1394 if (const StructType
*STy
= dyn_cast
<StructType
>(Ty
)) {
1396 // If all of elements have zero size, this does too.
1397 for (unsigned i
= 0, e
= STy
->getNumElements(); i
!= e
; ++i
)
1398 if (!isMaybeZeroSizedType(STy
->getElementType(i
))) return false;
1401 } else if (const ArrayType
*ATy
= dyn_cast
<ArrayType
>(Ty
)) {
1402 return isMaybeZeroSizedType(ATy
->getElementType());
1407 /// IdxCompare - Compare the two constants as though they were getelementptr
1408 /// indices. This allows coersion of the types to be the same thing.
1410 /// If the two constants are the "same" (after coersion), return 0. If the
1411 /// first is less than the second, return -1, if the second is less than the
1412 /// first, return 1. If the constants are not integral, return -2.
1414 static int IdxCompare(Constant
*C1
, Constant
*C2
, const Type
*ElTy
) {
1415 if (C1
== C2
) return 0;
1417 // Ok, we found a different index. If they are not ConstantInt, we can't do
1418 // anything with them.
1419 if (!isa
<ConstantInt
>(C1
) || !isa
<ConstantInt
>(C2
))
1420 return -2; // don't know!
1422 // Ok, we have two differing integer indices. Sign extend them to be the same
1423 // type. Long is always big enough, so we use it.
1424 if (!C1
->getType()->isIntegerTy(64))
1425 C1
= ConstantExpr::getSExt(C1
, Type::getInt64Ty(C1
->getContext()));
1427 if (!C2
->getType()->isIntegerTy(64))
1428 C2
= ConstantExpr::getSExt(C2
, Type::getInt64Ty(C1
->getContext()));
1430 if (C1
== C2
) return 0; // They are equal
1432 // If the type being indexed over is really just a zero sized type, there is
1433 // no pointer difference being made here.
1434 if (isMaybeZeroSizedType(ElTy
))
1435 return -2; // dunno.
1437 // If they are really different, now that they are the same type, then we
1438 // found a difference!
1439 if (cast
<ConstantInt
>(C1
)->getSExtValue() <
1440 cast
<ConstantInt
>(C2
)->getSExtValue())
1446 /// evaluateFCmpRelation - This function determines if there is anything we can
1447 /// decide about the two constants provided. This doesn't need to handle simple
1448 /// things like ConstantFP comparisons, but should instead handle ConstantExprs.
1449 /// If we can determine that the two constants have a particular relation to
1450 /// each other, we should return the corresponding FCmpInst predicate,
1451 /// otherwise return FCmpInst::BAD_FCMP_PREDICATE. This is used below in
1452 /// ConstantFoldCompareInstruction.
1454 /// To simplify this code we canonicalize the relation so that the first
1455 /// operand is always the most "complex" of the two. We consider ConstantFP
1456 /// to be the simplest, and ConstantExprs to be the most complex.
1457 static FCmpInst::Predicate
evaluateFCmpRelation(Constant
*V1
, Constant
*V2
) {
1458 assert(V1
->getType() == V2
->getType() &&
1459 "Cannot compare values of different types!");
1461 // No compile-time operations on this type yet.
1462 if (V1
->getType()->isPPC_FP128Ty())
1463 return FCmpInst::BAD_FCMP_PREDICATE
;
1465 // Handle degenerate case quickly
1466 if (V1
== V2
) return FCmpInst::FCMP_OEQ
;
1468 if (!isa
<ConstantExpr
>(V1
)) {
1469 if (!isa
<ConstantExpr
>(V2
)) {
1470 // We distilled thisUse the standard constant folder for a few cases
1472 R
= dyn_cast
<ConstantInt
>(
1473 ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ
, V1
, V2
));
1474 if (R
&& !R
->isZero())
1475 return FCmpInst::FCMP_OEQ
;
1476 R
= dyn_cast
<ConstantInt
>(
1477 ConstantExpr::getFCmp(FCmpInst::FCMP_OLT
, V1
, V2
));
1478 if (R
&& !R
->isZero())
1479 return FCmpInst::FCMP_OLT
;
1480 R
= dyn_cast
<ConstantInt
>(
1481 ConstantExpr::getFCmp(FCmpInst::FCMP_OGT
, V1
, V2
));
1482 if (R
&& !R
->isZero())
1483 return FCmpInst::FCMP_OGT
;
1485 // Nothing more we can do
1486 return FCmpInst::BAD_FCMP_PREDICATE
;
1489 // If the first operand is simple and second is ConstantExpr, swap operands.
1490 FCmpInst::Predicate SwappedRelation
= evaluateFCmpRelation(V2
, V1
);
1491 if (SwappedRelation
!= FCmpInst::BAD_FCMP_PREDICATE
)
1492 return FCmpInst::getSwappedPredicate(SwappedRelation
);
1494 // Ok, the LHS is known to be a constantexpr. The RHS can be any of a
1495 // constantexpr or a simple constant.
1496 ConstantExpr
*CE1
= cast
<ConstantExpr
>(V1
);
1497 switch (CE1
->getOpcode()) {
1498 case Instruction::FPTrunc
:
1499 case Instruction::FPExt
:
1500 case Instruction::UIToFP
:
1501 case Instruction::SIToFP
:
1502 // We might be able to do something with these but we don't right now.
1508 // There are MANY other foldings that we could perform here. They will
1509 // probably be added on demand, as they seem needed.
1510 return FCmpInst::BAD_FCMP_PREDICATE
;
1513 /// evaluateICmpRelation - This function determines if there is anything we can
1514 /// decide about the two constants provided. This doesn't need to handle simple
1515 /// things like integer comparisons, but should instead handle ConstantExprs
1516 /// and GlobalValues. If we can determine that the two constants have a
1517 /// particular relation to each other, we should return the corresponding ICmp
1518 /// predicate, otherwise return ICmpInst::BAD_ICMP_PREDICATE.
1520 /// To simplify this code we canonicalize the relation so that the first
1521 /// operand is always the most "complex" of the two. We consider simple
1522 /// constants (like ConstantInt) to be the simplest, followed by
1523 /// GlobalValues, followed by ConstantExpr's (the most complex).
1525 static ICmpInst::Predicate
evaluateICmpRelation(Constant
*V1
, Constant
*V2
,
1527 assert(V1
->getType() == V2
->getType() &&
1528 "Cannot compare different types of values!");
1529 if (V1
== V2
) return ICmpInst::ICMP_EQ
;
1531 if (!isa
<ConstantExpr
>(V1
) && !isa
<GlobalValue
>(V1
) &&
1532 !isa
<BlockAddress
>(V1
)) {
1533 if (!isa
<GlobalValue
>(V2
) && !isa
<ConstantExpr
>(V2
) &&
1534 !isa
<BlockAddress
>(V2
)) {
1535 // We distilled this down to a simple case, use the standard constant
1538 ICmpInst::Predicate pred
= ICmpInst::ICMP_EQ
;
1539 R
= dyn_cast
<ConstantInt
>(ConstantExpr::getICmp(pred
, V1
, V2
));
1540 if (R
&& !R
->isZero())
1542 pred
= isSigned
? ICmpInst::ICMP_SLT
: ICmpInst::ICMP_ULT
;
1543 R
= dyn_cast
<ConstantInt
>(ConstantExpr::getICmp(pred
, V1
, V2
));
1544 if (R
&& !R
->isZero())
1546 pred
= isSigned
? ICmpInst::ICMP_SGT
: ICmpInst::ICMP_UGT
;
1547 R
= dyn_cast
<ConstantInt
>(ConstantExpr::getICmp(pred
, V1
, V2
));
1548 if (R
&& !R
->isZero())
1551 // If we couldn't figure it out, bail.
1552 return ICmpInst::BAD_ICMP_PREDICATE
;
1555 // If the first operand is simple, swap operands.
1556 ICmpInst::Predicate SwappedRelation
=
1557 evaluateICmpRelation(V2
, V1
, isSigned
);
1558 if (SwappedRelation
!= ICmpInst::BAD_ICMP_PREDICATE
)
1559 return ICmpInst::getSwappedPredicate(SwappedRelation
);
1561 } else if (const GlobalValue
*GV
= dyn_cast
<GlobalValue
>(V1
)) {
1562 if (isa
<ConstantExpr
>(V2
)) { // Swap as necessary.
1563 ICmpInst::Predicate SwappedRelation
=
1564 evaluateICmpRelation(V2
, V1
, isSigned
);
1565 if (SwappedRelation
!= ICmpInst::BAD_ICMP_PREDICATE
)
1566 return ICmpInst::getSwappedPredicate(SwappedRelation
);
1567 return ICmpInst::BAD_ICMP_PREDICATE
;
1570 // Now we know that the RHS is a GlobalValue, BlockAddress or simple
1571 // constant (which, since the types must match, means that it's a
1572 // ConstantPointerNull).
1573 if (const GlobalValue
*GV2
= dyn_cast
<GlobalValue
>(V2
)) {
1574 // Don't try to decide equality of aliases.
1575 if (!isa
<GlobalAlias
>(GV
) && !isa
<GlobalAlias
>(GV2
))
1576 if (!GV
->hasExternalWeakLinkage() || !GV2
->hasExternalWeakLinkage())
1577 return ICmpInst::ICMP_NE
;
1578 } else if (isa
<BlockAddress
>(V2
)) {
1579 return ICmpInst::ICMP_NE
; // Globals never equal labels.
1581 assert(isa
<ConstantPointerNull
>(V2
) && "Canonicalization guarantee!");
1582 // GlobalVals can never be null unless they have external weak linkage.
1583 // We don't try to evaluate aliases here.
1584 if (!GV
->hasExternalWeakLinkage() && !isa
<GlobalAlias
>(GV
))
1585 return ICmpInst::ICMP_NE
;
1587 } else if (const BlockAddress
*BA
= dyn_cast
<BlockAddress
>(V1
)) {
1588 if (isa
<ConstantExpr
>(V2
)) { // Swap as necessary.
1589 ICmpInst::Predicate SwappedRelation
=
1590 evaluateICmpRelation(V2
, V1
, isSigned
);
1591 if (SwappedRelation
!= ICmpInst::BAD_ICMP_PREDICATE
)
1592 return ICmpInst::getSwappedPredicate(SwappedRelation
);
1593 return ICmpInst::BAD_ICMP_PREDICATE
;
1596 // Now we know that the RHS is a GlobalValue, BlockAddress or simple
1597 // constant (which, since the types must match, means that it is a
1598 // ConstantPointerNull).
1599 if (const BlockAddress
*BA2
= dyn_cast
<BlockAddress
>(V2
)) {
1600 // Block address in another function can't equal this one, but block
1601 // addresses in the current function might be the same if blocks are
1603 if (BA2
->getFunction() != BA
->getFunction())
1604 return ICmpInst::ICMP_NE
;
1606 // Block addresses aren't null, don't equal the address of globals.
1607 assert((isa
<ConstantPointerNull
>(V2
) || isa
<GlobalValue
>(V2
)) &&
1608 "Canonicalization guarantee!");
1609 return ICmpInst::ICMP_NE
;
1612 // Ok, the LHS is known to be a constantexpr. The RHS can be any of a
1613 // constantexpr, a global, block address, or a simple constant.
1614 ConstantExpr
*CE1
= cast
<ConstantExpr
>(V1
);
1615 Constant
*CE1Op0
= CE1
->getOperand(0);
1617 switch (CE1
->getOpcode()) {
1618 case Instruction::Trunc
:
1619 case Instruction::FPTrunc
:
1620 case Instruction::FPExt
:
1621 case Instruction::FPToUI
:
1622 case Instruction::FPToSI
:
1623 break; // We can't evaluate floating point casts or truncations.
1625 case Instruction::UIToFP
:
1626 case Instruction::SIToFP
:
1627 case Instruction::BitCast
:
1628 case Instruction::ZExt
:
1629 case Instruction::SExt
:
1630 // If the cast is not actually changing bits, and the second operand is a
1631 // null pointer, do the comparison with the pre-casted value.
1632 if (V2
->isNullValue() &&
1633 (CE1
->getType()->isPointerTy() || CE1
->getType()->isIntegerTy())) {
1634 if (CE1
->getOpcode() == Instruction::ZExt
) isSigned
= false;
1635 if (CE1
->getOpcode() == Instruction::SExt
) isSigned
= true;
1636 return evaluateICmpRelation(CE1Op0
,
1637 Constant::getNullValue(CE1Op0
->getType()),
1642 case Instruction::GetElementPtr
:
1643 // Ok, since this is a getelementptr, we know that the constant has a
1644 // pointer type. Check the various cases.
1645 if (isa
<ConstantPointerNull
>(V2
)) {
1646 // If we are comparing a GEP to a null pointer, check to see if the base
1647 // of the GEP equals the null pointer.
1648 if (const GlobalValue
*GV
= dyn_cast
<GlobalValue
>(CE1Op0
)) {
1649 if (GV
->hasExternalWeakLinkage())
1650 // Weak linkage GVals could be zero or not. We're comparing that
1651 // to null pointer so its greater-or-equal
1652 return isSigned
? ICmpInst::ICMP_SGE
: ICmpInst::ICMP_UGE
;
1654 // If its not weak linkage, the GVal must have a non-zero address
1655 // so the result is greater-than
1656 return isSigned
? ICmpInst::ICMP_SGT
: ICmpInst::ICMP_UGT
;
1657 } else if (isa
<ConstantPointerNull
>(CE1Op0
)) {
1658 // If we are indexing from a null pointer, check to see if we have any
1659 // non-zero indices.
1660 for (unsigned i
= 1, e
= CE1
->getNumOperands(); i
!= e
; ++i
)
1661 if (!CE1
->getOperand(i
)->isNullValue())
1662 // Offsetting from null, must not be equal.
1663 return isSigned
? ICmpInst::ICMP_SGT
: ICmpInst::ICMP_UGT
;
1664 // Only zero indexes from null, must still be zero.
1665 return ICmpInst::ICMP_EQ
;
1667 // Otherwise, we can't really say if the first operand is null or not.
1668 } else if (const GlobalValue
*GV2
= dyn_cast
<GlobalValue
>(V2
)) {
1669 if (isa
<ConstantPointerNull
>(CE1Op0
)) {
1670 if (GV2
->hasExternalWeakLinkage())
1671 // Weak linkage GVals could be zero or not. We're comparing it to
1672 // a null pointer, so its less-or-equal
1673 return isSigned
? ICmpInst::ICMP_SLE
: ICmpInst::ICMP_ULE
;
1675 // If its not weak linkage, the GVal must have a non-zero address
1676 // so the result is less-than
1677 return isSigned
? ICmpInst::ICMP_SLT
: ICmpInst::ICMP_ULT
;
1678 } else if (const GlobalValue
*GV
= dyn_cast
<GlobalValue
>(CE1Op0
)) {
1680 // If this is a getelementptr of the same global, then it must be
1681 // different. Because the types must match, the getelementptr could
1682 // only have at most one index, and because we fold getelementptr's
1683 // with a single zero index, it must be nonzero.
1684 assert(CE1
->getNumOperands() == 2 &&
1685 !CE1
->getOperand(1)->isNullValue() &&
1686 "Suprising getelementptr!");
1687 return isSigned
? ICmpInst::ICMP_SGT
: ICmpInst::ICMP_UGT
;
1689 // If they are different globals, we don't know what the value is,
1690 // but they can't be equal.
1691 return ICmpInst::ICMP_NE
;
1695 ConstantExpr
*CE2
= cast
<ConstantExpr
>(V2
);
1696 Constant
*CE2Op0
= CE2
->getOperand(0);
1698 // There are MANY other foldings that we could perform here. They will
1699 // probably be added on demand, as they seem needed.
1700 switch (CE2
->getOpcode()) {
1702 case Instruction::GetElementPtr
:
1703 // By far the most common case to handle is when the base pointers are
1704 // obviously to the same or different globals.
1705 if (isa
<GlobalValue
>(CE1Op0
) && isa
<GlobalValue
>(CE2Op0
)) {
1706 if (CE1Op0
!= CE2Op0
) // Don't know relative ordering, but not equal
1707 return ICmpInst::ICMP_NE
;
1708 // Ok, we know that both getelementptr instructions are based on the
1709 // same global. From this, we can precisely determine the relative
1710 // ordering of the resultant pointers.
1713 // The logic below assumes that the result of the comparison
1714 // can be determined by finding the first index that differs.
1715 // This doesn't work if there is over-indexing in any
1716 // subsequent indices, so check for that case first.
1717 if (!CE1
->isGEPWithNoNotionalOverIndexing() ||
1718 !CE2
->isGEPWithNoNotionalOverIndexing())
1719 return ICmpInst::BAD_ICMP_PREDICATE
; // Might be equal.
1721 // Compare all of the operands the GEP's have in common.
1722 gep_type_iterator GTI
= gep_type_begin(CE1
);
1723 for (;i
!= CE1
->getNumOperands() && i
!= CE2
->getNumOperands();
1725 switch (IdxCompare(CE1
->getOperand(i
),
1726 CE2
->getOperand(i
), GTI
.getIndexedType())) {
1727 case -1: return isSigned
? ICmpInst::ICMP_SLT
:ICmpInst::ICMP_ULT
;
1728 case 1: return isSigned
? ICmpInst::ICMP_SGT
:ICmpInst::ICMP_UGT
;
1729 case -2: return ICmpInst::BAD_ICMP_PREDICATE
;
1732 // Ok, we ran out of things they have in common. If any leftovers
1733 // are non-zero then we have a difference, otherwise we are equal.
1734 for (; i
< CE1
->getNumOperands(); ++i
)
1735 if (!CE1
->getOperand(i
)->isNullValue()) {
1736 if (isa
<ConstantInt
>(CE1
->getOperand(i
)))
1737 return isSigned
? ICmpInst::ICMP_SGT
: ICmpInst::ICMP_UGT
;
1739 return ICmpInst::BAD_ICMP_PREDICATE
; // Might be equal.
1742 for (; i
< CE2
->getNumOperands(); ++i
)
1743 if (!CE2
->getOperand(i
)->isNullValue()) {
1744 if (isa
<ConstantInt
>(CE2
->getOperand(i
)))
1745 return isSigned
? ICmpInst::ICMP_SLT
: ICmpInst::ICMP_ULT
;
1747 return ICmpInst::BAD_ICMP_PREDICATE
; // Might be equal.
1749 return ICmpInst::ICMP_EQ
;
1758 return ICmpInst::BAD_ICMP_PREDICATE
;
1761 Constant
*llvm::ConstantFoldCompareInstruction(unsigned short pred
,
1762 Constant
*C1
, Constant
*C2
) {
1763 const Type
*ResultTy
;
1764 if (const VectorType
*VT
= dyn_cast
<VectorType
>(C1
->getType()))
1765 ResultTy
= VectorType::get(Type::getInt1Ty(C1
->getContext()),
1766 VT
->getNumElements());
1768 ResultTy
= Type::getInt1Ty(C1
->getContext());
1770 // Fold FCMP_FALSE/FCMP_TRUE unconditionally.
1771 if (pred
== FCmpInst::FCMP_FALSE
)
1772 return Constant::getNullValue(ResultTy
);
1774 if (pred
== FCmpInst::FCMP_TRUE
)
1775 return Constant::getAllOnesValue(ResultTy
);
1777 // Handle some degenerate cases first
1778 if (isa
<UndefValue
>(C1
) || isa
<UndefValue
>(C2
)) {
1779 // For EQ and NE, we can always pick a value for the undef to make the
1780 // predicate pass or fail, so we can return undef.
1781 if (ICmpInst::isEquality(ICmpInst::Predicate(pred
)))
1782 return UndefValue::get(ResultTy
);
1783 // Otherwise, pick the same value as the non-undef operand, and fold
1784 // it to true or false.
1785 return ConstantInt::get(ResultTy
, CmpInst::isTrueWhenEqual(pred
));
1788 // No compile-time operations on this type yet.
1789 if (C1
->getType()->isPPC_FP128Ty())
1792 // icmp eq/ne(null,GV) -> false/true
1793 if (C1
->isNullValue()) {
1794 if (const GlobalValue
*GV
= dyn_cast
<GlobalValue
>(C2
))
1795 // Don't try to evaluate aliases. External weak GV can be null.
1796 if (!isa
<GlobalAlias
>(GV
) && !GV
->hasExternalWeakLinkage()) {
1797 if (pred
== ICmpInst::ICMP_EQ
)
1798 return ConstantInt::getFalse(C1
->getContext());
1799 else if (pred
== ICmpInst::ICMP_NE
)
1800 return ConstantInt::getTrue(C1
->getContext());
1802 // icmp eq/ne(GV,null) -> false/true
1803 } else if (C2
->isNullValue()) {
1804 if (const GlobalValue
*GV
= dyn_cast
<GlobalValue
>(C1
))
1805 // Don't try to evaluate aliases. External weak GV can be null.
1806 if (!isa
<GlobalAlias
>(GV
) && !GV
->hasExternalWeakLinkage()) {
1807 if (pred
== ICmpInst::ICMP_EQ
)
1808 return ConstantInt::getFalse(C1
->getContext());
1809 else if (pred
== ICmpInst::ICMP_NE
)
1810 return ConstantInt::getTrue(C1
->getContext());
1814 // If the comparison is a comparison between two i1's, simplify it.
1815 if (C1
->getType()->isIntegerTy(1)) {
1817 case ICmpInst::ICMP_EQ
:
1818 if (isa
<ConstantInt
>(C2
))
1819 return ConstantExpr::getXor(C1
, ConstantExpr::getNot(C2
));
1820 return ConstantExpr::getXor(ConstantExpr::getNot(C1
), C2
);
1821 case ICmpInst::ICMP_NE
:
1822 return ConstantExpr::getXor(C1
, C2
);
1828 if (isa
<ConstantInt
>(C1
) && isa
<ConstantInt
>(C2
)) {
1829 APInt V1
= cast
<ConstantInt
>(C1
)->getValue();
1830 APInt V2
= cast
<ConstantInt
>(C2
)->getValue();
1832 default: llvm_unreachable("Invalid ICmp Predicate"); return 0;
1833 case ICmpInst::ICMP_EQ
: return ConstantInt::get(ResultTy
, V1
== V2
);
1834 case ICmpInst::ICMP_NE
: return ConstantInt::get(ResultTy
, V1
!= V2
);
1835 case ICmpInst::ICMP_SLT
: return ConstantInt::get(ResultTy
, V1
.slt(V2
));
1836 case ICmpInst::ICMP_SGT
: return ConstantInt::get(ResultTy
, V1
.sgt(V2
));
1837 case ICmpInst::ICMP_SLE
: return ConstantInt::get(ResultTy
, V1
.sle(V2
));
1838 case ICmpInst::ICMP_SGE
: return ConstantInt::get(ResultTy
, V1
.sge(V2
));
1839 case ICmpInst::ICMP_ULT
: return ConstantInt::get(ResultTy
, V1
.ult(V2
));
1840 case ICmpInst::ICMP_UGT
: return ConstantInt::get(ResultTy
, V1
.ugt(V2
));
1841 case ICmpInst::ICMP_ULE
: return ConstantInt::get(ResultTy
, V1
.ule(V2
));
1842 case ICmpInst::ICMP_UGE
: return ConstantInt::get(ResultTy
, V1
.uge(V2
));
1844 } else if (isa
<ConstantFP
>(C1
) && isa
<ConstantFP
>(C2
)) {
1845 APFloat C1V
= cast
<ConstantFP
>(C1
)->getValueAPF();
1846 APFloat C2V
= cast
<ConstantFP
>(C2
)->getValueAPF();
1847 APFloat::cmpResult R
= C1V
.compare(C2V
);
1849 default: llvm_unreachable("Invalid FCmp Predicate"); return 0;
1850 case FCmpInst::FCMP_FALSE
: return Constant::getNullValue(ResultTy
);
1851 case FCmpInst::FCMP_TRUE
: return Constant::getAllOnesValue(ResultTy
);
1852 case FCmpInst::FCMP_UNO
:
1853 return ConstantInt::get(ResultTy
, R
==APFloat::cmpUnordered
);
1854 case FCmpInst::FCMP_ORD
:
1855 return ConstantInt::get(ResultTy
, R
!=APFloat::cmpUnordered
);
1856 case FCmpInst::FCMP_UEQ
:
1857 return ConstantInt::get(ResultTy
, R
==APFloat::cmpUnordered
||
1858 R
==APFloat::cmpEqual
);
1859 case FCmpInst::FCMP_OEQ
:
1860 return ConstantInt::get(ResultTy
, R
==APFloat::cmpEqual
);
1861 case FCmpInst::FCMP_UNE
:
1862 return ConstantInt::get(ResultTy
, R
!=APFloat::cmpEqual
);
1863 case FCmpInst::FCMP_ONE
:
1864 return ConstantInt::get(ResultTy
, R
==APFloat::cmpLessThan
||
1865 R
==APFloat::cmpGreaterThan
);
1866 case FCmpInst::FCMP_ULT
:
1867 return ConstantInt::get(ResultTy
, R
==APFloat::cmpUnordered
||
1868 R
==APFloat::cmpLessThan
);
1869 case FCmpInst::FCMP_OLT
:
1870 return ConstantInt::get(ResultTy
, R
==APFloat::cmpLessThan
);
1871 case FCmpInst::FCMP_UGT
:
1872 return ConstantInt::get(ResultTy
, R
==APFloat::cmpUnordered
||
1873 R
==APFloat::cmpGreaterThan
);
1874 case FCmpInst::FCMP_OGT
:
1875 return ConstantInt::get(ResultTy
, R
==APFloat::cmpGreaterThan
);
1876 case FCmpInst::FCMP_ULE
:
1877 return ConstantInt::get(ResultTy
, R
!=APFloat::cmpGreaterThan
);
1878 case FCmpInst::FCMP_OLE
:
1879 return ConstantInt::get(ResultTy
, R
==APFloat::cmpLessThan
||
1880 R
==APFloat::cmpEqual
);
1881 case FCmpInst::FCMP_UGE
:
1882 return ConstantInt::get(ResultTy
, R
!=APFloat::cmpLessThan
);
1883 case FCmpInst::FCMP_OGE
:
1884 return ConstantInt::get(ResultTy
, R
==APFloat::cmpGreaterThan
||
1885 R
==APFloat::cmpEqual
);
1887 } else if (C1
->getType()->isVectorTy()) {
1888 SmallVector
<Constant
*, 16> C1Elts
, C2Elts
;
1889 C1
->getVectorElements(C1Elts
);
1890 C2
->getVectorElements(C2Elts
);
1891 if (C1Elts
.empty() || C2Elts
.empty())
1894 // If we can constant fold the comparison of each element, constant fold
1895 // the whole vector comparison.
1896 SmallVector
<Constant
*, 4> ResElts
;
1897 for (unsigned i
= 0, e
= C1Elts
.size(); i
!= e
; ++i
) {
1898 // Compare the elements, producing an i1 result or constant expr.
1899 ResElts
.push_back(ConstantExpr::getCompare(pred
, C1Elts
[i
], C2Elts
[i
]));
1901 return ConstantVector::get(&ResElts
[0], ResElts
.size());
1904 if (C1
->getType()->isFloatingPointTy()) {
1905 int Result
= -1; // -1 = unknown, 0 = known false, 1 = known true.
1906 switch (evaluateFCmpRelation(C1
, C2
)) {
1907 default: llvm_unreachable("Unknown relation!");
1908 case FCmpInst::FCMP_UNO
:
1909 case FCmpInst::FCMP_ORD
:
1910 case FCmpInst::FCMP_UEQ
:
1911 case FCmpInst::FCMP_UNE
:
1912 case FCmpInst::FCMP_ULT
:
1913 case FCmpInst::FCMP_UGT
:
1914 case FCmpInst::FCMP_ULE
:
1915 case FCmpInst::FCMP_UGE
:
1916 case FCmpInst::FCMP_TRUE
:
1917 case FCmpInst::FCMP_FALSE
:
1918 case FCmpInst::BAD_FCMP_PREDICATE
:
1919 break; // Couldn't determine anything about these constants.
1920 case FCmpInst::FCMP_OEQ
: // We know that C1 == C2
1921 Result
= (pred
== FCmpInst::FCMP_UEQ
|| pred
== FCmpInst::FCMP_OEQ
||
1922 pred
== FCmpInst::FCMP_ULE
|| pred
== FCmpInst::FCMP_OLE
||
1923 pred
== FCmpInst::FCMP_UGE
|| pred
== FCmpInst::FCMP_OGE
);
1925 case FCmpInst::FCMP_OLT
: // We know that C1 < C2
1926 Result
= (pred
== FCmpInst::FCMP_UNE
|| pred
== FCmpInst::FCMP_ONE
||
1927 pred
== FCmpInst::FCMP_ULT
|| pred
== FCmpInst::FCMP_OLT
||
1928 pred
== FCmpInst::FCMP_ULE
|| pred
== FCmpInst::FCMP_OLE
);
1930 case FCmpInst::FCMP_OGT
: // We know that C1 > C2
1931 Result
= (pred
== FCmpInst::FCMP_UNE
|| pred
== FCmpInst::FCMP_ONE
||
1932 pred
== FCmpInst::FCMP_UGT
|| pred
== FCmpInst::FCMP_OGT
||
1933 pred
== FCmpInst::FCMP_UGE
|| pred
== FCmpInst::FCMP_OGE
);
1935 case FCmpInst::FCMP_OLE
: // We know that C1 <= C2
1936 // We can only partially decide this relation.
1937 if (pred
== FCmpInst::FCMP_UGT
|| pred
== FCmpInst::FCMP_OGT
)
1939 else if (pred
== FCmpInst::FCMP_ULT
|| pred
== FCmpInst::FCMP_OLT
)
1942 case FCmpInst::FCMP_OGE
: // We known that C1 >= C2
1943 // We can only partially decide this relation.
1944 if (pred
== FCmpInst::FCMP_ULT
|| pred
== FCmpInst::FCMP_OLT
)
1946 else if (pred
== FCmpInst::FCMP_UGT
|| pred
== FCmpInst::FCMP_OGT
)
1949 case ICmpInst::ICMP_NE
: // We know that C1 != C2
1950 // We can only partially decide this relation.
1951 if (pred
== FCmpInst::FCMP_OEQ
|| pred
== FCmpInst::FCMP_UEQ
)
1953 else if (pred
== FCmpInst::FCMP_ONE
|| pred
== FCmpInst::FCMP_UNE
)
1958 // If we evaluated the result, return it now.
1960 return ConstantInt::get(ResultTy
, Result
);
1963 // Evaluate the relation between the two constants, per the predicate.
1964 int Result
= -1; // -1 = unknown, 0 = known false, 1 = known true.
1965 switch (evaluateICmpRelation(C1
, C2
, CmpInst::isSigned(pred
))) {
1966 default: llvm_unreachable("Unknown relational!");
1967 case ICmpInst::BAD_ICMP_PREDICATE
:
1968 break; // Couldn't determine anything about these constants.
1969 case ICmpInst::ICMP_EQ
: // We know the constants are equal!
1970 // If we know the constants are equal, we can decide the result of this
1971 // computation precisely.
1972 Result
= ICmpInst::isTrueWhenEqual((ICmpInst::Predicate
)pred
);
1974 case ICmpInst::ICMP_ULT
:
1976 case ICmpInst::ICMP_ULT
: case ICmpInst::ICMP_NE
: case ICmpInst::ICMP_ULE
:
1978 case ICmpInst::ICMP_UGT
: case ICmpInst::ICMP_EQ
: case ICmpInst::ICMP_UGE
:
1982 case ICmpInst::ICMP_SLT
:
1984 case ICmpInst::ICMP_SLT
: case ICmpInst::ICMP_NE
: case ICmpInst::ICMP_SLE
:
1986 case ICmpInst::ICMP_SGT
: case ICmpInst::ICMP_EQ
: case ICmpInst::ICMP_SGE
:
1990 case ICmpInst::ICMP_UGT
:
1992 case ICmpInst::ICMP_UGT
: case ICmpInst::ICMP_NE
: case ICmpInst::ICMP_UGE
:
1994 case ICmpInst::ICMP_ULT
: case ICmpInst::ICMP_EQ
: case ICmpInst::ICMP_ULE
:
1998 case ICmpInst::ICMP_SGT
:
2000 case ICmpInst::ICMP_SGT
: case ICmpInst::ICMP_NE
: case ICmpInst::ICMP_SGE
:
2002 case ICmpInst::ICMP_SLT
: case ICmpInst::ICMP_EQ
: case ICmpInst::ICMP_SLE
:
2006 case ICmpInst::ICMP_ULE
:
2007 if (pred
== ICmpInst::ICMP_UGT
) Result
= 0;
2008 if (pred
== ICmpInst::ICMP_ULT
|| pred
== ICmpInst::ICMP_ULE
) Result
= 1;
2010 case ICmpInst::ICMP_SLE
:
2011 if (pred
== ICmpInst::ICMP_SGT
) Result
= 0;
2012 if (pred
== ICmpInst::ICMP_SLT
|| pred
== ICmpInst::ICMP_SLE
) Result
= 1;
2014 case ICmpInst::ICMP_UGE
:
2015 if (pred
== ICmpInst::ICMP_ULT
) Result
= 0;
2016 if (pred
== ICmpInst::ICMP_UGT
|| pred
== ICmpInst::ICMP_UGE
) Result
= 1;
2018 case ICmpInst::ICMP_SGE
:
2019 if (pred
== ICmpInst::ICMP_SLT
) Result
= 0;
2020 if (pred
== ICmpInst::ICMP_SGT
|| pred
== ICmpInst::ICMP_SGE
) Result
= 1;
2022 case ICmpInst::ICMP_NE
:
2023 if (pred
== ICmpInst::ICMP_EQ
) Result
= 0;
2024 if (pred
== ICmpInst::ICMP_NE
) Result
= 1;
2028 // If we evaluated the result, return it now.
2030 return ConstantInt::get(ResultTy
, Result
);
2032 // If the right hand side is a bitcast, try using its inverse to simplify
2033 // it by moving it to the left hand side. We can't do this if it would turn
2034 // a vector compare into a scalar compare or visa versa.
2035 if (ConstantExpr
*CE2
= dyn_cast
<ConstantExpr
>(C2
)) {
2036 Constant
*CE2Op0
= CE2
->getOperand(0);
2037 if (CE2
->getOpcode() == Instruction::BitCast
&&
2038 CE2
->getType()->isVectorTy() == CE2Op0
->getType()->isVectorTy()) {
2039 Constant
*Inverse
= ConstantExpr::getBitCast(C1
, CE2Op0
->getType());
2040 return ConstantExpr::getICmp(pred
, Inverse
, CE2Op0
);
2044 // If the left hand side is an extension, try eliminating it.
2045 if (ConstantExpr
*CE1
= dyn_cast
<ConstantExpr
>(C1
)) {
2046 if ((CE1
->getOpcode() == Instruction::SExt
&& ICmpInst::isSigned(pred
)) ||
2047 (CE1
->getOpcode() == Instruction::ZExt
&& !ICmpInst::isSigned(pred
))){
2048 Constant
*CE1Op0
= CE1
->getOperand(0);
2049 Constant
*CE1Inverse
= ConstantExpr::getTrunc(CE1
, CE1Op0
->getType());
2050 if (CE1Inverse
== CE1Op0
) {
2051 // Check whether we can safely truncate the right hand side.
2052 Constant
*C2Inverse
= ConstantExpr::getTrunc(C2
, CE1Op0
->getType());
2053 if (ConstantExpr::getZExt(C2Inverse
, C2
->getType()) == C2
) {
2054 return ConstantExpr::getICmp(pred
, CE1Inverse
, C2Inverse
);
2060 if ((!isa
<ConstantExpr
>(C1
) && isa
<ConstantExpr
>(C2
)) ||
2061 (C1
->isNullValue() && !C2
->isNullValue())) {
2062 // If C2 is a constant expr and C1 isn't, flip them around and fold the
2063 // other way if possible.
2064 // Also, if C1 is null and C2 isn't, flip them around.
2065 pred
= ICmpInst::getSwappedPredicate((ICmpInst::Predicate
)pred
);
2066 return ConstantExpr::getICmp(pred
, C2
, C1
);
2072 /// isInBoundsIndices - Test whether the given sequence of *normalized* indices
2074 template<typename IndexTy
>
2075 static bool isInBoundsIndices(IndexTy
const *Idxs
, size_t NumIdx
) {
2076 // No indices means nothing that could be out of bounds.
2077 if (NumIdx
== 0) return true;
2079 // If the first index is zero, it's in bounds.
2080 if (cast
<Constant
>(Idxs
[0])->isNullValue()) return true;
2082 // If the first index is one and all the rest are zero, it's in bounds,
2083 // by the one-past-the-end rule.
2084 if (!cast
<ConstantInt
>(Idxs
[0])->isOne())
2086 for (unsigned i
= 1, e
= NumIdx
; i
!= e
; ++i
)
2087 if (!cast
<Constant
>(Idxs
[i
])->isNullValue())
2092 template<typename IndexTy
>
2093 static Constant
*ConstantFoldGetElementPtrImpl(Constant
*C
,
2095 IndexTy
const *Idxs
,
2097 Constant
*Idx0
= cast
<Constant
>(Idxs
[0]);
2099 (NumIdx
== 1 && Idx0
->isNullValue()))
2102 if (isa
<UndefValue
>(C
)) {
2103 const PointerType
*Ptr
= cast
<PointerType
>(C
->getType());
2104 const Type
*Ty
= GetElementPtrInst::getIndexedType(Ptr
, Idxs
, Idxs
+NumIdx
);
2105 assert(Ty
!= 0 && "Invalid indices for GEP!");
2106 return UndefValue::get(PointerType::get(Ty
, Ptr
->getAddressSpace()));
2109 if (C
->isNullValue()) {
2111 for (unsigned i
= 0, e
= NumIdx
; i
!= e
; ++i
)
2112 if (!cast
<Constant
>(Idxs
[i
])->isNullValue()) {
2117 const PointerType
*Ptr
= cast
<PointerType
>(C
->getType());
2118 const Type
*Ty
= GetElementPtrInst::getIndexedType(Ptr
, Idxs
,
2120 assert(Ty
!= 0 && "Invalid indices for GEP!");
2121 return ConstantPointerNull::get(
2122 PointerType::get(Ty
,Ptr
->getAddressSpace()));
2126 if (ConstantExpr
*CE
= dyn_cast
<ConstantExpr
>(C
)) {
2127 // Combine Indices - If the source pointer to this getelementptr instruction
2128 // is a getelementptr instruction, combine the indices of the two
2129 // getelementptr instructions into a single instruction.
2131 if (CE
->getOpcode() == Instruction::GetElementPtr
) {
2132 const Type
*LastTy
= 0;
2133 for (gep_type_iterator I
= gep_type_begin(CE
), E
= gep_type_end(CE
);
2137 if ((LastTy
&& LastTy
->isArrayTy()) || Idx0
->isNullValue()) {
2138 SmallVector
<Value
*, 16> NewIndices
;
2139 NewIndices
.reserve(NumIdx
+ CE
->getNumOperands());
2140 for (unsigned i
= 1, e
= CE
->getNumOperands()-1; i
!= e
; ++i
)
2141 NewIndices
.push_back(CE
->getOperand(i
));
2143 // Add the last index of the source with the first index of the new GEP.
2144 // Make sure to handle the case when they are actually different types.
2145 Constant
*Combined
= CE
->getOperand(CE
->getNumOperands()-1);
2146 // Otherwise it must be an array.
2147 if (!Idx0
->isNullValue()) {
2148 const Type
*IdxTy
= Combined
->getType();
2149 if (IdxTy
!= Idx0
->getType()) {
2150 const Type
*Int64Ty
= Type::getInt64Ty(IdxTy
->getContext());
2151 Constant
*C1
= ConstantExpr::getSExtOrBitCast(Idx0
, Int64Ty
);
2152 Constant
*C2
= ConstantExpr::getSExtOrBitCast(Combined
, Int64Ty
);
2153 Combined
= ConstantExpr::get(Instruction::Add
, C1
, C2
);
2156 ConstantExpr::get(Instruction::Add
, Idx0
, Combined
);
2160 NewIndices
.push_back(Combined
);
2161 NewIndices
.append(Idxs
+1, Idxs
+NumIdx
);
2162 return (inBounds
&& cast
<GEPOperator
>(CE
)->isInBounds()) ?
2163 ConstantExpr::getInBoundsGetElementPtr(CE
->getOperand(0),
2165 NewIndices
.size()) :
2166 ConstantExpr::getGetElementPtr(CE
->getOperand(0),
2172 // Implement folding of:
2173 // int* getelementptr ([2 x int]* bitcast ([3 x int]* %X to [2 x int]*),
2175 // To: int* getelementptr ([3 x int]* %X, long 0, long 0)
2177 if (CE
->isCast() && NumIdx
> 1 && Idx0
->isNullValue()) {
2178 if (const PointerType
*SPT
=
2179 dyn_cast
<PointerType
>(CE
->getOperand(0)->getType()))
2180 if (const ArrayType
*SAT
= dyn_cast
<ArrayType
>(SPT
->getElementType()))
2181 if (const ArrayType
*CAT
=
2182 dyn_cast
<ArrayType
>(cast
<PointerType
>(C
->getType())->getElementType()))
2183 if (CAT
->getElementType() == SAT
->getElementType())
2185 ConstantExpr::getInBoundsGetElementPtr(
2186 (Constant
*)CE
->getOperand(0), Idxs
, NumIdx
) :
2187 ConstantExpr::getGetElementPtr(
2188 (Constant
*)CE
->getOperand(0), Idxs
, NumIdx
);
2192 // Check to see if any array indices are not within the corresponding
2193 // notional array bounds. If so, try to determine if they can be factored
2194 // out into preceding dimensions.
2195 bool Unknown
= false;
2196 SmallVector
<Constant
*, 8> NewIdxs
;
2197 const Type
*Ty
= C
->getType();
2198 const Type
*Prev
= 0;
2199 for (unsigned i
= 0; i
!= NumIdx
;
2200 Prev
= Ty
, Ty
= cast
<CompositeType
>(Ty
)->getTypeAtIndex(Idxs
[i
]), ++i
) {
2201 if (ConstantInt
*CI
= dyn_cast
<ConstantInt
>(Idxs
[i
])) {
2202 if (const ArrayType
*ATy
= dyn_cast
<ArrayType
>(Ty
))
2203 if (ATy
->getNumElements() <= INT64_MAX
&&
2204 ATy
->getNumElements() != 0 &&
2205 CI
->getSExtValue() >= (int64_t)ATy
->getNumElements()) {
2206 if (isa
<SequentialType
>(Prev
)) {
2207 // It's out of range, but we can factor it into the prior
2209 NewIdxs
.resize(NumIdx
);
2210 ConstantInt
*Factor
= ConstantInt::get(CI
->getType(),
2211 ATy
->getNumElements());
2212 NewIdxs
[i
] = ConstantExpr::getSRem(CI
, Factor
);
2214 Constant
*PrevIdx
= cast
<Constant
>(Idxs
[i
-1]);
2215 Constant
*Div
= ConstantExpr::getSDiv(CI
, Factor
);
2217 // Before adding, extend both operands to i64 to avoid
2218 // overflow trouble.
2219 if (!PrevIdx
->getType()->isIntegerTy(64))
2220 PrevIdx
= ConstantExpr::getSExt(PrevIdx
,
2221 Type::getInt64Ty(Div
->getContext()));
2222 if (!Div
->getType()->isIntegerTy(64))
2223 Div
= ConstantExpr::getSExt(Div
,
2224 Type::getInt64Ty(Div
->getContext()));
2226 NewIdxs
[i
-1] = ConstantExpr::getAdd(PrevIdx
, Div
);
2228 // It's out of range, but the prior dimension is a struct
2229 // so we can't do anything about it.
2234 // We don't know if it's in range or not.
2239 // If we did any factoring, start over with the adjusted indices.
2240 if (!NewIdxs
.empty()) {
2241 for (unsigned i
= 0; i
!= NumIdx
; ++i
)
2242 if (!NewIdxs
[i
]) NewIdxs
[i
] = cast
<Constant
>(Idxs
[i
]);
2244 ConstantExpr::getInBoundsGetElementPtr(C
, NewIdxs
.data(),
2246 ConstantExpr::getGetElementPtr(C
, NewIdxs
.data(), NewIdxs
.size());
2249 // If all indices are known integers and normalized, we can do a simple
2250 // check for the "inbounds" property.
2251 if (!Unknown
&& !inBounds
&&
2252 isa
<GlobalVariable
>(C
) && isInBoundsIndices(Idxs
, NumIdx
))
2253 return ConstantExpr::getInBoundsGetElementPtr(C
, Idxs
, NumIdx
);
2258 Constant
*llvm::ConstantFoldGetElementPtr(Constant
*C
,
2260 Constant
* const *Idxs
,
2262 return ConstantFoldGetElementPtrImpl(C
, inBounds
, Idxs
, NumIdx
);
2265 Constant
*llvm::ConstantFoldGetElementPtr(Constant
*C
,
2269 return ConstantFoldGetElementPtrImpl(C
, inBounds
, Idxs
, NumIdx
);