for (unsigned i = 0; i != NumElts; ++i)
Result.push_back(Context.getConstantExprBitCast(CV->getOperand(i),
DstEltTy));
- return Context.getConstantVector(Result);
+ return ConstantVector::get(Result);
}
/// This function determines which opcode to use to fold two constant cast
// can only be handled by Analysis/ConstantFolding.cpp).
if (isa<ConstantInt>(V) || isa<ConstantFP>(V))
return Context.getConstantExprBitCast(
- Context.getConstantVector(&V, 1), DestPTy);
+ ConstantVector::get(&V, 1), DestPTy);
}
// Finally, implement bitcast folding now. The code below doesn't handle
return V;
if (DestTy->isFloatingPoint())
- return Context.getConstantFP(APFloat(CI->getValue(),
+ return ConstantFP::get(Context, APFloat(CI->getValue(),
DestTy != Type::PPC_FP128Ty));
// Otherwise, can't fold this (vector?)
// Handle ConstantFP input.
if (const ConstantFP *FP = dyn_cast<ConstantFP>(V))
// FP -> Integral.
- return Context.getConstantInt(FP->getValueAPF().bitcastToAPInt());
+ return ConstantInt::get(Context, FP->getValueAPF().bitcastToAPInt());
return 0;
}
for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i)
res.push_back(Context.getConstantExprCast(opc,
CV->getOperand(i), DstEltTy));
- return Context.getConstantVector(DestVecTy, res);
+ return ConstantVector::get(DestVecTy, res);
}
// We actually have to do a cast now. Perform the cast according to the
DestTy == Type::FP128Ty ? APFloat::IEEEquad :
APFloat::Bogus,
APFloat::rmNearestTiesToEven, &ignored);
- return Context.getConstantFP(Val);
+ return ConstantFP::get(Context, Val);
}
return 0; // Can't fold.
case Instruction::FPToUI:
(void) V.convertToInteger(x, DestBitWidth, opc==Instruction::FPToSI,
APFloat::rmTowardZero, &ignored);
APInt Val(DestBitWidth, 2, x);
- return Context.getConstantInt(Val);
+ return ConstantInt::get(Context, Val);
}
return 0; // Can't fold.
case Instruction::IntToPtr: //always treated as unsigned
return 0; // Other pointer types cannot be casted
case Instruction::PtrToInt: // always treated as unsigned
if (V->isNullValue()) // is it a null pointer value?
- return Context.getConstantInt(DestTy, 0);
+ return ConstantInt::get(DestTy, 0);
return 0; // Other pointer types cannot be casted
case Instruction::UIToFP:
case Instruction::SIToFP:
(void)apf.convertFromAPInt(api,
opc==Instruction::SIToFP,
APFloat::rmNearestTiesToEven);
- return Context.getConstantFP(apf);
+ return ConstantFP::get(Context, apf);
}
return 0;
case Instruction::ZExt:
uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
APInt Result(CI->getValue());
Result.zext(BitWidth);
- return Context.getConstantInt(Result);
+ return ConstantInt::get(Context, Result);
}
return 0;
case Instruction::SExt:
uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
APInt Result(CI->getValue());
Result.sext(BitWidth);
- return Context.getConstantInt(Result);
+ return ConstantInt::get(Context, Result);
}
return 0;
case Instruction::Trunc:
uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
APInt Result(CI->getValue());
Result.trunc(BitWidth);
- return Context.getConstantInt(Result);
+ return ConstantInt::get(Context, Result);
}
return 0;
case Instruction::BitCast:
break;
}
- LLVM_UNREACHABLE("Failed to cast constant expression");
+ llvm_unreachable("Failed to cast constant expression");
return 0;
}
(idxVal == i) ? Elt : Context.getUndef(Elt->getType());
Ops.push_back(const_cast<Constant*>(Op));
}
- return Context.getConstantVector(Ops);
+ return ConstantVector::get(Ops);
}
if (isa<ConstantAggregateZero>(Val)) {
// Insertion of scalar constant into vector aggregate zero
(idxVal == i) ? Elt : Context.getNullValue(Elt->getType());
Ops.push_back(const_cast<Constant*>(Op));
}
- return Context.getConstantVector(Ops);
+ return ConstantVector::get(Ops);
}
if (const ConstantVector *CVal = dyn_cast<ConstantVector>(Val)) {
// Insertion of scalar constant into vector constant
(idxVal == i) ? Elt : cast<Constant>(CVal->getOperand(i));
Ops.push_back(const_cast<Constant*>(Op));
}
- return Context.getConstantVector(Ops);
+ return ConstantVector::get(Ops);
}
return 0;
Result.push_back(InElt);
}
- return Context.getConstantVector(&Result[0], Result.size());
+ return ConstantVector::get(&Result[0], Result.size());
}
Constant *llvm::ConstantFoldExtractValueInstruction(LLVMContext &Context,
Ops[i] = const_cast<Constant*>(Op);
}
if (isa<StructType>(AggTy))
- return Context.getConstantStruct(Ops);
+ return ConstantStruct::get(Ops);
else
- return Con
text.getConstantArray(cast<ArrayType>(AggTy), Ops);
+ return Con
stantArray::get(cast<ArrayType>(AggTy), Ops);
}
if (isa<ConstantAggregateZero>(Agg)) {
// Insertion of constant into aggregate zero
Ops[i] = const_cast<Constant*>(Op);
}
if (isa<StructType>(AggTy))
- return Context.getConstantStruct(Ops);
+ return ConstantStruct::get(Ops);
else
- return Con
text.getConstantArray(cast<ArrayType>(AggTy), Ops);
+ return Con
stantArray::get(cast<ArrayType>(AggTy), Ops);
}
if (isa<ConstantStruct>(Agg) || isa<ConstantArray>(Agg)) {
// Insertion of constant into aggregate constant
}
Constant *C;
if (isa<StructType>(Agg->getType()))
- C = Context.getConstantStruct(Ops);
+ C = ConstantStruct::get(Ops);
else
- C = Con
text.getConstantArray(cast<ArrayType>(Agg->getType()), Ops);
+ C = Con
stantArray::get(cast<ArrayType>(Agg->getType()), Ops);
return C;
}
return 0;
}
-/// EvalVectorOp - Given two vector constants and a function pointer, apply the
-/// function pointer to each element pair, producing a new ConstantVector
-/// constant. Either or both of V1 and V2 may be NULL, meaning a
-/// ConstantAggregateZero operand.
-static Constant *EvalVectorOp(LLVMContext &Context, const ConstantVector *V1,
- const ConstantVector *V2,
- const VectorType *VTy,
- Constant *(*FP)(Constant*, Constant*)) {
- std::vector<Constant*> Res;
- const Type *EltTy = VTy->getElementType();
- for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
- const Constant *C1 = V1 ? V1->getOperand(i) : Context.getNullValue(EltTy);
- const Constant *C2 = V2 ? V2->getOperand(i) : Context.getNullValue(EltTy);
- Res.push_back(FP(const_cast<Constant*>(C1),
- const_cast<Constant*>(C2)));
- }
- return Context.getConstantVector(Res);
-}
Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
unsigned Opcode,
default:
break;
case Instruction::Add:
- return Context.getConstantInt(C1V + C2V);
+ return ConstantInt::get(Context, C1V + C2V);
case Instruction::Sub:
- return Context.getConstantInt(C1V - C2V);
+ return ConstantInt::get(Context, C1V - C2V);
case Instruction::Mul:
- return Context.getConstantInt(C1V * C2V);
+ return ConstantInt::get(Context, C1V * C2V);
case Instruction::UDiv:
assert(!CI2->isNullValue() && "Div by zero handled above");
- return Context.getConstantInt(C1V.udiv(C2V));
+ return ConstantInt::get(Context, C1V.udiv(C2V));
case Instruction::SDiv:
assert(!CI2->isNullValue() && "Div by zero handled above");
if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
return Context.getUndef(CI1->getType()); // MIN_INT / -1 -> undef
- return Context.getConstantInt(C1V.sdiv(C2V));
+ return ConstantInt::get(Context, C1V.sdiv(C2V));
case Instruction::URem:
assert(!CI2->isNullValue() && "Div by zero handled above");
- return Context.getConstantInt(C1V.urem(C2V));
+ return ConstantInt::get(Context, C1V.urem(C2V));
case Instruction::SRem:
assert(!CI2->isNullValue() && "Div by zero handled above");
if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
return Context.getUndef(CI1->getType()); // MIN_INT % -1 -> undef
- return Context.getConstantInt(C1V.srem(C2V));
+ return ConstantInt::get(Context, C1V.srem(C2V));
case Instruction::And:
- return Context.getConstantInt(C1V & C2V);
+ return ConstantInt::get(Context, C1V & C2V);
case Instruction::Or:
- return Context.getConstantInt(C1V | C2V);
+ return ConstantInt::get(Context, C1V | C2V);
case Instruction::Xor:
- return Context.getConstantInt(C1V ^ C2V);
+ return ConstantInt::get(Context, C1V ^ C2V);
case Instruction::Shl: {
uint32_t shiftAmt = C2V.getZExtValue();
if (shiftAmt < C1V.getBitWidth())
- return Context.getConstantInt(C1V.shl(shiftAmt));
+ return ConstantInt::get(Context, C1V.shl(shiftAmt));
else
return Context.getUndef(C1->getType()); // too big shift is undef
}
case Instruction::LShr: {
uint32_t shiftAmt = C2V.getZExtValue();
if (shiftAmt < C1V.getBitWidth())
- return Context.getConstantInt(C1V.lshr(shiftAmt));
+ return ConstantInt::get(Context, C1V.lshr(shiftAmt));
else
return Context.getUndef(C1->getType()); // too big shift is undef
}
case Instruction::AShr: {
uint32_t shiftAmt = C2V.getZExtValue();
if (shiftAmt < C1V.getBitWidth())
- return Context.getConstantInt(C1V.ashr(shiftAmt));
+ return ConstantInt::get(Context, C1V.ashr(shiftAmt));
else
return Context.getUndef(C1->getType()); // too big shift is undef
}
break;
case Instruction::FAdd:
(void)C3V.add(C2V, APFloat::rmNearestTiesToEven);
- return Context.getConstantFP(C3V);
+ return ConstantFP::get(Context, C3V);
case Instruction::FSub:
(void)C3V.subtract(C2V, APFloat::rmNearestTiesToEven);
- return Context.getConstantFP(C3V);
+ return ConstantFP::get(Context, C3V);
case Instruction::FMul:
(void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven);
- return Context.getConstantFP(C3V);
+ return ConstantFP::get(Context, C3V);
case Instruction::FDiv:
(void)C3V.divide(C2V, APFloat::rmNearestTiesToEven);
- return Context.getConstantFP(C3V);
+ return ConstantFP::get(Context, C3V);
case Instruction::FRem:
(void)C3V.mod(C2V, APFloat::rmNearestTiesToEven);
- return Context.getConstantFP(C3V);
+ return ConstantFP::get(Context, C3V);
}
}
} else if (const VectorType *VTy = dyn_cast<VectorType>(C1->getType())) {
const ConstantVector *CP2 = dyn_cast<ConstantVector>(C2);
if ((CP1 != NULL || isa<ConstantAggregateZero>(C1)) &&
(CP2 != NULL || isa<ConstantAggregateZero>(C2))) {
+ std::vector<Constant*> Res;
+ const Type* EltTy = VTy->getElementType();
+ const Constant *C1 = 0;
+ const Constant *C2 = 0;
switch (Opcode) {
default:
break;
case Instruction::Add:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getAdd);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprAdd(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::FAdd:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFAdd);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprFAdd(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::Sub:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getSub);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprSub(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::FSub:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFSub);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprFSub(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::Mul:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getMul);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprMul(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::FMul:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFMul);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprFMul(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::UDiv:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getUDiv);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprUDiv(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::SDiv:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getSDiv);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprSDiv(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::FDiv:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFDiv);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprFDiv(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::URem:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getURem);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprURem(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::SRem:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getSRem);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprSRem(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::FRem:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFRem);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprFRem(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::And:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getAnd);
- case Instruction::Or:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getOr);
- case Instruction::Xor:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getXor);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprAnd(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
+ case Instruction::Or:
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprOr(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
+ case Instruction::Xor:
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprXor(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::LShr:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getLShr);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprLShr(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::AShr:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getAShr);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprAShr(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
case Instruction::Shl:
- return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getShl);
+ for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+ C1 = CP1 ? CP1->getOperand(i) : Context.getNullValue(EltTy);
+ C2 = CP2 ? CP2->getOperand(i) : Context.getNullValue(EltTy);
+ Res.push_back(Context.getConstantExprShl(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2)));
+ }
+ return ConstantVector::get(Res);
}
}
}
// Don't try to evaluate aliases. External weak GV can be null.
if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) {
if (pred == ICmpInst::ICMP_EQ)
- return Context.getConstantIntFalse();
+ return Context.getFalse();
else if (pred == ICmpInst::ICMP_NE)
- return Context.getConstantIntTrue();
+ return Context.getTrue();
}
// icmp eq/ne(GV,null) -> false/true
} else if (C2->isNullValue()) {
// Don't try to evaluate aliases. External weak GV can be null.
if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) {
if (pred == ICmpInst::ICMP_EQ)
- return Context.getConstantIntFalse();
+ return Context.getFalse();
else if (pred == ICmpInst::ICMP_NE)
- return Context.getConstantIntTrue();
+ return Context.getTrue();
}
}
APInt V1 = cast<ConstantInt>(C1)->getValue();
APInt V2 = cast<ConstantInt>(C2)->getValue();
switch (pred) {
- default: LLVM_UNREACHABLE("Invalid ICmp Predicate"); return 0;
+ default: llvm_unreachable("Invalid ICmp Predicate"); return 0;
case ICmpInst::ICMP_EQ:
- return Context.getConstantInt(Type::Int1Ty, V1 == V2);
+ return ConstantInt::get(Type::Int1Ty, V1 == V2);
case ICmpInst::ICMP_NE:
- return Context.getConstantInt(Type::Int1Ty, V1 != V2);
+ return ConstantInt::get(Type::Int1Ty, V1 != V2);
case ICmpInst::ICMP_SLT:
- return Context.getConstantInt(Type::Int1Ty, V1.slt(V2));
+ return ConstantInt::get(Type::Int1Ty, V1.slt(V2));
case ICmpInst::ICMP_SGT:
- return Context.getConstantInt(Type::Int1Ty, V1.sgt(V2));
+ return ConstantInt::get(Type::Int1Ty, V1.sgt(V2));
case ICmpInst::ICMP_SLE:
- return Context.getConstantInt(Type::Int1Ty, V1.sle(V2));
+ return ConstantInt::get(Type::Int1Ty, V1.sle(V2));
case ICmpInst::ICMP_SGE:
- return Context.getConstantInt(Type::Int1Ty, V1.sge(V2));
+ return ConstantInt::get(Type::Int1Ty, V1.sge(V2));
case ICmpInst::ICMP_ULT:
- return Context.getConstantInt(Type::Int1Ty, V1.ult(V2));
+ return ConstantInt::get(Type::Int1Ty, V1.ult(V2));
case ICmpInst::ICMP_UGT:
- return Context.getConstantInt(Type::Int1Ty, V1.ugt(V2));
+ return ConstantInt::get(Type::Int1Ty, V1.ugt(V2));
case ICmpInst::ICMP_ULE:
- return Context.getConstantInt(Type::Int1Ty, V1.ule(V2));
+ return ConstantInt::get(Type::Int1Ty, V1.ule(V2));
case ICmpInst::ICMP_UGE:
- return Context.getConstantInt(Type::Int1Ty, V1.uge(V2));
+ return ConstantInt::get(Type::Int1Ty, V1.uge(V2));
}
} else if (isa<ConstantFP>(C1) && isa<ConstantFP>(C2)) {
APFloat C1V = cast<ConstantFP>(C1)->getValueAPF();
APFloat C2V = cast<ConstantFP>(C2)->getValueAPF();
APFloat::cmpResult R = C1V.compare(C2V);
switch (pred) {
- default: LLVM_UNREACHABLE("Invalid FCmp Predicate"); return 0;
- case FCmpInst::FCMP_FALSE: return Context.getConstantIntFalse();
- case FCmpInst::FCMP_TRUE: return Context.getConstantIntTrue();
+ default: llvm_unreachable("Invalid FCmp Predicate"); return 0;
+ case FCmpInst::FCMP_FALSE: return Context.getFalse();
+ case FCmpInst::FCMP_TRUE: return Context.getTrue();
case FCmpInst::FCMP_UNO:
- return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered);
+ return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered);
case FCmpInst::FCMP_ORD:
- return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpUnordered);
+ return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpUnordered);
case FCmpInst::FCMP_UEQ:
- return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered ||
+ return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered ||
R==APFloat::cmpEqual);
case FCmpInst::FCMP_OEQ:
- return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpEqual);
+ return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpEqual);
case FCmpInst::FCMP_UNE:
- return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpEqual);
+ return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpEqual);
case FCmpInst::FCMP_ONE:
- return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpLessThan ||
+ return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan ||
R==APFloat::cmpGreaterThan);
case FCmpInst::FCMP_ULT:
- return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered ||
+ return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered ||
R==APFloat::cmpLessThan);
case FCmpInst::FCMP_OLT:
- return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpLessThan);
+ return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan);
case FCmpInst::FCMP_UGT:
- return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered ||
+ return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered ||
R==APFloat::cmpGreaterThan);
case FCmpInst::FCMP_OGT:
- return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpGreaterThan);
+ return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan);
case FCmpInst::FCMP_ULE:
- return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpGreaterThan);
+ return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpGreaterThan);
case FCmpInst::FCMP_OLE:
- return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpLessThan ||
+ return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan ||
R==APFloat::cmpEqual);
case FCmpInst::FCMP_UGE:
- return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpLessThan);
+ return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpLessThan);
case FCmpInst::FCMP_OGE:
- return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpGreaterThan ||
+ return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan ||
R==APFloat::cmpEqual);
}
} else if (isa<VectorType>(C1->getType())) {
ResElts.push_back(
Context.getConstantExprCompare(pred, C1Elts[i], C2Elts[i]));
}
- return Context.getConstantVector(&ResElts[0], ResElts.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(Context, C1, C2)) {
- default: LLVM_UNREACHABLE("Unknown relation!");
+ default: llvm_unreachable("Unknown relation!");
case FCmpInst::FCMP_UNO:
case FCmpInst::FCMP_ORD:
case FCmpInst::FCMP_UEQ:
// If we evaluated the result, return it now.
if (Result != -1)
- return Context.getConstantInt(Type::Int1Ty, Result);
+ 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(Context, C1, C2, CmpInst::isSigned(pred))) {
- default: LLVM_UNREACHABLE("Unknown relational!");
+ default: llvm_unreachable("Unknown relational!");
case ICmpInst::BAD_ICMP_PREDICATE:
break; // Couldn't determine anything about these constants.
case ICmpInst::ICMP_EQ: // We know the constants are equal!
// If we evaluated the result, return it now.
if (Result != -1)
- return Context.getConstantInt(Type::Int1Ty, Result);
+ return ConstantInt::get(Type::Int1Ty, Result);
if (!isa<ConstantExpr>(C1) && isa<ConstantExpr>(C2)) {
// If C2 is a constant expr and C1 isn't, flip them around and fold the
projects / oota-llvm.git / blobdiff