[llvm-commits] CVS: llvm/lib/Transforms/Scalar/CorrelatedExprs.cpp InstructionCombining.cpp LoopUnswitch.cpp ScalarReplAggregates.cpp
Reid Spencer
reid at x10sys.com
Fri Jan 19 13:14:26 PST 2007
Changes in directory llvm/lib/Transforms/Scalar:
CorrelatedExprs.cpp updated: 1.49 -> 1.50
InstructionCombining.cpp updated: 1.603 -> 1.604
LoopUnswitch.cpp updated: 1.57 -> 1.58
ScalarReplAggregates.cpp updated: 1.66 -> 1.67
---
Log message:
For PR1043: http://llvm.org/PR1043 :
This is the final patch for this PR. It implements some minor cleanup
in the use of IntegerType, to wit:
1. Type::getIntegerTypeMask -> IntegerType::getBitMask
2. Type::Int*Ty changed to IntegerType* from Type*
3. ConstantInt::getType() returns IntegerType* now, not Type*
This also fixes PR1120: http://llvm.org/PR1120 .
Patch by Sheng Zhou.
---
Diffs of the changes: (+42 -40)
CorrelatedExprs.cpp | 1
InstructionCombining.cpp | 76 +++++++++++++++++++++++------------------------
LoopUnswitch.cpp | 3 +
ScalarReplAggregates.cpp | 2 -
4 files changed, 42 insertions(+), 40 deletions(-)
Index: llvm/lib/Transforms/Scalar/CorrelatedExprs.cpp
diff -u llvm/lib/Transforms/Scalar/CorrelatedExprs.cpp:1.49 llvm/lib/Transforms/Scalar/CorrelatedExprs.cpp:1.50
--- llvm/lib/Transforms/Scalar/CorrelatedExprs.cpp:1.49 Sun Jan 14 20:27:26 2007
+++ llvm/lib/Transforms/Scalar/CorrelatedExprs.cpp Fri Jan 19 15:13:56 2007
@@ -33,6 +33,7 @@
#include "llvm/Function.h"
#include "llvm/Instructions.h"
#include "llvm/Type.h"
+#include "llvm/DerivedTypes.h"
#include "llvm/Analysis/Dominators.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/Transforms/Utils/Local.h"
Index: llvm/lib/Transforms/Scalar/InstructionCombining.cpp
diff -u llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.603 llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.604
--- llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.603 Thu Jan 18 16:16:33 2007
+++ llvm/lib/Transforms/Scalar/InstructionCombining.cpp Fri Jan 19 15:13:56 2007
@@ -558,7 +558,7 @@
Instruction *I = dyn_cast<Instruction>(V);
if (!I) return;
- Mask &= V->getType()->getIntegerTypeMask();
+ Mask &= cast<IntegerType>(V->getType())->getBitMask();
switch (I->getOpcode()) {
case Instruction::And:
@@ -632,11 +632,11 @@
}
case Instruction::ZExt: {
// Compute the bits in the result that are not present in the input.
- const Type *SrcTy = I->getOperand(0)->getType();
- uint64_t NotIn = ~SrcTy->getIntegerTypeMask();
- uint64_t NewBits = I->getType()->getIntegerTypeMask() & NotIn;
+ const IntegerType *SrcTy = cast<IntegerType>(I->getOperand(0)->getType());
+ uint64_t NotIn = ~SrcTy->getBitMask();
+ uint64_t NewBits = cast<IntegerType>(I->getType())->getBitMask() & NotIn;
- Mask &= SrcTy->getIntegerTypeMask();
+ Mask &= SrcTy->getBitMask();
ComputeMaskedBits(I->getOperand(0), Mask, KnownZero, KnownOne, Depth+1);
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
// The top bits are known to be zero.
@@ -645,11 +645,11 @@
}
case Instruction::SExt: {
// Compute the bits in the result that are not present in the input.
- const Type *SrcTy = I->getOperand(0)->getType();
- uint64_t NotIn = ~SrcTy->getIntegerTypeMask();
- uint64_t NewBits = I->getType()->getIntegerTypeMask() & NotIn;
+ const IntegerType *SrcTy = cast<IntegerType>(I->getOperand(0)->getType());
+ uint64_t NotIn = ~SrcTy->getBitMask();
+ uint64_t NewBits = cast<IntegerType>(I->getType())->getBitMask() & NotIn;
- Mask &= SrcTy->getIntegerTypeMask();
+ Mask &= SrcTy->getBitMask();
ComputeMaskedBits(I->getOperand(0), Mask, KnownZero, KnownOne, Depth+1);
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
@@ -766,7 +766,7 @@
uint64_t KnownZero,
uint64_t KnownOne,
int64_t &Min, int64_t &Max) {
- uint64_t TypeBits = Ty->getIntegerTypeMask();
+ uint64_t TypeBits = cast<IntegerType>(Ty)->getBitMask();
uint64_t UnknownBits = ~(KnownZero|KnownOne) & TypeBits;
uint64_t SignBit = 1ULL << (Ty->getPrimitiveSizeInBits()-1);
@@ -796,7 +796,7 @@
uint64_t KnownOne,
uint64_t &Min,
uint64_t &Max) {
- uint64_t TypeBits = Ty->getIntegerTypeMask();
+ uint64_t TypeBits = cast<IntegerType>(Ty)->getBitMask();
uint64_t UnknownBits = ~(KnownZero|KnownOne) & TypeBits;
// The minimum value is when the unknown bits are all zeros.
@@ -831,7 +831,7 @@
}
// If this is the root being simplified, allow it to have multiple uses,
// just set the DemandedMask to all bits.
- DemandedMask = V->getType()->getIntegerTypeMask();
+ DemandedMask = cast<IntegerType>(V->getType())->getBitMask();
} else if (DemandedMask == 0) { // Not demanding any bits from V.
if (V != UndefValue::get(V->getType()))
return UpdateValueUsesWith(V, UndefValue::get(V->getType()));
@@ -843,7 +843,7 @@
Instruction *I = dyn_cast<Instruction>(V);
if (!I) return false; // Only analyze instructions.
- DemandedMask &= V->getType()->getIntegerTypeMask();
+ DemandedMask &= cast<IntegerType>(V->getType())->getBitMask();
uint64_t KnownZero2 = 0, KnownOne2 = 0;
switch (I->getOpcode()) {
@@ -1011,11 +1011,11 @@
break;
case Instruction::ZExt: {
// Compute the bits in the result that are not present in the input.
- const Type *SrcTy = I->getOperand(0)->getType();
- uint64_t NotIn = ~SrcTy->getIntegerTypeMask();
- uint64_t NewBits = I->getType()->getIntegerTypeMask() & NotIn;
+ const IntegerType *SrcTy = cast<IntegerType>(I->getOperand(0)->getType());
+ uint64_t NotIn = ~SrcTy->getBitMask();
+ uint64_t NewBits = cast<IntegerType>(I->getType())->getBitMask() & NotIn;
- DemandedMask &= SrcTy->getIntegerTypeMask();
+ DemandedMask &= SrcTy->getBitMask();
if (SimplifyDemandedBits(I->getOperand(0), DemandedMask,
KnownZero, KnownOne, Depth+1))
return true;
@@ -1026,13 +1026,13 @@
}
case Instruction::SExt: {
// Compute the bits in the result that are not present in the input.
- const Type *SrcTy = I->getOperand(0)->getType();
- uint64_t NotIn = ~SrcTy->getIntegerTypeMask();
- uint64_t NewBits = I->getType()->getIntegerTypeMask() & NotIn;
+ const IntegerType *SrcTy = cast<IntegerType>(I->getOperand(0)->getType());
+ uint64_t NotIn = ~SrcTy->getBitMask();
+ uint64_t NewBits = cast<IntegerType>(I->getType())->getBitMask() & NotIn;
// Get the sign bit for the source type
uint64_t InSignBit = 1ULL << (SrcTy->getPrimitiveSizeInBits()-1);
- int64_t InputDemandedBits = DemandedMask & SrcTy->getIntegerTypeMask();
+ int64_t InputDemandedBits = DemandedMask & SrcTy->getBitMask();
// If any of the sign extended bits are demanded, we know that the sign
// bit is demanded.
@@ -1174,7 +1174,7 @@
// Compute the new bits that are at the top now.
uint64_t HighBits = (1ULL << ShiftAmt)-1;
HighBits <<= I->getType()->getPrimitiveSizeInBits() - ShiftAmt;
- uint64_t TypeMask = I->getType()->getIntegerTypeMask();
+ uint64_t TypeMask = cast<IntegerType>(I->getType())->getBitMask();
// Unsigned shift right.
if (SimplifyDemandedBits(I->getOperand(0),
(DemandedMask << ShiftAmt) & TypeMask,
@@ -1207,7 +1207,7 @@
// Compute the new bits that are at the top now.
uint64_t HighBits = (1ULL << ShiftAmt)-1;
HighBits <<= I->getType()->getPrimitiveSizeInBits() - ShiftAmt;
- uint64_t TypeMask = I->getType()->getIntegerTypeMask();
+ uint64_t TypeMask = cast<IntegerType>(I->getType())->getBitMask();
// Signed shift right.
if (SimplifyDemandedBits(I->getOperand(0),
(DemandedMask << ShiftAmt) & TypeMask,
@@ -1745,7 +1745,7 @@
// (X & 254)+1 -> (X&254)|1
uint64_t KnownZero, KnownOne;
if (!isa<PackedType>(I.getType()) &&
- SimplifyDemandedBits(&I, I.getType()->getIntegerTypeMask(),
+ SimplifyDemandedBits(&I, cast<IntegerType>(I.getType())->getBitMask(),
KnownZero, KnownOne))
return &I;
}
@@ -1780,7 +1780,7 @@
// This is a sign extend if the top bits are known zero.
uint64_t Mask = ~0ULL;
Mask <<= 64-(TySizeBits-Size);
- Mask &= XorLHS->getType()->getIntegerTypeMask();
+ Mask &= cast<IntegerType>(XorLHS->getType())->getBitMask();
if (!MaskedValueIsZero(XorLHS, Mask))
Size = 0; // Not a sign ext, but can't be any others either.
goto FoundSExt;
@@ -1876,7 +1876,7 @@
// Form a mask of all bits from the lowest bit added through the top.
uint64_t AddRHSHighBits = ~((AddRHSV & -AddRHSV)-1);
- AddRHSHighBits &= C2->getType()->getIntegerTypeMask();
+ AddRHSHighBits &= C2->getType()->getBitMask();
// See if the and mask includes all of these bits.
uint64_t AddRHSHighBitsAnd = AddRHSHighBits & C2->getZExtValue();
@@ -2621,7 +2621,7 @@
Val >>= 64-TypeBits; // Shift out unwanted 1 bits...
return C->getSExtValue() == Val-1;
}
- return C->getZExtValue() == C->getType()->getIntegerTypeMask()-1;
+ return C->getZExtValue() == C->getType()->getBitMask()-1;
}
// isMinValuePlusOne - return true if this is Min+1
@@ -2838,7 +2838,7 @@
uint64_t AndRHSV = cast<ConstantInt>(AndRHS)->getZExtValue();
// Clear bits that are not part of the constant.
- AndRHSV &= AndRHS->getType()->getIntegerTypeMask();
+ AndRHSV &= AndRHS->getType()->getBitMask();
// If there is only one bit set...
if (isOneBitSet(cast<ConstantInt>(AndRHS))) {
@@ -3024,7 +3024,7 @@
// is all N is, ignore it.
unsigned MB, ME;
if (isRunOfOnes(Mask, MB, ME)) { // begin/end bit of run, inclusive
- uint64_t Mask = RHS->getType()->getIntegerTypeMask();
+ uint64_t Mask = cast<IntegerType>(RHS->getType())->getBitMask();
Mask >>= 64-MB+1;
if (MaskedValueIsZero(RHS, Mask))
break;
@@ -3063,7 +3063,7 @@
// purpose is to compute bits we don't care about.
uint64_t KnownZero, KnownOne;
if (!isa<PackedType>(I.getType())) {
- if (SimplifyDemandedBits(&I, I.getType()->getIntegerTypeMask(),
+ if (SimplifyDemandedBits(&I, cast<IntegerType>(I.getType())->getBitMask(),
KnownZero, KnownOne))
return &I;
} else {
@@ -3075,7 +3075,7 @@
if (ConstantInt *AndRHS = dyn_cast<ConstantInt>(Op1)) {
uint64_t AndRHSMask = AndRHS->getZExtValue();
- uint64_t TypeMask = Op0->getType()->getIntegerTypeMask();
+ uint64_t TypeMask = cast<IntegerType>(Op0->getType())->getBitMask();
uint64_t NotAndRHS = AndRHSMask^TypeMask;
// Optimize a variety of ((val OP C1) & C2) combinations...
@@ -3540,7 +3540,7 @@
// purpose is to compute bits we don't care about.
uint64_t KnownZero, KnownOne;
if (!isa<PackedType>(I.getType()) &&
- SimplifyDemandedBits(&I, I.getType()->getIntegerTypeMask(),
+ SimplifyDemandedBits(&I, cast<IntegerType>(I.getType())->getBitMask(),
KnownZero, KnownOne))
return &I;
@@ -3868,7 +3868,7 @@
// purpose is to compute bits we don't care about.
uint64_t KnownZero, KnownOne;
if (!isa<PackedType>(I.getType()) &&
- SimplifyDemandedBits(&I, I.getType()->getIntegerTypeMask(),
+ SimplifyDemandedBits(&I, cast<IntegerType>(I.getType())->getBitMask(),
KnownZero, KnownOne))
return &I;
@@ -4498,7 +4498,7 @@
// See if we can fold the comparison based on bits known to be zero or one
// in the input.
uint64_t KnownZero, KnownOne;
- if (SimplifyDemandedBits(Op0, Ty->getIntegerTypeMask(),
+ if (SimplifyDemandedBits(Op0, cast<IntegerType>(Ty)->getBitMask(),
KnownZero, KnownOne, 0))
return &I;
@@ -5422,7 +5422,7 @@
// 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, I.getType()->getIntegerTypeMask(),
+ if (SimplifyDemandedBits(&I, cast<IntegerType>(I.getType())->getBitMask(),
KnownZero, KnownOne))
return &I;
@@ -6024,7 +6024,7 @@
// See if we can simplify any instructions used by the LHS whose sole
// purpose is to compute bits we don't care about.
uint64_t KnownZero = 0, KnownOne = 0;
- if (SimplifyDemandedBits(&CI, DestTy->getIntegerTypeMask(),
+ if (SimplifyDemandedBits(&CI, cast<IntegerType>(DestTy)->getBitMask(),
KnownZero, KnownOne))
return &CI;
@@ -6197,7 +6197,7 @@
if (Op1CV == 0 || isPowerOf2_64(Op1CV)) {
// If Op1C some other power of two, convert:
uint64_t KnownZero, KnownOne;
- uint64_t TypeMask = Op1->getType()->getIntegerTypeMask();
+ uint64_t TypeMask = Op1C->getType()->getBitMask();
ComputeMaskedBits(Op0, TypeMask, KnownZero, KnownOne);
// This only works for EQ and NE
@@ -6319,7 +6319,7 @@
// If we're actually extending zero bits and the trunc is a no-op
if (MidSize < DstSize && SrcSize == DstSize) {
// Replace both of the casts with an And of the type mask.
- uint64_t AndValue = CSrc->getType()->getIntegerTypeMask();
+ uint64_t AndValue = cast<IntegerType>(CSrc->getType())->getBitMask();
Constant *AndConst = ConstantInt::get(A->getType(), AndValue);
Instruction *And =
BinaryOperator::createAnd(CSrc->getOperand(0), AndConst);
Index: llvm/lib/Transforms/Scalar/LoopUnswitch.cpp
diff -u llvm/lib/Transforms/Scalar/LoopUnswitch.cpp:1.57 llvm/lib/Transforms/Scalar/LoopUnswitch.cpp:1.58
--- llvm/lib/Transforms/Scalar/LoopUnswitch.cpp:1.57 Fri Jan 12 18:02:49 2007
+++ llvm/lib/Transforms/Scalar/LoopUnswitch.cpp Fri Jan 19 15:13:56 2007
@@ -29,6 +29,7 @@
#define DEBUG_TYPE "loop-unswitch"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"
#include "llvm/Instructions.h"
#include "llvm/Analysis/LoopInfo.h"
@@ -486,7 +487,7 @@
// Insert a conditional branch on LIC to the two preheaders. The original
// code is the true version and the new code is the false version.
Value *BranchVal = LIC;
- if (Val->getType() != Type::Int1Ty || !isa<ConstantInt>(Val))
+ if (!isa<ConstantInt>(Val) || Val->getType() != Type::Int1Ty)
BranchVal = new ICmpInst(ICmpInst::ICMP_EQ, LIC, Val, "tmp", InsertPt);
else if (Val != ConstantInt::getTrue())
// We want to enter the new loop when the condition is true.
Index: llvm/lib/Transforms/Scalar/ScalarReplAggregates.cpp
diff -u llvm/lib/Transforms/Scalar/ScalarReplAggregates.cpp:1.66 llvm/lib/Transforms/Scalar/ScalarReplAggregates.cpp:1.67
--- llvm/lib/Transforms/Scalar/ScalarReplAggregates.cpp:1.66 Sun Jan 14 20:27:26 2007
+++ llvm/lib/Transforms/Scalar/ScalarReplAggregates.cpp Fri Jan 19 15:13:56 2007
@@ -748,7 +748,7 @@
if (TotalBits != SrcSize) {
assert(TotalBits > SrcSize);
uint64_t Mask = ~(((1ULL << SrcSize)-1) << Offset);
- Mask = Mask & SV->getType()->getIntegerTypeMask();
+ Mask = Mask & cast<IntegerType>(SV->getType())->getBitMask();
Old = BinaryOperator::createAnd(Old,
ConstantInt::get(Old->getType(), Mask),
Old->getName()+".mask", SI);
More information about the llvm-commits
mailing list