if (const VectorType *SrcTy = dyn_cast<VectorType>(V->getType())) {
assert(DestPTy->getBitWidth() == SrcTy->getBitWidth() &&
"Not cast between same sized vectors!");
+ SrcTy = NULL;
// First, check for null. Undef is already handled.
if (isa<ConstantAggregateZero>(V))
return Constant::getNullValue(DestTy);
if (ConstantVector *CV = dyn_cast<ConstantVector>(V))
return BitCastConstantVector(CV, DestPTy);
}
+
+ // Canonicalize scalar-to-vector bitcasts into vector-to-vector bitcasts
+ // This allows for other simplifications (although some of them
+ // can only be handled by Analysis/ConstantFolding.cpp).
+ if (isa<ConstantInt>(V) || isa<ConstantFP>(V))
+ return ConstantExpr::getBitCast(ConstantVector::get(&V, 1), DestPTy);
}
// Finally, implement bitcast folding now. The code below doesn't handle
// Integral -> Integral. This is a no-op because the bit widths must
// be the same. Consequently, we just fold to V.
return V;
-
- if (DestTy->isFloatingPoint()) {
- assert((DestTy == Type::DoubleTy || DestTy == Type::FloatTy) &&
- "Unknown FP type!");
- return ConstantFP::get(APFloat(CI->getValue()));
- }
+
+ if (DestTy->isFloatingPoint())
+ return ConstantFP::get(APFloat(CI->getValue(),
+ DestTy != Type::PPC_FP128Ty));
+
// Otherwise, can't fold this (vector?)
return 0;
}
-
+
// Handle ConstantFP input.
- if (const ConstantFP *FP = dyn_cast<ConstantFP>(V)) {
+ if (const ConstantFP *FP = dyn_cast<ConstantFP>(V))
// FP -> Integral.
- if (DestTy == Type::Int32Ty) {
- return ConstantInt::get(FP->getValueAPF().convertToAPInt());
- } else {
- assert(DestTy == Type::Int64Ty && "only support f32/f64 for now!");
- return ConstantInt::get(FP->getValueAPF().convertToAPInt());
- }
- }
+ return ConstantInt::get(FP->getValueAPF().bitcastToAPInt());
+
return 0;
}
}
}
+ // If the cast operand is a constant vector, perform the cast by
+ // operating on each element. In the cast of bitcasts, the element
+ // count may be mismatched; don't attempt to handle that here.
+ if (const ConstantVector *CV = dyn_cast<ConstantVector>(V))
+ if (isa<VectorType>(DestTy) &&
+ cast<VectorType>(DestTy)->getNumElements() ==
+ CV->getType()->getNumElements()) {
+ std::vector<Constant*> res;
+ const VectorType *DestVecTy = cast<VectorType>(DestTy);
+ const Type *DstEltTy = DestVecTy->getElementType();
+ for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i)
+ res.push_back(ConstantExpr::getCast(opc,
+ CV->getOperand(i), DstEltTy));
+ return ConstantVector::get(DestVecTy, res);
+ }
+
// We actually have to do a cast now. Perform the cast according to the
// opcode specified.
switch (opc) {
case Instruction::FPTrunc:
case Instruction::FPExt:
if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
+ bool ignored;
APFloat Val = FPC->getValueAPF();
Val.convert(DestTy == Type::FloatTy ? APFloat::IEEEsingle :
DestTy == Type::DoubleTy ? APFloat::IEEEdouble :
DestTy == Type::X86_FP80Ty ? APFloat::x87DoubleExtended :
DestTy == Type::FP128Ty ? APFloat::IEEEquad :
APFloat::Bogus,
- APFloat::rmNearestTiesToEven);
+ APFloat::rmNearestTiesToEven, &ignored);
return ConstantFP::get(Val);
}
return 0; // Can't fold.
case Instruction::FPToSI:
if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
const APFloat &V = FPC->getValueAPF();
+ bool ignored;
uint64_t x[2];
uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
(void) V.convertToInteger(x, DestBitWidth, opc==Instruction::FPToSI,
- APFloat::rmTowardZero);
+ APFloat::rmTowardZero, &ignored);
APInt Val(DestBitWidth, 2, x);
return ConstantInt::get(Val);
}
- if (const ConstantVector *CV = dyn_cast<ConstantVector>(V)) {
- std::vector<Constant*> res;
- const VectorType *DestVecTy = cast<VectorType>(DestTy);
- const Type *DstEltTy = DestVecTy->getElementType();
- for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i)
- res.push_back(ConstantFoldCastInstruction(opc, V->getOperand(i),
- DstEltTy));
- return ConstantVector::get(DestVecTy, res);
- }
return 0; // Can't fold.
case Instruction::IntToPtr: //always treated as unsigned
if (V->isNullValue()) // Is it an integral null value?
APFloat::rmNearestTiesToEven);
return ConstantFP::get(apf);
}
- if (const ConstantVector *CV = dyn_cast<ConstantVector>(V)) {
- std::vector<Constant*> res;
- const VectorType *DestVecTy = cast<VectorType>(DestTy);
- const Type *DstEltTy = DestVecTy->getElementType();
- for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i)
- res.push_back(ConstantFoldCastInstruction(opc, V->getOperand(i),
- DstEltTy));
- return ConstantVector::get(DestVecTy, res);
- }
return 0;
case Instruction::ZExt:
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
}
return ConstantVector::get(Ops);
}
+
return 0;
}
const Constant *Mask) {
// Undefined shuffle mask -> undefined value.
if (isa<UndefValue>(Mask)) return UndefValue::get(V1->getType());
-
- unsigned NumElts = cast<VectorType>(V1->getType())->getNumElements();
+
+ unsigned MaskNumElts = cast<VectorType>(Mask->getType())->getNumElements();
+ unsigned SrcNumElts = cast<VectorType>(V1->getType())->getNumElements();
const Type *EltTy = cast<VectorType>(V1->getType())->getElementType();
-
+
// Loop over the shuffle mask, evaluating each element.
SmallVector<Constant*, 32> Result;
- for (unsigned i = 0; i != NumElts; ++i) {
+ for (unsigned i = 0; i != MaskNumElts; ++i) {
Constant *InElt = GetVectorElement(Mask, i);
if (InElt == 0) return 0;
-
+
if (isa<UndefValue>(InElt))
InElt = UndefValue::get(EltTy);
else if (ConstantInt *CI = dyn_cast<ConstantInt>(InElt)) {
unsigned Elt = CI->getZExtValue();
- if (Elt >= NumElts*2)
+ if (Elt >= SrcNumElts*2)
InElt = UndefValue::get(EltTy);
- else if (Elt >= NumElts)
- InElt = GetVectorElement(V2, Elt-NumElts);
+ else if (Elt >= SrcNumElts)
+ InElt = GetVectorElement(V2, Elt - SrcNumElts);
else
InElt = GetVectorElement(V1, Elt);
if (InElt == 0) return 0;
}
Result.push_back(InElt);
}
-
+
return ConstantVector::get(&Result[0], Result.size());
}
-Constant *llvm::ConstantFoldExtractValue(const Constant *Agg,
- Constant* const *Idxs,
- unsigned NumIdx) {
- // FIXME: implement some constant folds
- return 0;
+Constant *llvm::ConstantFoldExtractValueInstruction(const Constant *Agg,
+ const unsigned *Idxs,
+ unsigned NumIdx) {
+ // Base case: no indices, so return the entire value.
+ if (NumIdx == 0)
+ return const_cast<Constant *>(Agg);
+
+ if (isa<UndefValue>(Agg)) // ev(undef, x) -> undef
+ return UndefValue::get(ExtractValueInst::getIndexedType(Agg->getType(),
+ Idxs,
+ Idxs + NumIdx));
+
+ if (isa<ConstantAggregateZero>(Agg)) // ev(0, x) -> 0
+ return
+ Constant::getNullValue(ExtractValueInst::getIndexedType(Agg->getType(),
+ Idxs,
+ Idxs + NumIdx));
+
+ // Otherwise recurse.
+ return ConstantFoldExtractValueInstruction(Agg->getOperand(*Idxs),
+ Idxs+1, NumIdx-1);
}
-Constant *llvm::ConstantFoldInsertValue(const Constant *Agg,
- const Constant *Val,
- Constant* const *Idxs,
- unsigned NumIdx) {
- // FIXME: implement some constant folds
+Constant *llvm::ConstantFoldInsertValueInstruction(const Constant *Agg,
+ const Constant *Val,
+ const unsigned *Idxs,
+ unsigned NumIdx) {
+ // Base case: no indices, so replace the entire value.
+ if (NumIdx == 0)
+ return const_cast<Constant *>(Val);
+
+ if (isa<UndefValue>(Agg)) {
+ // Insertion of constant into aggregate undef
+ // Optimize away insertion of undef
+ if (isa<UndefValue>(Val))
+ return const_cast<Constant*>(Agg);
+ // Otherwise break the aggregate undef into multiple undefs and do
+ // the insertion
+ const CompositeType *AggTy = cast<CompositeType>(Agg->getType());
+ unsigned numOps;
+ if (const ArrayType *AR = dyn_cast<ArrayType>(AggTy))
+ numOps = AR->getNumElements();
+ else
+ numOps = cast<StructType>(AggTy)->getNumElements();
+ std::vector<Constant*> Ops(numOps);
+ for (unsigned i = 0; i < numOps; ++i) {
+ const Type *MemberTy = AggTy->getTypeAtIndex(i);
+ const Constant *Op =
+ (*Idxs == i) ?
+ ConstantFoldInsertValueInstruction(UndefValue::get(MemberTy),
+ Val, Idxs+1, NumIdx-1) :
+ UndefValue::get(MemberTy);
+ Ops[i] = const_cast<Constant*>(Op);
+ }
+ if (isa<StructType>(AggTy))
+ return ConstantStruct::get(Ops);
+ else
+ return ConstantArray::get(cast<ArrayType>(AggTy), Ops);
+ }
+ if (isa<ConstantAggregateZero>(Agg)) {
+ // Insertion of constant into aggregate zero
+ // Optimize away insertion of zero
+ if (Val->isNullValue())
+ return const_cast<Constant*>(Agg);
+ // Otherwise break the aggregate zero into multiple zeros and do
+ // the insertion
+ const CompositeType *AggTy = cast<CompositeType>(Agg->getType());
+ unsigned numOps;
+ if (const ArrayType *AR = dyn_cast<ArrayType>(AggTy))
+ numOps = AR->getNumElements();
+ else
+ numOps = cast<StructType>(AggTy)->getNumElements();
+ std::vector<Constant*> Ops(numOps);
+ for (unsigned i = 0; i < numOps; ++i) {
+ const Type *MemberTy = AggTy->getTypeAtIndex(i);
+ const Constant *Op =
+ (*Idxs == i) ?
+ ConstantFoldInsertValueInstruction(Constant::getNullValue(MemberTy),
+ Val, Idxs+1, NumIdx-1) :
+ Constant::getNullValue(MemberTy);
+ Ops[i] = const_cast<Constant*>(Op);
+ }
+ if (isa<StructType>(AggTy))
+ return ConstantStruct::get(Ops);
+ else
+ return ConstantArray::get(cast<ArrayType>(AggTy), Ops);
+ }
+ if (isa<ConstantStruct>(Agg) || isa<ConstantArray>(Agg)) {
+ // Insertion of constant into aggregate constant
+ std::vector<Constant*> Ops(Agg->getNumOperands());
+ for (unsigned i = 0; i < Agg->getNumOperands(); ++i) {
+ const Constant *Op =
+ (*Idxs == i) ?
+ ConstantFoldInsertValueInstruction(Agg->getOperand(i),
+ Val, Idxs+1, NumIdx-1) :
+ Agg->getOperand(i);
+ Ops[i] = const_cast<Constant*>(Op);
+ }
+ Constant *C;
+ if (isa<StructType>(Agg->getType()))
+ C = ConstantStruct::get(Ops);
+ else
+ C = ConstantArray::get(cast<ArrayType>(Agg->getType()), Ops);
+ return C;
+ }
+
return 0;
}
return Constant::getNullValue(C1->getType());
case Instruction::UDiv:
case Instruction::SDiv:
- case Instruction::FDiv:
case Instruction::URem:
case Instruction::SRem:
- case Instruction::FRem:
if (!isa<UndefValue>(C2)) // undef / X -> 0
return Constant::getNullValue(C1->getType());
return const_cast<Constant*>(C2); // X / undef -> undef
case Instruction::SDiv:
if (CI2->equalsInt(1))
return const_cast<Constant*>(C1); // X / 1 == X
+ if (CI2->equalsInt(0))
+ return UndefValue::get(CI2->getType()); // X / 0 == undef
break;
case Instruction::URem:
case Instruction::SRem:
if (CI2->equalsInt(1))
return Constant::getNullValue(CI2->getType()); // X % 1 == 0
+ if (CI2->equalsInt(0))
+ return UndefValue::get(CI2->getType()); // X % 0 == undef
break;
case Instruction::And:
if (CI2->isZero()) return const_cast<Constant*>(C2); // X & 0 == 0
case Instruction::Mul:
return ConstantInt::get(C1V * C2V);
case Instruction::UDiv:
- if (CI2->isNullValue())
- return 0; // X / 0 -> can't fold
+ assert(!CI2->isNullValue() && "Div by zero handled above");
return ConstantInt::get(C1V.udiv(C2V));
case Instruction::SDiv:
- if (CI2->isNullValue())
- return 0; // X / 0 -> can't fold
+ assert(!CI2->isNullValue() && "Div by zero handled above");
if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
- return 0; // MIN_INT / -1 -> overflow
+ return UndefValue::get(CI1->getType()); // MIN_INT / -1 -> undef
return ConstantInt::get(C1V.sdiv(C2V));
case Instruction::URem:
- if (C2->isNullValue())
- return 0; // X / 0 -> can't fold
+ assert(!CI2->isNullValue() && "Div by zero handled above");
return ConstantInt::get(C1V.urem(C2V));
- case Instruction::SRem:
- if (CI2->isNullValue())
- return 0; // X % 0 -> can't fold
+ case Instruction::SRem:
+ assert(!CI2->isNullValue() && "Div by zero handled above");
if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
- return 0; // MIN_INT % -1 -> overflow
+ return UndefValue::get(CI1->getType()); // MIN_INT % -1 -> undef
return ConstantInt::get(C1V.srem(C2V));
case Instruction::And:
return ConstantInt::get(C1V & C2V);
switch (Opcode) {
default:
break;
- case Instruction::Add:
+ case Instruction::FAdd:
(void)C3V.add(C2V, APFloat::rmNearestTiesToEven);
return ConstantFP::get(C3V);
- case Instruction::Sub:
+ case Instruction::FSub:
(void)C3V.subtract(C2V, APFloat::rmNearestTiesToEven);
return ConstantFP::get(C3V);
- case Instruction::Mul:
+ case Instruction::FMul:
(void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven);
return ConstantFP::get(C3V);
case Instruction::FDiv:
(void)C3V.divide(C2V, APFloat::rmNearestTiesToEven);
return ConstantFP::get(C3V);
case Instruction::FRem:
- if (C2V.isZero()) {
- // IEEE 754, Section 7.1, #5
- if (CFP1->getType() == Type::DoubleTy)
- return ConstantFP::get(APFloat(std::numeric_limits<double>::
- quiet_NaN()));
- if (CFP1->getType() == Type::FloatTy)
- return ConstantFP::get(APFloat(std::numeric_limits<float>::
- quiet_NaN()));
- break;
- }
(void)C3V.mod(C2V, APFloat::rmNearestTiesToEven);
return ConstantFP::get(C3V);
}
switch (Opcode) {
default:
break;
- case Instruction::Add:
+ case Instruction::Add:
return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getAdd);
- case Instruction::Sub:
+ case Instruction::FAdd:
+ return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFAdd);
+ case Instruction::Sub:
return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getSub);
- case Instruction::Mul:
+ case Instruction::FSub:
+ return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFSub);
+ case Instruction::Mul:
return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getMul);
+ case Instruction::FMul:
+ return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFMul);
case Instruction::UDiv:
return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getUDiv);
case Instruction::SDiv:
return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getOr);
case Instruction::Xor:
return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getXor);
+ case Instruction::LShr:
+ return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getLShr);
+ case Instruction::AShr:
+ return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getAShr);
+ case Instruction::Shl:
+ return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getShl);
}
}
}
// other way if possible.
switch (Opcode) {
case Instruction::Add:
+ case Instruction::FAdd:
case Instruction::Mul:
+ case Instruction::FMul:
case Instruction::And:
case Instruction::Or:
case Instruction::Xor:
case Instruction::LShr:
case Instruction::AShr:
case Instruction::Sub:
+ case Instruction::FSub:
case Instruction::SDiv:
case Instruction::UDiv:
case Instruction::FDiv:
}
break;
- case Instruction::PtrToInt:
- case Instruction::IntToPtr:
- // inttoptr(x1) != inttoptr(x2) iff x1 != x2
- if (const ConstantExpr *CE2 = dyn_cast<ConstantExpr>(V2))
- if (CE1->getOpcode() == CE2->getOpcode()) {
- Constant *Op1 = const_cast<Constant*>(CE1Op0);
- Constant *Op2 = CE2->getOperand(0);
- if (CE1Op->getType() == CE2Op->getType()) {
- ConstantInt *R = 0;
-
- ICmpInst::Predicate pred = ICmpInst::ICMP_EQ;
- R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, Op1, Op2));
- if (R && !R->isZero())
- return pred;
-
- pred = ICmpInst::ICMP_NE;
- R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, Op1, Op2));
- if (R && !R->isZero())
- return pred;
- }
- }
- break;
-
case Instruction::GetElementPtr:
// Ok, since this is a getelementptr, we know that the constant has a
// pointer type. Check the various cases.
Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred,
const Constant *C1,
const Constant *C2) {
-
+ // Fold FCMP_FALSE/FCMP_TRUE unconditionally.
+ if (pred == FCmpInst::FCMP_FALSE) {
+ if (const VectorType *VT = dyn_cast<VectorType>(C1->getType()))
+ return Constant::getNullValue(VectorType::getInteger(VT));
+ else
+ return ConstantInt::getFalse();
+ }
+
+ if (pred == FCmpInst::FCMP_TRUE) {
+ if (const VectorType *VT = dyn_cast<VectorType>(C1->getType()))
+ return Constant::getAllOnesValue(VectorType::getInteger(VT));
+ else
+ return ConstantInt::getTrue();
+ }
+
// Handle some degenerate cases first
- if (isa<UndefValue>(C1) || isa<UndefValue>(C2))
+ if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) {
+ // vicmp/vfcmp -> [vector] undef
+ if (const VectorType *VTy = dyn_cast<VectorType>(C1->getType()))
+ return UndefValue::get(VectorType::getInteger(VTy));
+
+ // icmp/fcmp -> i1 undef
return UndefValue::get(Type::Int1Ty);
+ }
// No compile-time operations on this type yet.
if (C1->getType() == Type::PPC_FP128Ty)
return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan ||
R==APFloat::cmpEqual);
}
- } 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,
- CP1->getOperand(i),
- CP2->getOperand(i));
- if (ConstantInt *CB = dyn_cast<ConstantInt>(C))
- return CB;
- }
- // Otherwise, could not decide from any element pairs.
- return 0;
- } else if (pred == ICmpInst::ICMP_EQ) {
- for (unsigned i = 0, e = CP1->getNumOperands(); i != e; ++i) {
- Constant *C = ConstantExpr::getICmp(ICmpInst::ICMP_EQ,
- CP1->getOperand(i),
- CP2->getOperand(i));
- if (ConstantInt *CB = dyn_cast<ConstantInt>(C))
- return CB;
- }
- // Otherwise, could not decide from any element pairs.
- return 0;
+ } else if (isa<VectorType>(C1->getType())) {
+ SmallVector<Constant*, 16> C1Elts, C2Elts;
+ C1->getVectorElements(C1Elts);
+ C2->getVectorElements(C2Elts);
+
+ // If we can constant fold the comparison of each element, constant fold
+ // the whole vector comparison.
+ SmallVector<Constant*, 4> ResElts;
+ const Type *InEltTy = C1Elts[0]->getType();
+ bool isFP = InEltTy->isFloatingPoint();
+ const Type *ResEltTy = InEltTy;
+ if (isFP)
+ ResEltTy = IntegerType::get(InEltTy->getPrimitiveSizeInBits());
+
+ for (unsigned i = 0, e = C1Elts.size(); i != e; ++i) {
+ // Compare the elements, producing an i1 result or constant expr.
+ Constant *C;
+ if (isFP)
+ C = ConstantExpr::getFCmp(pred, C1Elts[i], C2Elts[i]);
+ else
+ C = ConstantExpr::getICmp(pred, C1Elts[i], C2Elts[i]);
+
+ // If it is a bool or undef result, convert to the dest type.
+ if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
+ if (CI->isZero())
+ ResElts.push_back(Constant::getNullValue(ResEltTy));
+ else
+ ResElts.push_back(Constant::getAllOnesValue(ResEltTy));
+ } else if (isa<UndefValue>(C)) {
+ ResElts.push_back(UndefValue::get(ResEltTy));
+ } else {
+ break;
}
}
+
+ if (ResElts.size() == C1Elts.size())
+ return ConstantVector::get(&ResElts[0], ResElts.size());
}
if (C1->getType()->isFloatingPoint()) {
+ int Result = -1; // -1 = unknown, 0 = known false, 1 = known true.
switch (evaluateFCmpRelation(C1, C2)) {
default: assert(0 && "Unknown relation!");
case FCmpInst::FCMP_UNO:
case FCmpInst::BAD_FCMP_PREDICATE:
break; // Couldn't determine anything about these constants.
case FCmpInst::FCMP_OEQ: // We know that C1 == C2
- return ConstantInt::get(Type::Int1Ty,
- pred == FCmpInst::FCMP_UEQ || pred == FCmpInst::FCMP_OEQ ||
- pred == FCmpInst::FCMP_ULE || pred == FCmpInst::FCMP_OLE ||
- pred == FCmpInst::FCMP_UGE || pred == FCmpInst::FCMP_OGE);
+ Result = (pred == FCmpInst::FCMP_UEQ || pred == FCmpInst::FCMP_OEQ ||
+ pred == FCmpInst::FCMP_ULE || pred == FCmpInst::FCMP_OLE ||
+ pred == FCmpInst::FCMP_UGE || pred == FCmpInst::FCMP_OGE);
+ break;
case FCmpInst::FCMP_OLT: // We know that C1 < C2
- return ConstantInt::get(Type::Int1Ty,
- pred == FCmpInst::FCMP_UNE || pred == FCmpInst::FCMP_ONE ||
- pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT ||
- pred == FCmpInst::FCMP_ULE || pred == FCmpInst::FCMP_OLE);
+ Result = (pred == FCmpInst::FCMP_UNE || pred == FCmpInst::FCMP_ONE ||
+ pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT ||
+ pred == FCmpInst::FCMP_ULE || pred == FCmpInst::FCMP_OLE);
+ break;
case FCmpInst::FCMP_OGT: // We know that C1 > C2
- return ConstantInt::get(Type::Int1Ty,
- pred == FCmpInst::FCMP_UNE || pred == FCmpInst::FCMP_ONE ||
- pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT ||
- pred == FCmpInst::FCMP_UGE || pred == FCmpInst::FCMP_OGE);
+ Result = (pred == FCmpInst::FCMP_UNE || pred == FCmpInst::FCMP_ONE ||
+ pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT ||
+ pred == FCmpInst::FCMP_UGE || pred == FCmpInst::FCMP_OGE);
+ break;
case FCmpInst::FCMP_OLE: // We know that C1 <= C2
// We can only partially decide this relation.
if (pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT)
- return ConstantInt::getFalse();
- if (pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT)
- return ConstantInt::getTrue();
+ Result = 0;
+ else if (pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT)
+ Result = 1;
break;
case FCmpInst::FCMP_OGE: // We known that C1 >= C2
// We can only partially decide this relation.
if (pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT)
- return ConstantInt::getFalse();
- if (pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT)
- return ConstantInt::getTrue();
+ Result = 0;
+ else if (pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT)
+ Result = 1;
break;
case ICmpInst::ICMP_NE: // We know that C1 != C2
// We can only partially decide this relation.
if (pred == FCmpInst::FCMP_OEQ || pred == FCmpInst::FCMP_UEQ)
- return ConstantInt::getFalse();
- if (pred == FCmpInst::FCMP_ONE || pred == FCmpInst::FCMP_UNE)
- return ConstantInt::getTrue();
+ Result = 0;
+ else if (pred == FCmpInst::FCMP_ONE || pred == FCmpInst::FCMP_UNE)
+ Result = 1;
break;
}
+
+ // If we evaluated the result, return it now.
+ if (Result != -1) {
+ if (const VectorType *VT = dyn_cast<VectorType>(C1->getType())) {
+ if (Result == 0)
+ return Constant::getNullValue(VectorType::getInteger(VT));
+ else
+ return Constant::getAllOnesValue(VectorType::getInteger(VT));
+ }
+ return ConstantInt::get(Type::Int1Ty, Result);
+ }
+
} else {
// Evaluate the relation between the two constants, per the predicate.
+ int Result = -1; // -1 = unknown, 0 = known false, 1 = known true.
switch (evaluateICmpRelation(C1, C2, CmpInst::isSigned(pred))) {
default: assert(0 && "Unknown relational!");
case ICmpInst::BAD_ICMP_PREDICATE:
case ICmpInst::ICMP_EQ: // We know the constants are equal!
// If we know the constants are equal, we can decide the result of this
// computation precisely.
- return ConstantInt::get(Type::Int1Ty,
- pred == ICmpInst::ICMP_EQ ||
- pred == ICmpInst::ICMP_ULE ||
- pred == ICmpInst::ICMP_SLE ||
- pred == ICmpInst::ICMP_UGE ||
- pred == ICmpInst::ICMP_SGE);
+ Result = (pred == ICmpInst::ICMP_EQ ||
+ pred == ICmpInst::ICMP_ULE ||
+ pred == ICmpInst::ICMP_SLE ||
+ pred == ICmpInst::ICMP_UGE ||
+ pred == ICmpInst::ICMP_SGE);
+ break;
case ICmpInst::ICMP_ULT:
// If we know that C1 < C2, we can decide the result of this computation
// precisely.
- return ConstantInt::get(Type::Int1Ty,
- pred == ICmpInst::ICMP_ULT ||
- pred == ICmpInst::ICMP_NE ||
- pred == ICmpInst::ICMP_ULE);
+ Result = (pred == ICmpInst::ICMP_ULT ||
+ pred == ICmpInst::ICMP_NE ||
+ pred == ICmpInst::ICMP_ULE);
+ break;
case ICmpInst::ICMP_SLT:
// If we know that C1 < C2, we can decide the result of this computation
// precisely.
- return ConstantInt::get(Type::Int1Ty,
- pred == ICmpInst::ICMP_SLT ||
- pred == ICmpInst::ICMP_NE ||
- pred == ICmpInst::ICMP_SLE);
+ Result = (pred == ICmpInst::ICMP_SLT ||
+ pred == ICmpInst::ICMP_NE ||
+ pred == ICmpInst::ICMP_SLE);
+ break;
case ICmpInst::ICMP_UGT:
// If we know that C1 > C2, we can decide the result of this computation
// precisely.
- return ConstantInt::get(Type::Int1Ty,
- pred == ICmpInst::ICMP_UGT ||
- pred == ICmpInst::ICMP_NE ||
- pred == ICmpInst::ICMP_UGE);
+ Result = (pred == ICmpInst::ICMP_UGT ||
+ pred == ICmpInst::ICMP_NE ||
+ pred == ICmpInst::ICMP_UGE);
+ break;
case ICmpInst::ICMP_SGT:
// If we know that C1 > C2, we can decide the result of this computation
// precisely.
- return ConstantInt::get(Type::Int1Ty,
- pred == ICmpInst::ICMP_SGT ||
- pred == ICmpInst::ICMP_NE ||
- pred == ICmpInst::ICMP_SGE);
+ Result = (pred == ICmpInst::ICMP_SGT ||
+ pred == ICmpInst::ICMP_NE ||
+ pred == ICmpInst::ICMP_SGE);
+ break;
case ICmpInst::ICMP_ULE:
// If we know that C1 <= C2, we can only partially decide this relation.
- if (pred == ICmpInst::ICMP_UGT) return ConstantInt::getFalse();
- if (pred == ICmpInst::ICMP_ULT) return ConstantInt::getTrue();
+ if (pred == ICmpInst::ICMP_UGT) Result = 0;
+ if (pred == ICmpInst::ICMP_ULT) Result = 1;
break;
case ICmpInst::ICMP_SLE:
// If we know that C1 <= C2, we can only partially decide this relation.
- if (pred == ICmpInst::ICMP_SGT) return ConstantInt::getFalse();
- if (pred == ICmpInst::ICMP_SLT) return ConstantInt::getTrue();
+ if (pred == ICmpInst::ICMP_SGT) Result = 0;
+ if (pred == ICmpInst::ICMP_SLT) Result = 1;
break;
case ICmpInst::ICMP_UGE:
// If we know that C1 >= C2, we can only partially decide this relation.
- if (pred == ICmpInst::ICMP_ULT) return ConstantInt::getFalse();
- if (pred == ICmpInst::ICMP_UGT) return ConstantInt::getTrue();
+ if (pred == ICmpInst::ICMP_ULT) Result = 0;
+ if (pred == ICmpInst::ICMP_UGT) Result = 1;
break;
case ICmpInst::ICMP_SGE:
// If we know that C1 >= C2, we can only partially decide this relation.
- if (pred == ICmpInst::ICMP_SLT) return ConstantInt::getFalse();
- if (pred == ICmpInst::ICMP_SGT) return ConstantInt::getTrue();
+ if (pred == ICmpInst::ICMP_SLT) Result = 0;
+ if (pred == ICmpInst::ICMP_SGT) Result = 1;
break;
case ICmpInst::ICMP_NE:
// If we know that C1 != C2, we can only partially decide this relation.
- if (pred == ICmpInst::ICMP_EQ) return ConstantInt::getFalse();
- if (pred == ICmpInst::ICMP_NE) return ConstantInt::getTrue();
+ if (pred == ICmpInst::ICMP_EQ) Result = 0;
+ if (pred == ICmpInst::ICMP_NE) Result = 1;
break;
}
-
+
+ // If we evaluated the result, return it now.
+ if (Result != -1) {
+ if (const VectorType *VT = dyn_cast<VectorType>(C1->getType())) {
+ if (Result == 0)
+ return Constant::getNullValue(VT);
+ else
+ return Constant::getAllOnesValue(VT);
+ }
+ return ConstantInt::get(Type::Int1Ty, Result);
+ }
+
if (!isa<ConstantExpr>(C1) && isa<ConstantExpr>(C2)) {
// If C2 is a constant expr and C1 isn't, flop them around and fold the
// other way if possible.
Offset = ConstantExpr::getSExt(Offset, Base->getType());
else if (Base->getType()->getPrimitiveSizeInBits() <
Offset->getType()->getPrimitiveSizeInBits())
- Base = ConstantExpr::getZExt(Base, Base->getType());
+ Base = ConstantExpr::getZExt(Base, Offset->getType());
Base = ConstantExpr::getAdd(Base, Offset);
return ConstantExpr::getIntToPtr(Base, CE->getType());