-//===- ConstantFolding.cpp - LLVM constant folder -------------------------===//
+//===- ConstantFold.cpp - LLVM constant folder ----------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
//
// This file implements folding of constants for LLVM. This implements the
-// (internal) ConstantFolding.h interface, which is used by the
+// (internal) ConstantFold.h interface, which is used by the
// ConstantExpr::get* methods to automatically fold constants when possible.
//
// The current constant folding implementation is implemented in two pieces: the
//
//===----------------------------------------------------------------------===//
-#include "ConstantFolding.h"
+#include "ConstantFold.h"
#include "llvm/Constants.h"
#include "llvm/Instructions.h"
#include "llvm/DerivedTypes.h"
// ConstantFold*Instruction Implementations
//===----------------------------------------------------------------------===//
-/// CastConstantPacked - Convert the specified ConstantPacked node to the
-/// specified packed type. At this point, we know that the elements of the
+/// CastConstantVector - Convert the specified ConstantVector node to the
+/// specified vector type. At this point, we know that the elements of the
/// input packed constant are all simple integer or FP values.
-static Constant *CastConstantPacked(ConstantPacked *CP,
- const PackedType *DstTy) {
- unsigned SrcNumElts = CP->getType()->getNumElements();
+static Constant *CastConstantVector(ConstantVector *CV,
+ const VectorType *DstTy) {
+ unsigned SrcNumElts = CV->getType()->getNumElements();
unsigned DstNumElts = DstTy->getNumElements();
- const Type *SrcEltTy = CP->getType()->getElementType();
+ const Type *SrcEltTy = CV->getType()->getElementType();
const Type *DstEltTy = DstTy->getElementType();
// If both vectors have the same number of elements (thus, the elements
(SrcEltTy->isFloatingPoint() && DstEltTy->isFloatingPoint())) {
for (unsigned i = 0; i != SrcNumElts; ++i)
Result.push_back(
- ConstantExpr::getBitCast(CP->getOperand(i), DstEltTy));
- return ConstantPacked::get(Result);
+ ConstantExpr::getBitCast(CV->getOperand(i), DstEltTy));
+ return ConstantVector::get(Result);
}
// If this is an int-to-fp cast ..
assert(DstEltTy->isFloatingPoint());
if (DstEltTy->getTypeID() == Type::DoubleTyID) {
for (unsigned i = 0; i != SrcNumElts; ++i) {
- double V =
- BitsToDouble(cast<ConstantInt>(CP->getOperand(i))->getZExtValue());
+ ConstantInt *CI = cast<ConstantInt>(CV->getOperand(i));
+ double V = CI->getValue().bitsToDouble();
Result.push_back(ConstantFP::get(Type::DoubleTy, V));
}
- return ConstantPacked::get(Result);
+ return ConstantVector::get(Result);
}
assert(DstEltTy == Type::FloatTy && "Unknown fp type!");
for (unsigned i = 0; i != SrcNumElts; ++i) {
- float V =
- BitsToFloat(cast<ConstantInt>(CP->getOperand(i))->getZExtValue());
+ ConstantInt *CI = cast<ConstantInt>(CV->getOperand(i));
+ float V = CI->getValue().bitsToFloat();
Result.push_back(ConstantFP::get(Type::FloatTy, V));
}
- return ConstantPacked::get(Result);
+ return ConstantVector::get(Result);
}
// Otherwise, this is an fp-to-int cast.
if (SrcEltTy->getTypeID() == Type::DoubleTyID) {
for (unsigned i = 0; i != SrcNumElts; ++i) {
uint64_t V =
- DoubleToBits(cast<ConstantFP>(CP->getOperand(i))->getValue());
+ DoubleToBits(cast<ConstantFP>(CV->getOperand(i))->getValue());
Constant *C = ConstantInt::get(Type::Int64Ty, V);
Result.push_back(ConstantExpr::getBitCast(C, DstEltTy ));
}
- return ConstantPacked::get(Result);
+ return ConstantVector::get(Result);
}
assert(SrcEltTy->getTypeID() == Type::FloatTyID);
for (unsigned i = 0; i != SrcNumElts; ++i) {
- uint32_t V = FloatToBits(cast<ConstantFP>(CP->getOperand(i))->getValue());
+ uint32_t V = FloatToBits(cast<ConstantFP>(CV->getOperand(i))->getValue());
Constant *C = ConstantInt::get(Type::Int32Ty, V);
Result.push_back(ConstantExpr::getBitCast(C, DstEltTy));
}
- return ConstantPacked::get(Result);
+ return ConstantVector::get(Result);
}
// Otherwise, this is a cast that changes element count and size. Handle
return ConstantFP::get(DestTy, FPC->getValue());
return 0; // Can't fold.
case Instruction::FPToUI:
- if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V))
- return ConstantInt::get(DestTy,(uint64_t) FPC->getValue());
+ if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
+ uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
+ APInt Val(APIntOps::RoundDoubleToAPInt(FPC->getValue(), DestBitWidth));
+ return ConstantInt::get(Val);
+ }
return 0; // Can't fold.
case Instruction::FPToSI:
- if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V))
- return ConstantInt::get(DestTy,(int64_t) FPC->getValue());
+ if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
+ uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
+ APInt Val(APIntOps::RoundDoubleToAPInt(FPC->getValue(), DestBitWidth));
+ return ConstantInt::get(Val);
+ }
return 0; // Can't fold.
case Instruction::IntToPtr: //always treated as unsigned
if (V->isNullValue()) // Is it an integral null value?
return 0; // Other pointer types cannot be casted
case Instruction::UIToFP:
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
- return ConstantFP::get(DestTy, double(CI->getZExtValue()));
+ return ConstantFP::get(DestTy, CI->getValue().roundToDouble());
return 0;
case Instruction::SIToFP:
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
- return ConstantFP::get(DestTy, double(CI->getSExtValue()));
+ return ConstantFP::get(DestTy, CI->getValue().signedRoundToDouble());
return 0;
case Instruction::ZExt:
- if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
- return ConstantInt::get(DestTy, CI->getZExtValue());
+ if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
+ uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
+ APInt Result(CI->getValue());
+ Result.zext(BitWidth);
+ return ConstantInt::get(Result);
+ }
return 0;
case Instruction::SExt:
- if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
- return ConstantInt::get(DestTy, CI->getSExtValue());
+ if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
+ uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
+ APInt Result(CI->getValue());
+ Result.sext(BitWidth);
+ return ConstantInt::get(Result);
+ }
return 0;
case Instruction::Trunc:
- if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) // Can't trunc a bool
- return ConstantInt::get(DestTy, CI->getZExtValue());
+ if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
+ uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
+ APInt Result(CI->getValue());
+ Result.trunc(BitWidth);
+ return ConstantInt::get(Result);
+ }
return 0;
case Instruction::BitCast:
if (SrcTy == DestTy)
// Handle casts from one packed constant to another. We know that the src
// and dest type have the same size (otherwise its an illegal cast).
- if (const PackedType *DestPTy = dyn_cast<PackedType>(DestTy)) {
- if (const PackedType *SrcTy = dyn_cast<PackedType>(V->getType())) {
+ if (const VectorType *DestPTy = dyn_cast<VectorType>(DestTy)) {
+ if (const VectorType *SrcTy = dyn_cast<VectorType>(V->getType())) {
assert(DestPTy->getBitWidth() == SrcTy->getBitWidth() &&
"Not cast between same sized vectors!");
// First, check for null and undef
if (isa<UndefValue>(V))
return UndefValue::get(DestTy);
- if (const ConstantPacked *CP = dyn_cast<ConstantPacked>(V)) {
- // This is a cast from a ConstantPacked of one type to a
- // ConstantPacked of another type. Check to see if all elements of
+ if (const ConstantVector *CV = dyn_cast<ConstantVector>(V)) {
+ // This is a cast from a ConstantVector of one type to a
+ // ConstantVector of another type. Check to see if all elements of
// the input are simple.
bool AllSimpleConstants = true;
- for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i) {
- if (!isa<ConstantInt>(CP->getOperand(i)) &&
- !isa<ConstantFP>(CP->getOperand(i))) {
+ for (unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
+ if (!isa<ConstantInt>(CV->getOperand(i)) &&
+ !isa<ConstantFP>(CV->getOperand(i))) {
AllSimpleConstants = false;
break;
}
// If all of the elements are simple constants, we can fold this.
if (AllSimpleConstants)
- return CastConstantPacked(const_cast<ConstantPacked*>(CP), DestPTy);
+ return CastConstantVector(const_cast<ConstantVector*>(CV), DestPTy);
}
}
}
// Handle integral constant input.
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
- // Integral -> Integral, must be changing sign.
if (DestTy->isInteger())
- return ConstantInt::get(DestTy, CI->getZExtValue());
+ // Integral -> Integral. This is a no-op because the bit widths must
+ // be the same. Consequently, we just fold to V.
+ return const_cast<Constant*>(V);
if (DestTy->isFloatingPoint()) {
if (DestTy == Type::FloatTy)
- return ConstantFP::get(DestTy, BitsToFloat(CI->getZExtValue()));
+ return ConstantFP::get(DestTy, CI->getValue().bitsToFloat());
assert(DestTy == Type::DoubleTy && "Unknown FP type!");
- return ConstantFP::get(DestTy, BitsToDouble(CI->getZExtValue()));
+ return ConstantFP::get(DestTy, CI->getValue().bitsToDouble());
}
// Otherwise, can't fold this (packed?)
return 0;
if (const ConstantFP *FP = dyn_cast<ConstantFP>(V)) {
// FP -> Integral.
if (DestTy == Type::Int32Ty) {
- return ConstantInt::get(DestTy, FloatToBits(FP->getValue()));
+ APInt Val(32, 0);
+ return ConstantInt::get(Val.floatToBits(FP->getValue()));
} else {
assert(DestTy == Type::Int64Ty && "only support f32/f64 for now!");
- return ConstantInt::get(DestTy, DoubleToBits(FP->getValue()));
+ APInt Val(64, 0);
+ return ConstantInt::get(Val.doubleToBits(FP->getValue()));
}
}
return 0;
Constant *llvm::ConstantFoldExtractElementInstruction(const Constant *Val,
const Constant *Idx) {
if (isa<UndefValue>(Val)) // ee(undef, x) -> undef
- return UndefValue::get(cast<PackedType>(Val->getType())->getElementType());
+ return UndefValue::get(cast<VectorType>(Val->getType())->getElementType());
if (Val->isNullValue()) // ee(zero, x) -> zero
return Constant::getNullValue(
- cast<PackedType>(Val->getType())->getElementType());
+ cast<VectorType>(Val->getType())->getElementType());
- if (const ConstantPacked *CVal = dyn_cast<ConstantPacked>(Val)) {
+ if (const ConstantVector *CVal = dyn_cast<ConstantVector>(Val)) {
if (const ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx)) {
return const_cast<Constant*>(CVal->getOperand(CIdx->getZExtValue()));
} else if (isa<UndefValue>(Idx)) {
const Constant *Idx) {
const ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx);
if (!CIdx) return 0;
- uint64_t idxVal = CIdx->getZExtValue();
+ APInt idxVal = CIdx->getValue();
if (isa<UndefValue>(Val)) {
// Insertion of scalar constant into packed undef
// Optimize away insertion of undef
// Otherwise break the aggregate undef into multiple undefs and do
// the insertion
unsigned numOps =
- cast<PackedType>(Val->getType())->getNumElements();
+ cast<VectorType>(Val->getType())->getNumElements();
std::vector<Constant*> Ops;
Ops.reserve(numOps);
for (unsigned i = 0; i < numOps; ++i) {
const Constant *Op =
- (i == idxVal) ? Elt : UndefValue::get(Elt->getType());
+ (idxVal == i) ? Elt : UndefValue::get(Elt->getType());
Ops.push_back(const_cast<Constant*>(Op));
}
- return ConstantPacked::get(Ops);
+ return ConstantVector::get(Ops);
}
if (isa<ConstantAggregateZero>(Val)) {
// Insertion of scalar constant into packed aggregate zero
// Otherwise break the aggregate zero into multiple zeros and do
// the insertion
unsigned numOps =
- cast<PackedType>(Val->getType())->getNumElements();
+ cast<VectorType>(Val->getType())->getNumElements();
std::vector<Constant*> Ops;
Ops.reserve(numOps);
for (unsigned i = 0; i < numOps; ++i) {
const Constant *Op =
- (i == idxVal) ? Elt : Constant::getNullValue(Elt->getType());
+ (idxVal == i) ? Elt : Constant::getNullValue(Elt->getType());
Ops.push_back(const_cast<Constant*>(Op));
}
- return ConstantPacked::get(Ops);
+ return ConstantVector::get(Ops);
}
- if (const ConstantPacked *CVal = dyn_cast<ConstantPacked>(Val)) {
+ if (const ConstantVector *CVal = dyn_cast<ConstantVector>(Val)) {
// Insertion of scalar constant into packed constant
std::vector<Constant*> Ops;
Ops.reserve(CVal->getNumOperands());
for (unsigned i = 0; i < CVal->getNumOperands(); ++i) {
const Constant *Op =
- (i == idxVal) ? Elt : cast<Constant>(CVal->getOperand(i));
+ (idxVal == i) ? Elt : cast<Constant>(CVal->getOperand(i));
Ops.push_back(const_cast<Constant*>(Op));
}
- return ConstantPacked::get(Ops);
+ return ConstantVector::get(Ops);
}
return 0;
}
}
/// EvalVectorOp - Given two packed constants and a function pointer, apply the
-/// function pointer to each element pair, producing a new ConstantPacked
+/// function pointer to each element pair, producing a new ConstantVector
/// constant.
-static Constant *EvalVectorOp(const ConstantPacked *V1,
- const ConstantPacked *V2,
+static Constant *EvalVectorOp(const ConstantVector *V1,
+ const ConstantVector *V2,
Constant *(*FP)(Constant*, Constant*)) {
std::vector<Constant*> Res;
for (unsigned i = 0, e = V1->getNumOperands(); i != e; ++i)
Res.push_back(FP(const_cast<Constant*>(V1->getOperand(i)),
const_cast<Constant*>(V2->getOperand(i))));
- return ConstantPacked::get(Res);
+ return ConstantVector::get(Res);
}
Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode,
return Constant::getNullValue(C1->getType());
return const_cast<Constant*>(C2); // X / undef -> undef
case Instruction::Or: // X | undef -> -1
- if (const PackedType *PTy = dyn_cast<PackedType>(C1->getType()))
- return ConstantPacked::getAllOnesValue(PTy);
+ if (const VectorType *PTy = dyn_cast<VectorType>(C1->getType()))
+ return ConstantVector::getAllOnesValue(PTy);
return ConstantInt::getAllOnesValue(C1->getType());
case Instruction::LShr:
if (isa<UndefValue>(C2) && isa<UndefValue>(C1))
case Instruction::Mul:
if (C2->isNullValue()) return const_cast<Constant*>(C2); // X * 0 == 0
if (const ConstantInt *CI = dyn_cast<ConstantInt>(C2))
- if (CI->getZExtValue() == 1)
+ if (CI->equalsInt(1))
return const_cast<Constant*>(C1); // X * 1 == X
break;
case Instruction::UDiv:
case Instruction::SDiv:
if (const ConstantInt *CI = dyn_cast<ConstantInt>(C2))
- if (CI->getZExtValue() == 1)
+ if (CI->equalsInt(1))
return const_cast<Constant*>(C1); // X / 1 == X
break;
case Instruction::URem:
case Instruction::SRem:
if (const ConstantInt *CI = dyn_cast<ConstantInt>(C2))
- if (CI->getZExtValue() == 1)
+ if (CI->equalsInt(1))
return Constant::getNullValue(CI->getType()); // X % 1 == 0
break;
case Instruction::And:
// Functions are at least 4-byte aligned. If and'ing the address of a
// function with a constant < 4, fold it to zero.
if (const ConstantInt *CI = dyn_cast<ConstantInt>(C2))
- if (CI->getZExtValue() < 4 && isa<Function>(CPR))
+ if (CI->getValue().ult(APInt(CI->getType()->getBitWidth(),4)) &&
+ isa<Function>(CPR))
return Constant::getNullValue(CI->getType());
}
break;
// so look at directly computing the value.
if (const ConstantInt *CI1 = dyn_cast<ConstantInt>(C1)) {
if (const ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
- uint64_t C1Val = CI1->getZExtValue();
- uint64_t C2Val = CI2->getZExtValue();
+ using namespace APIntOps;
+ APInt C1V = CI1->getValue();
+ APInt C2V = CI2->getValue();
switch (Opcode) {
default:
break;
case Instruction::Add:
- return ConstantInt::get(C1->getType(), C1Val + C2Val);
+ return ConstantInt::get(C1V + C2V);
case Instruction::Sub:
- return ConstantInt::get(C1->getType(), C1Val - C2Val);
+ return ConstantInt::get(C1V - C2V);
case Instruction::Mul:
- return ConstantInt::get(C1->getType(), C1Val * C2Val);
+ return ConstantInt::get(C1V * C2V);
case Instruction::UDiv:
- if (CI2->isNullValue()) // X / 0 -> can't fold
- return 0;
- return ConstantInt::get(C1->getType(), C1Val / C2Val);
+ if (CI2->isNullValue())
+ return 0; // X / 0 -> can't fold
+ return ConstantInt::get(C1V.udiv(C2V));
case Instruction::SDiv:
- if (CI2->isNullValue()) return 0; // X / 0 -> can't fold
- if (CI2->isAllOnesValue() &&
- (((CI1->getType()->getPrimitiveSizeInBits() == 64) &&
- (CI1->getSExtValue() == INT64_MIN)) ||
- (CI1->getSExtValue() == -CI1->getSExtValue())))
- return 0; // MIN_INT / -1 -> overflow
- return ConstantInt::get(C1->getType(),
- CI1->getSExtValue() / CI2->getSExtValue());
- case Instruction::URem:
- if (C2->isNullValue()) return 0; // X / 0 -> can't fold
- return ConstantInt::get(C1->getType(), C1Val % C2Val);
+ if (CI2->isNullValue())
+ return 0; // X / 0 -> can't fold
+ if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
+ return 0; // MIN_INT / -1 -> overflow
+ return ConstantInt::get(C1V.sdiv(C2V));
+ case Instruction::URem:
+ if (C2->isNullValue())
+ return 0; // X / 0 -> can't fold
+ return ConstantInt::get(C1V.urem(C2V));
case Instruction::SRem:
- if (CI2->isNullValue()) return 0; // X % 0 -> can't fold
- if (CI2->isAllOnesValue() &&
- (((CI1->getType()->getPrimitiveSizeInBits() == 64) &&
- (CI1->getSExtValue() == INT64_MIN)) ||
- (CI1->getSExtValue() == -CI1->getSExtValue())))
- return 0; // MIN_INT % -1 -> overflow
- return ConstantInt::get(C1->getType(),
- CI1->getSExtValue() % CI2->getSExtValue());
+ if (CI2->isNullValue())
+ return 0; // X % 0 -> can't fold
+ if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
+ return 0; // MIN_INT % -1 -> overflow
+ return ConstantInt::get(C1V.srem(C2V));
case Instruction::And:
- return ConstantInt::get(C1->getType(), C1Val & C2Val);
+ return ConstantInt::get(C1V & C2V);
case Instruction::Or:
- return ConstantInt::get(C1->getType(), C1Val | C2Val);
+ return ConstantInt::get(C1V | C2V);
case Instruction::Xor:
- return ConstantInt::get(C1->getType(), C1Val ^ C2Val);
+ return ConstantInt::get(C1V ^ C2V);
case Instruction::Shl:
- return ConstantInt::get(C1->getType(), C1Val << C2Val);
+ if (uint32_t shiftAmt = C2V.getZExtValue())
+ if (shiftAmt < C1V.getBitWidth())
+ return ConstantInt::get(C1V.shl(shiftAmt));
+ else
+ return UndefValue::get(C1->getType()); // too big shift is undef
+ return const_cast<ConstantInt*>(CI1); // Zero shift is identity
case Instruction::LShr:
- return ConstantInt::get(C1->getType(), C1Val >> C2Val);
+ if (uint32_t shiftAmt = C2V.getZExtValue())
+ if (shiftAmt < C1V.getBitWidth())
+ return ConstantInt::get(C1V.lshr(shiftAmt));
+ else
+ return UndefValue::get(C1->getType()); // too big shift is undef
+ return const_cast<ConstantInt*>(CI1); // Zero shift is identity
case Instruction::AShr:
- return ConstantInt::get(C1->getType(),
- CI1->getSExtValue() >> C2Val);
+ if (uint32_t shiftAmt = C2V.getZExtValue())
+ if (shiftAmt < C1V.getBitWidth())
+ return ConstantInt::get(C1V.ashr(shiftAmt));
+ else
+ return UndefValue::get(C1->getType()); // too big shift is undef
+ return const_cast<ConstantInt*>(CI1); // Zero shift is identity
}
}
} else if (const ConstantFP *CFP1 = dyn_cast<ConstantFP>(C1)) {
case Instruction::Mul:
return ConstantFP::get(CFP1->getType(), C1Val * C2Val);
case Instruction::FDiv:
- if (CFP2->isExactlyValue(0.0))
- return ConstantFP::get(CFP1->getType(),
- std::numeric_limits<double>::infinity());
- if (CFP2->isExactlyValue(-0.0))
- return ConstantFP::get(CFP1->getType(),
- -std::numeric_limits<double>::infinity());
+ if (CFP2->isExactlyValue(0.0) || CFP2->isExactlyValue(-0.0))
+ if (CFP1->isExactlyValue(0.0) || CFP1->isExactlyValue(-0.0))
+ // IEEE 754, Section 7.1, #4
+ return ConstantFP::get(CFP1->getType(),
+ std::numeric_limits<double>::quiet_NaN());
+ else if (CFP2->isExactlyValue(-0.0) || C1Val < 0.0)
+ // IEEE 754, Section 7.2, negative infinity case
+ return ConstantFP::get(CFP1->getType(),
+ -std::numeric_limits<double>::infinity());
+ else
+ // IEEE 754, Section 7.2, positive infinity case
+ return ConstantFP::get(CFP1->getType(),
+ std::numeric_limits<double>::infinity());
return ConstantFP::get(CFP1->getType(), C1Val / C2Val);
case Instruction::FRem:
- if (CFP2->isNullValue())
- return 0;
+ if (CFP2->isExactlyValue(0.0) || CFP2->isExactlyValue(-0.0))
+ // IEEE 754, Section 7.1, #5
+ return ConstantFP::get(CFP1->getType(),
+ std::numeric_limits<double>::quiet_NaN());
return ConstantFP::get(CFP1->getType(), std::fmod(C1Val, C2Val));
+
}
}
- } else if (const ConstantPacked *CP1 = dyn_cast<ConstantPacked>(C1)) {
- if (const ConstantPacked *CP2 = dyn_cast<ConstantPacked>(C2)) {
+ } else if (const ConstantVector *CP1 = dyn_cast<ConstantVector>(C1)) {
+ if (const ConstantVector *CP2 = dyn_cast<ConstantVector>(C2)) {
switch (Opcode) {
default:
break;
Constant *C2 = const_cast<Constant*>(V2);
R = dyn_cast<ConstantInt>(
ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ, C1, C2));
- if (R && R->getZExtValue())
+ if (R && !R->isZero())
return FCmpInst::FCMP_OEQ;
R = dyn_cast<ConstantInt>(
ConstantExpr::getFCmp(FCmpInst::FCMP_OLT, C1, C2));
- if (R && R->getZExtValue())
+ if (R && !R->isZero())
return FCmpInst::FCMP_OLT;
R = dyn_cast<ConstantInt>(
ConstantExpr::getFCmp(FCmpInst::FCMP_OGT, C1, C2));
- if (R && R->getZExtValue())
+ if (R && !R->isZero())
return FCmpInst::FCMP_OGT;
// Nothing more we can do
Constant *C2 = const_cast<Constant*>(V2);
ICmpInst::Predicate pred = ICmpInst::ICMP_EQ;
R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
- if (R && R->getZExtValue())
+ if (R && !R->isZero())
return pred;
pred = isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
- if (R && R->getZExtValue())
+ if (R && !R->isZero())
return pred;
pred = isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
- if (R && R->getZExtValue())
+ if (R && !R->isZero())
return pred;
// If we couldn't figure it out, bail.
}
if (isa<ConstantInt>(C1) && isa<ConstantInt>(C2)) {
- if (ICmpInst::isSignedPredicate(ICmpInst::Predicate(pred))) {
- int64_t V1 = cast<ConstantInt>(C1)->getSExtValue();
- int64_t V2 = cast<ConstantInt>(C2)->getSExtValue();
- switch (pred) {
- default: assert(0 && "Invalid ICmp Predicate"); return 0;
- case ICmpInst::ICMP_SLT:return ConstantInt::get(Type::Int1Ty, V1 < V2);
- case ICmpInst::ICMP_SGT:return ConstantInt::get(Type::Int1Ty, V1 > V2);
- case ICmpInst::ICMP_SLE:return ConstantInt::get(Type::Int1Ty, V1 <= V2);
- case ICmpInst::ICMP_SGE:return ConstantInt::get(Type::Int1Ty, V1 >= V2);
- }
- } else {
- uint64_t V1 = cast<ConstantInt>(C1)->getZExtValue();
- uint64_t V2 = cast<ConstantInt>(C2)->getZExtValue();
- switch (pred) {
- default: assert(0 && "Invalid ICmp Predicate"); return 0;
- case ICmpInst::ICMP_EQ: return ConstantInt::get(Type::Int1Ty, V1 == V2);
- case ICmpInst::ICMP_NE: return ConstantInt::get(Type::Int1Ty, V1 != V2);
- case ICmpInst::ICMP_ULT:return ConstantInt::get(Type::Int1Ty, V1 < V2);
- case ICmpInst::ICMP_UGT:return ConstantInt::get(Type::Int1Ty, V1 > V2);
- case ICmpInst::ICMP_ULE:return ConstantInt::get(Type::Int1Ty, V1 <= V2);
- case ICmpInst::ICMP_UGE:return ConstantInt::get(Type::Int1Ty, V1 >= V2);
- }
+ APInt V1 = cast<ConstantInt>(C1)->getValue();
+ APInt V2 = cast<ConstantInt>(C2)->getValue();
+ switch (pred) {
+ default: assert(0 && "Invalid ICmp Predicate"); return 0;
+ case ICmpInst::ICMP_EQ: return ConstantInt::get(Type::Int1Ty, V1 == V2);
+ case ICmpInst::ICMP_NE: return ConstantInt::get(Type::Int1Ty, V1 != V2);
+ case ICmpInst::ICMP_SLT:return ConstantInt::get(Type::Int1Ty, V1.slt(V2));
+ case ICmpInst::ICMP_SGT:return ConstantInt::get(Type::Int1Ty, V1.sgt(V2));
+ case ICmpInst::ICMP_SLE:return ConstantInt::get(Type::Int1Ty, V1.sle(V2));
+ case ICmpInst::ICMP_SGE:return ConstantInt::get(Type::Int1Ty, V1.sge(V2));
+ case ICmpInst::ICMP_ULT:return ConstantInt::get(Type::Int1Ty, V1.ult(V2));
+ case ICmpInst::ICMP_UGT:return ConstantInt::get(Type::Int1Ty, V1.ugt(V2));
+ case ICmpInst::ICMP_ULE:return ConstantInt::get(Type::Int1Ty, V1.ule(V2));
+ case ICmpInst::ICMP_UGE:return ConstantInt::get(Type::Int1Ty, V1.uge(V2));
}
} else if (isa<ConstantFP>(C1) && isa<ConstantFP>(C2)) {
double C1Val = cast<ConstantFP>(C1)->getValue();
case FCmpInst::FCMP_OGE:
return ConstantInt::get(Type::Int1Ty, C1Val >= C2Val);
}
- } else if (const ConstantPacked *CP1 = dyn_cast<ConstantPacked>(C1)) {
- if (const ConstantPacked *CP2 = dyn_cast<ConstantPacked>(C2)) {
+ } else if (const ConstantVector *CP1 = dyn_cast<ConstantVector>(C1)) {
+ if (const ConstantVector *CP2 = dyn_cast<ConstantVector>(C2)) {
if (pred == FCmpInst::FCMP_OEQ || pred == FCmpInst::FCMP_UEQ) {
for (unsigned i = 0, e = CP1->getNumOperands(); i != e; ++i) {
Constant *C= ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ,