[llvm-commits] CVS: llvm/lib/Transforms/Scalar/InstructionCombining.cpp
Reid Spencer
reid at x10sys.com
Fri Mar 23 11:46:52 PDT 2007
Changes in directory llvm/lib/Transforms/Scalar:
InstructionCombining.cpp updated: 1.677 -> 1.678
---
Log message:
For PR1205: http://llvm.org/PR1205 :
APIntify several utility functions supporting logical operators and shift
operators.
Patch by Zhou Sheng.
---
Diffs of the changes: (+39 -37)
InstructionCombining.cpp | 76 ++++++++++++++++++++++++-----------------------
1 files changed, 39 insertions(+), 37 deletions(-)
Index: llvm/lib/Transforms/Scalar/InstructionCombining.cpp
diff -u llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.677 llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.678
--- llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.677 Thu Mar 22 22:13:21 2007
+++ llvm/lib/Transforms/Scalar/InstructionCombining.cpp Fri Mar 23 13:46:34 2007
@@ -3666,17 +3666,14 @@
// Adding a one to a single bit bit-field should be turned into an XOR
// of the bit. First thing to check is to see if this AND is with a
// single bit constant.
- uint64_t AndRHSV = cast<ConstantInt>(AndRHS)->getZExtValue();
-
- // Clear bits that are not part of the constant.
- AndRHSV &= AndRHS->getType()->getBitMask();
+ APInt AndRHSV(cast<ConstantInt>(AndRHS)->getValue());
// If there is only one bit set...
if (isOneBitSet(cast<ConstantInt>(AndRHS))) {
// Ok, at this point, we know that we are masking the result of the
// ADD down to exactly one bit. If the constant we are adding has
// no bits set below this bit, then we can eliminate the ADD.
- uint64_t AddRHS = cast<ConstantInt>(OpRHS)->getZExtValue();
+ APInt AddRHS(cast<ConstantInt>(OpRHS)->getValue());
// Check to see if any bits below the one bit set in AndRHSV are set.
if ((AddRHS & (AndRHSV-1)) == 0) {
@@ -3849,7 +3846,7 @@
case Instruction::And:
if (ConstantExpr::getAnd(N, Mask) == Mask) {
// If the AndRHS is a power of two minus one (0+1+), this is simple.
- if ((Mask->getZExtValue() & Mask->getZExtValue()+1) == 0)
+ if ((Mask->getValue() & Mask->getValue()+1) == 0)
break;
// Otherwise, if Mask is 0+1+0+, and if B is known to have the low 0+
@@ -3857,8 +3854,9 @@
// is all N is, ignore it.
unsigned MB, ME;
if (isRunOfOnes(Mask, MB, ME)) { // begin/end bit of run, inclusive
- uint64_t Mask = cast<IntegerType>(RHS->getType())->getBitMask();
- Mask >>= 64-MB+1;
+ uint32_t BitWidth = cast<IntegerType>(RHS->getType())->getBitWidth();
+ APInt Mask(APInt::getAllOnesValue(BitWidth));
+ Mask = APIntOps::lshr(Mask, BitWidth-MB+1);
if (MaskedValueIsZero(RHS, Mask))
break;
}
@@ -3867,7 +3865,7 @@
case Instruction::Or:
case Instruction::Xor:
// If the AndRHS is a power of two minus one (0+1+), and N&Mask == 0
- if ((Mask->getZExtValue() & Mask->getZExtValue()+1) == 0 &&
+ if ((Mask->getValue() & Mask->getValue()+1) == 0 &&
ConstantExpr::getAnd(N, Mask)->isNullValue())
break;
return 0;
@@ -6292,8 +6290,8 @@
// See if we can turn a signed shr into an unsigned shr.
if (I.isArithmeticShift()) {
- if (MaskedValueIsZero(Op0,
- 1ULL << (I.getType()->getPrimitiveSizeInBits()-1))) {
+ if (MaskedValueIsZero(Op0,
+ APInt::getSignBit(I.getType()->getPrimitiveSizeInBits()))) {
return BinaryOperator::createLShr(Op0, Op1, I.getName());
}
}
@@ -6310,16 +6308,16 @@
// See if we can simplify any instructions used by the instruction whose sole
// purpose is to compute bits we don't care about.
- uint64_t KnownZero, KnownOne;
- if (SimplifyDemandedBits(&I, cast<IntegerType>(I.getType())->getBitMask(),
+ uint32_t TypeBits = Op0->getType()->getPrimitiveSizeInBits();
+ APInt KnownZero(TypeBits, 0), KnownOne(TypeBits, 0);
+ if (SimplifyDemandedBits(&I, APInt::getAllOnesValue(TypeBits),
KnownZero, KnownOne))
return &I;
// shl uint X, 32 = 0 and shr ubyte Y, 9 = 0, ... just don't eliminate shr
// of a signed value.
//
- unsigned TypeBits = Op0->getType()->getPrimitiveSizeInBits();
- if (Op1->getZExtValue() >= TypeBits) {
+ if (Op1->getZExtValue() >= TypeBits) { // shift amount always <= 32 bits
if (I.getOpcode() != Instruction::AShr)
return ReplaceInstUsesWith(I, Constant::getNullValue(Op0->getType()));
else {
@@ -6462,8 +6460,8 @@
// operation.
//
if (isValid && !isLeftShift && I.getOpcode() == Instruction::AShr) {
- uint64_t Val = Op0C->getZExtValue();
- isValid = ((Val & (1 << (TypeBits-1))) != 0) == highBitSet;
+ APInt Val(Op0C->getValue());
+ isValid = ((Val & APInt::getSignBit(TypeBits)) != 0) == highBitSet;
}
if (isValid) {
@@ -6488,6 +6486,7 @@
if (ShiftOp && isa<ConstantInt>(ShiftOp->getOperand(1))) {
ConstantInt *ShiftAmt1C = cast<ConstantInt>(ShiftOp->getOperand(1));
+ // shift amount always <= 32 bits
unsigned ShiftAmt1 = (unsigned)ShiftAmt1C->getZExtValue();
unsigned ShiftAmt2 = (unsigned)Op1->getZExtValue();
assert(ShiftAmt2 != 0 && "Should have been simplified earlier");
@@ -6495,8 +6494,8 @@
Value *X = ShiftOp->getOperand(0);
unsigned AmtSum = ShiftAmt1+ShiftAmt2; // Fold into one big shift.
- if (AmtSum > I.getType()->getPrimitiveSizeInBits())
- AmtSum = I.getType()->getPrimitiveSizeInBits();
+ if (AmtSum > TypeBits)
+ AmtSum = TypeBits;
const IntegerType *Ty = cast<IntegerType>(I.getType());
@@ -6515,8 +6514,8 @@
BinaryOperator::createAShr(X, ConstantInt::get(Ty, AmtSum));
InsertNewInstBefore(Shift, I);
- uint64_t Mask = Ty->getBitMask() >> ShiftAmt2;
- return BinaryOperator::createAnd(Shift, ConstantInt::get(Ty, Mask));
+ APInt Mask(APInt::getAllOnesValue(TypeBits).lshr(ShiftAmt2));
+ return BinaryOperator::createAnd(Shift, ConstantInt::get(Mask));
}
// Okay, if we get here, one shift must be left, and the other shift must be
@@ -6524,13 +6523,13 @@
if (ShiftAmt1 == ShiftAmt2) {
// If we have ((X >>? C) << C), turn this into X & (-1 << C).
if (I.getOpcode() == Instruction::Shl) {
- uint64_t Mask = Ty->getBitMask() << ShiftAmt1;
- return BinaryOperator::createAnd(X, ConstantInt::get(Ty, Mask));
+ APInt Mask(APInt::getAllOnesValue(TypeBits).shl(ShiftAmt1));
+ return BinaryOperator::createAnd(X, ConstantInt::get(Mask));
}
// If we have ((X << C) >>u C), turn this into X & (-1 >>u C).
if (I.getOpcode() == Instruction::LShr) {
- uint64_t Mask = Ty->getBitMask() >> ShiftAmt1;
- return BinaryOperator::createAnd(X, ConstantInt::get(Ty, Mask));
+ APInt Mask(APInt::getAllOnesValue(TypeBits).lshr(ShiftAmt1));
+ return BinaryOperator::createAnd(X, ConstantInt::get(Mask));
}
// We can simplify ((X << C) >>s C) into a trunc + sext.
// NOTE: we could do this for any C, but that would make 'unusual' integer
@@ -6538,9 +6537,12 @@
// generators.
const Type *SExtType = 0;
switch (Ty->getBitWidth() - ShiftAmt1) {
- case 8 : SExtType = Type::Int8Ty; break;
- case 16: SExtType = Type::Int16Ty; break;
- case 32: SExtType = Type::Int32Ty; break;
+ case 1 : SExtType = Type::Int1Ty; break;
+ case 8 : SExtType = Type::Int8Ty; break;
+ case 16 : SExtType = Type::Int16Ty; break;
+ case 32 : SExtType = Type::Int32Ty; break;
+ case 64 : SExtType = Type::Int64Ty; break;
+ case 128: SExtType = IntegerType::get(128); break;
default: break;
}
if (SExtType) {
@@ -6560,8 +6562,8 @@
BinaryOperator::createShl(X, ConstantInt::get(Ty, ShiftDiff));
InsertNewInstBefore(Shift, I);
- uint64_t Mask = Ty->getBitMask() << ShiftAmt2;
- return BinaryOperator::createAnd(Shift, ConstantInt::get(Ty, Mask));
+ APInt Mask(APInt::getAllOnesValue(TypeBits).shl(ShiftAmt2));
+ return BinaryOperator::createAnd(Shift, ConstantInt::get(Mask));
}
// (X << C1) >>u C2 --> X >>u (C2-C1) & (-1 >> C2)
@@ -6571,8 +6573,8 @@
BinaryOperator::createLShr(X, ConstantInt::get(Ty, ShiftDiff));
InsertNewInstBefore(Shift, I);
- uint64_t Mask = Ty->getBitMask() >> ShiftAmt2;
- return BinaryOperator::createAnd(Shift, ConstantInt::get(Ty, Mask));
+ APInt Mask(APInt::getAllOnesValue(TypeBits).lshr(ShiftAmt2));
+ return BinaryOperator::createAnd(Shift, ConstantInt::get(Mask));
}
// We can't handle (X << C1) >>s C2, it shifts arbitrary bits in.
@@ -6589,8 +6591,8 @@
ConstantInt::get(Ty, ShiftDiff));
InsertNewInstBefore(Shift, I);
- uint64_t Mask = Ty->getBitMask() << ShiftAmt2;
- return BinaryOperator::createAnd(Shift, ConstantInt::get(Ty, Mask));
+ APInt Mask(APInt::getAllOnesValue(TypeBits).shl(ShiftAmt2));
+ return BinaryOperator::createAnd(Shift, ConstantInt::get(Mask));
}
// (X << C1) >>u C2 --> X << (C1-C2) & (-1 >> C2)
@@ -6600,8 +6602,8 @@
BinaryOperator::createShl(X, ConstantInt::get(Ty, ShiftDiff));
InsertNewInstBefore(Shift, I);
- uint64_t Mask = Ty->getBitMask() >> ShiftAmt2;
- return BinaryOperator::createAnd(Shift, ConstantInt::get(Ty, Mask));
+ APInt Mask(APInt::getAllOnesValue(TypeBits).lshr(ShiftAmt2));
+ return BinaryOperator::createAnd(Shift, ConstantInt::get(Mask));
}
// We can't handle (X << C1) >>a C2, it shifts arbitrary bits in.
@@ -8191,7 +8193,7 @@
(ParamTy->isInteger() && ActTy->isInteger() &&
ParamTy->getPrimitiveSizeInBits() >= ActTy->getPrimitiveSizeInBits()) ||
(c && ParamTy->getPrimitiveSizeInBits() >= ActTy->getPrimitiveSizeInBits()
- && c->getSExtValue() > 0);
+ && c->getValue().isPositive());
if (Callee->isDeclaration() && !isConvertible) return false;
}
More information about the llvm-commits
mailing list