[llvm-commits] CVS: llvm/lib/Transforms/Scalar/InstructionCombining.cpp
Reid Spencer
reid at x10sys.com
Tue Dec 12 01:19:06 PST 2006
Changes in directory llvm/lib/Transforms/Scalar:
InstructionCombining.cpp updated: 1.562 -> 1.563
---
Log message:
Fix numerous inferred casts.
---
Diffs of the changes: (+121 -77)
InstructionCombining.cpp | 198 ++++++++++++++++++++++++++++-------------------
1 files changed, 121 insertions(+), 77 deletions(-)
Index: llvm/lib/Transforms/Scalar/InstructionCombining.cpp
diff -u llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.562 llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.563
--- llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.562 Wed Dec 6 19:30:31 2006
+++ llvm/lib/Transforms/Scalar/InstructionCombining.cpp Tue Dec 12 03:18:51 2006
@@ -205,13 +205,14 @@
/// InsertCastBefore - Insert a cast of V to TY before the instruction POS.
/// This also adds the cast to the worklist. Finally, this returns the
/// cast.
- Value *InsertCastBefore(Value *V, const Type *Ty, Instruction &Pos) {
+ Value *InsertCastBefore(Instruction::CastOps opc, Value *V, const Type *Ty,
+ Instruction &Pos) {
if (V->getType() == Ty) return V;
if (Constant *CV = dyn_cast<Constant>(V))
- return ConstantExpr::getCast(CV, Ty);
+ return ConstantExpr::getCast(opc, CV, Ty);
- Instruction *C = CastInst::createInferredCast(V, Ty, V->getName(), &Pos);
+ Instruction *C = CastInst::create(opc, V, Ty, V->getName(), &Pos);
WorkList.push_back(C);
return C;
}
@@ -269,7 +270,8 @@
/// InsertBefore instruction. This is specialized a bit to avoid inserting
/// casts that are known to not do anything...
///
- Value *InsertOperandCastBefore(Value *V, const Type *DestTy,
+ Value *InsertOperandCastBefore(Instruction::CastOps opcode,
+ Value *V, const Type *DestTy,
Instruction *InsertBefore);
// SimplifyCommutative - This performs a few simplifications for commutative
@@ -398,13 +400,14 @@
/// InsertBefore instruction. This is specialized a bit to avoid inserting
/// casts that are known to not do anything...
///
-Value *InstCombiner::InsertOperandCastBefore(Value *V, const Type *DestTy,
+Value *InstCombiner::InsertOperandCastBefore(Instruction::CastOps opcode,
+ Value *V, const Type *DestTy,
Instruction *InsertBefore) {
if (V->getType() == DestTy) return V;
if (Constant *C = dyn_cast<Constant>(V))
- return ConstantExpr::getCast(C, DestTy);
+ return ConstantExpr::getCast(opcode, C, DestTy);
- return InsertCastBefore(V, DestTy, *InsertBefore);
+ return InsertCastBefore(opcode, V, DestTy, *InsertBefore);
}
// SimplifyCommutative - This performs a few simplifications for commutative
@@ -1894,7 +1897,7 @@
(CI->getType()->getPrimitiveSize() ==
TD->getIntPtrType()->getPrimitiveSize())
&& isa<PointerType>(CI->getOperand(0)->getType())) {
- Value *I2 = InsertCastBefore(CI->getOperand(0),
+ Value *I2 = InsertCastBefore(Instruction::BitCast, CI->getOperand(0),
PointerType::get(Type::SByteTy), I);
I2 = InsertNewInstBefore(new GetElementPtrInst(I2, Other, "ctg2"), I);
return new PtrToIntInst(I2, CI->getType());
@@ -2190,7 +2193,7 @@
SCOpTy->getPrimitiveSizeInBits()-1);
if (SCIOp0->getType()->isUnsigned()) {
const Type *NewTy = SCIOp0->getType()->getSignedVersion();
- SCIOp0 = InsertCastBefore(SCIOp0, NewTy, I);
+ SCIOp0 = InsertCastBefore(Instruction::BitCast, SCIOp0, NewTy, I);
}
Value *V =
@@ -2200,8 +2203,14 @@
// If the multiply type is not the same as the source type, sign extend
// or truncate to the multiply type.
- if (I.getType() != V->getType())
- V = InsertCastBefore(V, I.getType(), I);
+ if (I.getType() != V->getType()) {
+ unsigned SrcBits = V->getType()->getPrimitiveSizeInBits();
+ unsigned DstBits = I.getType()->getPrimitiveSizeInBits();
+ Instruction::CastOps opcode =
+ (SrcBits == DstBits ? Instruction::BitCast :
+ (SrcBits < DstBits ? Instruction::SExt : Instruction::Trunc));
+ V = InsertCastBefore(opcode, V, I.getType(), I);
+ }
Value *OtherOp = Op0 == BoolCast ? I.getOperand(1) : Op0;
return BinaryOperator::createAnd(V, OtherOp);
@@ -2863,12 +2872,14 @@
Constant *ShrMask = ConstantExpr::getLShr(AllOne, OpRHS);
Constant *CI = ConstantExpr::getAnd(AndRHS, ShrMask);
if (CI == AndRHS) { // Masking out bits shifted in.
+ // (Val ashr C1) & C2 -> (Val lshr C1) & C2
// Make the argument unsigned.
Value *ShVal = Op->getOperand(0);
ShVal = InsertNewInstBefore(new ShiftInst(Instruction::LShr, ShVal,
OpRHS, Op->getName()),
TheAnd);
- Value *AndRHS2 = ConstantExpr::getCast(AndRHS, ShVal->getType());
+ Value *AndRHS2 = ConstantExpr::getBitCast(AndRHS, ShVal->getType());
+
return BinaryOperator::createAnd(ShVal, AndRHS2, TheAnd.getName());
}
}
@@ -2897,9 +2908,9 @@
InsertNewInstBefore(Add, IB);
// Convert to unsigned for the comparison.
const Type *UnsType = Add->getType()->getUnsignedVersion();
- Value *OffsetVal = InsertCastBefore(Add, UnsType, IB);
+ Value *OffsetVal = InsertCastBefore(Instruction::BitCast, Add, UnsType, IB);
AddCST = ConstantExpr::getAdd(AddCST, Hi);
- AddCST = ConstantExpr::getCast(AddCST, UnsType);
+ AddCST = ConstantExpr::getBitCast(AddCST, UnsType);
return new SetCondInst(Instruction::SetLT, OffsetVal, AddCST);
}
@@ -2918,9 +2929,9 @@
InsertNewInstBefore(Add, IB);
// Convert to unsigned for the comparison.
const Type *UnsType = Add->getType()->getUnsignedVersion();
- Value *OffsetVal = InsertCastBefore(Add, UnsType, IB);
+ Value *OffsetVal = InsertCastBefore(Instruction::BitCast, Add, UnsType, IB);
AddCST = ConstantExpr::getAdd(AddCST, Hi);
- AddCST = ConstantExpr::getCast(AddCST, UnsType);
+ AddCST = ConstantExpr::getBitCast(AddCST, UnsType);
return new SetCondInst(Instruction::SetGT, OffsetVal, AddCST);
}
@@ -3101,7 +3112,7 @@
} else if (CastOp->getOpcode() == Instruction::Or) {
// Change: and (cast (or X, C1) to T), C2
// into : trunc(C1)&C2 iff trunc(C1)&C2 == C2
- Constant *C3 = ConstantExpr::getCast(AndCI, I.getType());
+ Constant *C3 = ConstantExpr::getBitCast(AndCI, I.getType());
if (ConstantExpr::getAnd(C3, AndRHS) == AndRHS) // trunc(C1)&C2
return ReplaceInstUsesWith(I, AndRHS);
}
@@ -3226,9 +3237,10 @@
LHSVal->getName()+".off");
InsertNewInstBefore(Add, I);
const Type *UnsType = Add->getType()->getUnsignedVersion();
- Value *OffsetVal = InsertCastBefore(Add, UnsType, I);
+ Value *OffsetVal = InsertCastBefore(Instruction::BitCast, Add,
+ UnsType, I);
AddCST = ConstantExpr::getSub(RHSCst, LHSCst);
- AddCST = ConstantExpr::getCast(AddCST, UnsType);
+ AddCST = ConstantExpr::getBitCast(AddCST, UnsType);
return new SetCondInst(Instruction::SetGT, OffsetVal, AddCST);
}
break; // (X != 13 & X != 15) -> no change
@@ -3614,9 +3626,10 @@
LHSVal->getName()+".off");
InsertNewInstBefore(Add, I);
const Type *UnsType = Add->getType()->getUnsignedVersion();
- Value *OffsetVal = InsertCastBefore(Add, UnsType, I);
+ Value *OffsetVal = InsertCastBefore(Instruction::BitCast, Add,
+ UnsType, I);
AddCST = ConstantExpr::getSub(AddOne(RHSCst), LHSCst);
- AddCST = ConstantExpr::getCast(AddCST, UnsType);
+ AddCST = ConstantExpr::getBitCast(AddCST, UnsType);
return new SetCondInst(Instruction::SetLT, OffsetVal, AddCST);
}
break; // (X == 13 | X == 15) -> no change
@@ -3917,11 +3930,11 @@
for (unsigned i = 1, e = GEP->getNumOperands(); i != e; ++i, ++GTI) {
Value *Op = GEP->getOperand(i);
uint64_t Size = TD.getTypeSize(GTI.getIndexedType()) & PtrSizeMask;
- Constant *Scale = ConstantExpr::getCast(ConstantInt::get(UIntPtrTy, Size),
+ Constant *Scale = ConstantExpr::getBitCast(ConstantInt::get(UIntPtrTy, Size),
SIntPtrTy);
if (Constant *OpC = dyn_cast<Constant>(Op)) {
if (!OpC->isNullValue()) {
- OpC = ConstantExpr::getCast(OpC, SIntPtrTy);
+ OpC = ConstantExpr::getIntegerCast(OpC, SIntPtrTy, true /*SExt*/);
Scale = ConstantExpr::getMul(OpC, Scale);
if (Constant *RC = dyn_cast<Constant>(Result))
Result = ConstantExpr::getAdd(RC, Scale);
@@ -4089,9 +4102,9 @@
// signed comparison.
const Type *NewTy = LHSV->getType()->getSignedVersion();
if (LHSV->getType() != NewTy)
- LHSV = InsertCastBefore(LHSV, NewTy, I);
+ LHSV = InsertCastBefore(Instruction::BitCast, LHSV, NewTy, I);
if (RHSV->getType() != NewTy)
- RHSV = InsertCastBefore(RHSV, NewTy, I);
+ RHSV = InsertCastBefore(Instruction::BitCast, RHSV, NewTy, I);
return new SetCondInst(Cond, LHSV, RHSV);
}
}
@@ -4388,7 +4401,8 @@
if (AndTy == Ty)
LHSI->setOperand(0, Shift->getOperand(0));
else {
- Value *NewCast = InsertCastBefore(Shift->getOperand(0), AndTy,
+ Value *NewCast = InsertCastBefore(Instruction::BitCast,
+ Shift->getOperand(0), AndTy,
*Shift);
LHSI->setOperand(0, NewCast);
}
@@ -4414,7 +4428,7 @@
// Make sure we insert a logical shift.
Constant *NewAndCST = AndCST;
if (AndCST->getType()->isSigned())
- NewAndCST = ConstantExpr::getCast(AndCST,
+ NewAndCST = ConstantExpr::getBitCast(AndCST,
AndCST->getType()->getUnsignedVersion());
NS = new ShiftInst(Instruction::LShr, NewAndCST,
Shift->getOperand(1), "tmp");
@@ -4423,11 +4437,13 @@
// If C's sign doesn't agree with the and, insert a cast now.
if (NS->getType() != LHSI->getType())
- NS = InsertCastBefore(NS, LHSI->getType(), I);
+ NS = InsertCastBefore(Instruction::BitCast, NS, LHSI->getType(),
+ I);
Value *ShiftOp = Shift->getOperand(0);
if (ShiftOp->getType() != LHSI->getType())
- ShiftOp = InsertCastBefore(ShiftOp, LHSI->getType(), I);
+ ShiftOp = InsertCastBefore(Instruction::BitCast, ShiftOp,
+ LHSI->getType(), I);
// Compute X & (C << Y).
Instruction *NewAnd =
@@ -4755,7 +4771,7 @@
// If 'X' is not signed, insert a cast now...
if (!BOC->getType()->isSigned()) {
const Type *DestTy = BOC->getType()->getSignedVersion();
- X = InsertCastBefore(X, DestTy, I);
+ X = InsertCastBefore(Instruction::BitCast, X, DestTy, I);
}
return new SetCondInst(isSetNE ? Instruction::SetLT :
Instruction::SetGE, X,
@@ -4770,8 +4786,8 @@
// If 'X' is signed, insert a cast now.
if (NegX->getType()->isSigned()) {
const Type *DestTy = NegX->getType()->getUnsignedVersion();
- X = InsertCastBefore(X, DestTy, I);
- NegX = ConstantExpr::getCast(NegX, DestTy);
+ X = InsertCastBefore(Instruction::BitCast, X, DestTy, I);
+ NegX = ConstantExpr::getBitCast(NegX, DestTy);
}
return new SetCondInst(isSetNE ? Instruction::SetGE :
@@ -4928,10 +4944,11 @@
// If Op1 is a constant, we can fold the cast into the constant.
if (Op1->getType() != Op0->getType())
if (Constant *Op1C = dyn_cast<Constant>(Op1)) {
- Op1 = ConstantExpr::getCast(Op1C, Op0->getType());
+ Op1 = ConstantExpr::getCast(Instruction::BitCast, Op1C,
+ Op0->getType());
} else {
// Otherwise, cast the RHS right before the setcc
- Op1 = InsertCastBefore(Op1, Op0->getType(), I);
+ Op1 = InsertCastBefore(Instruction::BitCast, Op1, Op0->getType(), I);
}
return BinaryOperator::create(I.getOpcode(), Op0, Op1);
}
@@ -5398,7 +5415,7 @@
Value *Op = ShiftOp->getOperand(0);
if (Op->getType() != C->getType())
- Op = InsertCastBefore(Op, I.getType(), I);
+ Op = InsertCastBefore(Instruction::BitCast, Op, I.getType(), I);
Instruction *Mask =
BinaryOperator::createAnd(Op, C, Op->getName()+".mask");
@@ -5420,7 +5437,8 @@
}
} else {
// (X >>s C1) << C2 where C1 > C2 === (X >>s (C1-C2)) & mask
- Op = InsertCastBefore(Mask, I.getType()->getSignedVersion(), I);
+ Op = InsertCastBefore(Instruction::BitCast, Mask,
+ I.getType()->getSignedVersion(), I);
Instruction *Shift =
new ShiftInst(ShiftOp->getOpcode(), Op,
ConstantInt::get(Type::UByteTy, ShiftAmt1-ShiftAmt2));
@@ -5851,7 +5869,8 @@
case Instruction::SExt:
// We need to emit a cast to truncate, then a cast to sext.
return CastInst::create(Instruction::SExt,
- InsertCastBefore(Res, Src->getType(), CI), DestTy);
+ InsertCastBefore(Instruction::Trunc, Res, Src->getType(),
+ CI), DestTy);
}
}
}
@@ -5874,10 +5893,15 @@
if (DestBitSize == SrcBitSize ||
!ValueRequiresCast(Op1, DestTy,TD) ||
!ValueRequiresCast(Op0, DestTy, TD)) {
- Value *Op0c = InsertOperandCastBefore(Op0, DestTy, SrcI);
- Value *Op1c = InsertOperandCastBefore(Op1, DestTy, SrcI);
- return BinaryOperator::create(cast<BinaryOperator>(SrcI)
- ->getOpcode(), Op0c, Op1c);
+ unsigned Op0BitSize = Op0->getType()->getPrimitiveSizeInBits();
+ Instruction::CastOps opcode =
+ (Op0BitSize > DestBitSize ? Instruction::Trunc :
+ (Op0BitSize == DestBitSize ? Instruction::BitCast :
+ Op0->getType()->isSigned() ? Instruction::SExt :Instruction::ZExt));
+ Value *Op0c = InsertOperandCastBefore(opcode, Op0, DestTy, SrcI);
+ Value *Op1c = InsertOperandCastBefore(opcode, Op1, DestTy, SrcI);
+ return BinaryOperator::create(
+ cast<BinaryOperator>(SrcI)->getOpcode(), Op0c, Op1c);
}
}
@@ -5886,7 +5910,7 @@
SrcI->getOpcode() == Instruction::Xor &&
Op1 == ConstantBool::getTrue() &&
(!Op0->hasOneUse() || !isa<SetCondInst>(Op0))) {
- Value *New = InsertOperandCastBefore(Op0, DestTy, &CI);
+ Value *New = InsertOperandCastBefore(Instruction::ZExt, Op0, DestTy, &CI);
return BinaryOperator::createXor(New, ConstantInt::get(CI.getType(), 1));
}
break;
@@ -5901,8 +5925,10 @@
// only be converting signedness, which is a noop.
if (!ValueRequiresCast(Op1, DestTy,TD) ||
!ValueRequiresCast(Op0, DestTy, TD)) {
- Value *Op0c = InsertOperandCastBefore(Op0, DestTy, SrcI);
- Value *Op1c = InsertOperandCastBefore(Op1, DestTy, SrcI);
+ Value *Op0c = InsertOperandCastBefore(Instruction::BitCast,
+ Op0, DestTy, SrcI);
+ Value *Op1c = InsertOperandCastBefore(Instruction::BitCast,
+ Op1, DestTy, SrcI);
return BinaryOperator::create(
cast<BinaryOperator>(SrcI)->getOpcode(), Op0c, Op1c);
}
@@ -5917,7 +5943,9 @@
// in the value.
if (DestBitSize == SrcBitSize ||
(DestBitSize < SrcBitSize && isa<Constant>(Op1))) {
- Value *Op0c = InsertOperandCastBefore(Op0, DestTy, SrcI);
+ Instruction::CastOps opcode = (DestBitSize == SrcBitSize ?
+ Instruction::BitCast : Instruction::Trunc);
+ Value *Op0c = InsertOperandCastBefore(opcode, Op0, DestTy, SrcI);
return new ShiftInst(Instruction::Shl, Op0c, Op1);
}
break;
@@ -6014,13 +6042,18 @@
// Get a mask for the bits shifting in.
uint64_t Mask = (~0ULL >> (64-ShAmt)) << DestBitWidth;
- if (SrcI->hasOneUse() && MaskedValueIsZero(SrcI->getOperand(0), Mask)) {
+ Value* SrcIOp0 = SrcI->getOperand(0);
+ if (SrcI->hasOneUse() && MaskedValueIsZero(SrcIOp0, Mask)) {
if (ShAmt >= DestBitWidth) // All zeros.
return ReplaceInstUsesWith(CI, Constant::getNullValue(Ty));
// Okay, we can shrink this. Truncate the input, then return a new
// shift.
- Value *V = InsertCastBefore(SrcI->getOperand(0), Ty, CI);
+ Instruction::CastOps opcode =
+ (SrcIOp0->getType()->getPrimitiveSizeInBits() ==
+ Ty->getPrimitiveSizeInBits() ? Instruction::BitCast :
+ Instruction::Trunc);
+ Value *V = InsertCastBefore(opcode, SrcIOp0, Ty, CI);
return new ShiftInst(Instruction::LShr, V, SrcI->getOperand(1));
}
} else { // This is a variable shr.
@@ -6188,8 +6221,10 @@
Tmp->getOperand(0)->getType() == DestTy) ||
((Tmp = dyn_cast<CastInst>(SVI->getOperand(1))) &&
Tmp->getOperand(0)->getType() == DestTy)) {
- Value *LHS = InsertOperandCastBefore(SVI->getOperand(0), DestTy, &CI);
- Value *RHS = InsertOperandCastBefore(SVI->getOperand(1), DestTy, &CI);
+ Value *LHS = InsertOperandCastBefore(Instruction::BitCast,
+ SVI->getOperand(0), DestTy, &CI);
+ Value *RHS = InsertOperandCastBefore(Instruction::BitCast,
+ SVI->getOperand(1), DestTy, &CI);
// Return a new shuffle vector. Use the same element ID's, as we
// know the vector types match #elts.
return new ShuffleVectorInst(LHS, RHS, SVI->getOperand(2));
@@ -6737,7 +6772,7 @@
// Turn PPC lvx -> load if the pointer is known aligned.
// Turn X86 loadups -> load if the pointer is known aligned.
if (GetKnownAlignment(II->getOperand(1), TD) >= 16) {
- Value *Ptr = InsertCastBefore(II->getOperand(1),
+ Value *Ptr = InsertCastBefore(Instruction::BitCast, II->getOperand(1),
PointerType::get(II->getType()), CI);
return new LoadInst(Ptr);
}
@@ -6747,7 +6782,8 @@
// Turn stvx -> store if the pointer is known aligned.
if (GetKnownAlignment(II->getOperand(2), TD) >= 16) {
const Type *OpPtrTy = PointerType::get(II->getOperand(1)->getType());
- Value *Ptr = InsertCastBefore(II->getOperand(2), OpPtrTy, CI);
+ Value *Ptr = InsertCastBefore(Instruction::BitCast, II->getOperand(2),
+ OpPtrTy, CI);
return new StoreInst(II->getOperand(1), Ptr);
}
break;
@@ -6758,7 +6794,8 @@
// Turn X86 storeu -> store if the pointer is known aligned.
if (GetKnownAlignment(II->getOperand(1), TD) >= 16) {
const Type *OpPtrTy = PointerType::get(II->getOperand(2)->getType());
- Value *Ptr = InsertCastBefore(II->getOperand(1), OpPtrTy, CI);
+ Value *Ptr = InsertCastBefore(Instruction::BitCast, II->getOperand(1),
+ OpPtrTy, CI);
return new StoreInst(II->getOperand(2), Ptr);
}
break;
@@ -6792,8 +6829,10 @@
if (AllEltsOk) {
// Cast the input vectors to byte vectors.
- Value *Op0 = InsertCastBefore(II->getOperand(1), Mask->getType(), CI);
- Value *Op1 = InsertCastBefore(II->getOperand(2), Mask->getType(), CI);
+ Value *Op0 = InsertCastBefore(Instruction::BitCast,
+ II->getOperand(1), Mask->getType(), CI);
+ Value *Op1 = InsertCastBefore(Instruction::BitCast,
+ II->getOperand(2), Mask->getType(), CI);
Value *Result = UndefValue::get(Op0->getType());
// Only extract each element once.
@@ -7316,15 +7355,18 @@
return 0;
}
-static Value *InsertSignExtendToPtrTy(Value *V, const Type *DTy,
- Instruction *InsertPoint,
- InstCombiner *IC) {
- unsigned PS = IC->getTargetData().getPointerSize();
- const Type *VTy = V->getType();
- if (!VTy->isSigned() && VTy->getPrimitiveSize() < PS)
- // We must insert a cast to ensure we sign-extend.
- V = IC->InsertCastBefore(V, VTy->getSignedVersion(), *InsertPoint);
- return IC->InsertCastBefore(V, DTy, *InsertPoint);
+static Value *InsertCastToIntPtrTy(Value *V, const Type *DTy,
+ Instruction *InsertPoint,
+ InstCombiner *IC) {
+ unsigned PtrSize = IC->getTargetData().getPointerSize();
+ unsigned VTySize = V->getType()->getPrimitiveSize();
+ // We must cast correctly to the pointer type. Ensure that we
+ // sign extend the integer value if it is smaller as this is
+ // used for address computation.
+ Instruction::CastOps opcode =
+ (VTySize < PtrSize ? Instruction::SExt :
+ (VTySize == PtrSize ? Instruction::BitCast : Instruction::Trunc));
+ return IC->InsertCastBefore(opcode, V, DTy, *InsertPoint);
}
@@ -7384,11 +7426,12 @@
Value *Op = GEP.getOperand(i);
if (Op->getType()->getPrimitiveSize() > TD->getPointerSize())
if (Constant *C = dyn_cast<Constant>(Op)) {
- GEP.setOperand(i, ConstantExpr::getCast(C,
+ GEP.setOperand(i, ConstantExpr::getTrunc(C,
TD->getIntPtrType()->getSignedVersion()));
MadeChange = true;
} else {
- Op = InsertCastBefore(Op, TD->getIntPtrType(), GEP);
+ Op = InsertCastBefore(Instruction::Trunc, Op, TD->getIntPtrType(),
+ GEP);
GEP.setOperand(i, Op);
MadeChange = true;
}
@@ -7398,7 +7441,7 @@
if (ConstantInt *CUI = dyn_cast<ConstantInt>(Op))
if (CUI->getType()->isUnsigned()) {
GEP.setOperand(i,
- ConstantExpr::getCast(CUI, CUI->getType()->getSignedVersion()));
+ ConstantExpr::getBitCast(CUI, CUI->getType()->getSignedVersion()));
MadeChange = true;
}
}
@@ -7444,22 +7487,22 @@
// target's pointer size.
if (SO1->getType() != GO1->getType()) {
if (Constant *SO1C = dyn_cast<Constant>(SO1)) {
- SO1 = ConstantExpr::getCast(SO1C, GO1->getType());
+ SO1 = ConstantExpr::getIntegerCast(SO1C, GO1->getType(), true);
} else if (Constant *GO1C = dyn_cast<Constant>(GO1)) {
- GO1 = ConstantExpr::getCast(GO1C, SO1->getType());
+ GO1 = ConstantExpr::getIntegerCast(GO1C, SO1->getType(), true);
} else {
unsigned PS = TD->getPointerSize();
if (SO1->getType()->getPrimitiveSize() == PS) {
// Convert GO1 to SO1's type.
- GO1 = InsertSignExtendToPtrTy(GO1, SO1->getType(), &GEP, this);
+ GO1 = InsertCastToIntPtrTy(GO1, SO1->getType(), &GEP, this);
} else if (GO1->getType()->getPrimitiveSize() == PS) {
// Convert SO1 to GO1's type.
- SO1 = InsertSignExtendToPtrTy(SO1, GO1->getType(), &GEP, this);
+ SO1 = InsertCastToIntPtrTy(SO1, GO1->getType(), &GEP, this);
} else {
const Type *PT = TD->getIntPtrType();
- SO1 = InsertSignExtendToPtrTy(SO1, PT, &GEP, this);
- GO1 = InsertSignExtendToPtrTy(GO1, PT, &GEP, this);
+ SO1 = InsertCastToIntPtrTy(SO1, PT, &GEP, this);
+ GO1 = InsertCastToIntPtrTy(GO1, PT, &GEP, this);
}
}
}
@@ -7593,7 +7636,8 @@
Scale = ConstantInt::get(Scale->getType(),
Scale->getZExtValue() / ArrayEltSize);
if (Scale->getZExtValue() != 1) {
- Constant *C = ConstantExpr::getCast(Scale, NewIdx->getType());
+ Constant *C = ConstantExpr::getIntegerCast(Scale, NewIdx->getType(),
+ true /*SExt*/);
Instruction *Sc = BinaryOperator::createMul(NewIdx, C, "idxscale");
NewIdx = InsertNewInstBefore(Sc, GEP);
}
@@ -8279,7 +8323,7 @@
return BinaryOperator::create(BO->getOpcode(), newEI0, newEI1);
}
} else if (isa<LoadInst>(I)) {
- Value *Ptr = InsertCastBefore(I->getOperand(0),
+ Value *Ptr = InsertCastBefore(Instruction::BitCast, I->getOperand(0),
PointerType::get(EI.getType()), EI);
GetElementPtrInst *GEP =
new GetElementPtrInst(Ptr, EI.getOperand(1), I->getName() + ".gep");
@@ -8659,7 +8703,7 @@
}
/// OptimizeConstantExpr - Given a constant expression and target data layout
-/// information, symbolically evaluation the constant expr to something simpler
+/// information, symbolically evaluate the constant expr to something simpler
/// if possible.
static Constant *OptimizeConstantExpr(ConstantExpr *CE, const TargetData *TD) {
if (!TD) return CE;
@@ -8677,8 +8721,8 @@
std::vector<Value*> Ops(CE->op_begin()+1, CE->op_end());
uint64_t Offset = TD->getIndexedOffset(Ptr->getType(), Ops);
Constant *C = ConstantInt::get(Type::ULongTy, Offset);
- C = ConstantExpr::getCast(C, TD->getIntPtrType());
- return ConstantExpr::getCast(C, CE->getType());
+ C = ConstantExpr::getIntegerCast(C, TD->getIntPtrType(), true /*SExt*/);
+ return ConstantExpr::getIntToPtr(C, CE->getType());
}
}
More information about the llvm-commits
mailing list