RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-12-30 15:45:26 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert Duncan's r143028 expression folding which appears to be the culprit

Browse Source 
behind a compile failure on 483.xalancbmk.

llvm-svn: 143102
This commit is contained in:
Bob Wilson 2011-10-27 15:47:25 +00:00
parent 7e10fef545
commit 2ca603d9b7
2 changed files with 4 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
lib/Analysis/ValueTracking.cpp
View File

@ -201,36 +201,9 @@ void llvm::ComputeMaskedBits(Value *V, const APInt &Mask,
ComputeMaskedBits(I->getOperand(1), Mask2, KnownZero, KnownOne, TD,Depth+1);
ComputeMaskedBits(I->getOperand(0), Mask2, KnownZero2, KnownOne2, TD,
Depth+1);
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
bool isKnownNegative = false;
bool isKnownNonNegative = false;
// If the multiplication is known not to overflow, compute the sign bit.
if (Mask.isNegative() && cast<BinaryOperator>(I)->hasNoSignedWrap()) {
Value *Op1 = I->getOperand(1), *Op2 = I->getOperand(0);
if (Op1 == Op2) {
// The product of a number with itself is non-negative.
isKnownNonNegative = true;
} else {
bool isKnownNonNegative1 = KnownZero.isNegative();
bool isKnownNonNegative2 = KnownZero2.isNegative();
bool isKnownNegative1 = KnownOne.isNegative();
bool isKnownNegative2 = KnownOne2.isNegative();
// The product of two numbers with the same sign is non-negative.
isKnownNonNegative = (isKnownNegative1 && isKnownNegative2) ||
(isKnownNonNegative1 && isKnownNonNegative2);
// The product of a negative number and a non-negative number is either
// negative or zero.
isKnownNegative = (isKnownNegative1 && isKnownNonNegative2 &&
isKnownNonZero(Op2, TD, Depth)) ||
(isKnownNegative2 && isKnownNonNegative1 &&
isKnownNonZero(Op1, TD, Depth));
assert(!(isKnownNegative && isKnownNonNegative) &&
"Sign bit both zero and one?");
}
}
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
// If low bits are zero in either operand, output low known-0 bits.
// Also compute a conserative estimate for high known-0 bits.
// More trickiness is possible, but this is sufficient for the
@ -247,12 +220,6 @@ void llvm::ComputeMaskedBits(Value *V, const APInt &Mask,
KnownZero = APInt::getLowBitsSet(BitWidth, TrailZ) |
APInt::getHighBitsSet(BitWidth, LeadZ);
KnownZero &= Mask;
if (isKnownNonNegative)
KnownZero.setBit(BitWidth - 1);
else if (isKnownNegative)
KnownOne.setBit(BitWidth - 1);
return;
}
case Instruction::UDiv: {
@ -817,7 +784,7 @@ bool llvm::isKnownNonZero(Value *V, const TargetData *TD, unsigned Depth) {
}
// The remaining tests are all recursive, so bail out if we hit the limit.
if (Depth++ >= MaxDepth)
if (Depth++ == MaxDepth)
return false;
unsigned BitWidth = getBitWidth(V->getType(), TD);
@ -901,15 +868,6 @@ bool llvm::isKnownNonZero(Value *V, const TargetData *TD, unsigned Depth) {
if (YKnownNonNegative && isPowerOfTwo(X, TD, /*OrZero*/false, Depth))
return true;
}
// X * Y.
else if (match(V, m_Mul(m_Value(X), m_Value(Y)))) {
BinaryOperator *BO = cast<BinaryOperator>(V);
// If X and Y are non-zero then so is X * Y as long as the multiplication
// does not overflow.
if ((BO->hasNoSignedWrap() || BO->hasNoUnsignedWrap()) &&
isKnownNonZero(X, TD, Depth) && isKnownNonZero(Y, TD, Depth))
return true;
}
// (C ? X : Y) != 0 if X != 0 and Y != 0.
else if (SelectInst *SI = dyn_cast<SelectInst>(V)) {
if (isKnownNonZero(SI->getTrueValue(), TD, Depth) &&

31
test/Transforms/InstSimplify/compare.ll
View File

@ -323,34 +323,3 @@ define i1 @and1(i32 %X) {
ret i1 %B
; CHECK: ret i1 false
}
define i1 @mul1(i32 %X) {
; CHECK: @mul1
; Square of a non-zero number is non-zero if there is no overflow.
%Y = or i32 %X, 1
%M = mul nuw i32 %Y, %Y
%C = icmp eq i32 %M, 0
ret i1 %C
; CHECK: ret i1 false
}
define i1 @mul2(i32 %X) {
; CHECK: @mul2
; Square of a non-zero number is positive if there is no signed overflow.
%Y = or i32 %X, 1
%M = mul nsw i32 %Y, %Y
%C = icmp sgt i32 %M, 0
ret i1 %C
; CHECK: ret i1 true
}
define i1 @mul3(i32 %X, i32 %Y) {
; CHECK: @mul3
; Product of non-negative numbers is non-negative if there is no signed overflow.
%XX = mul nsw i32 %X, %X
%YY = mul nsw i32 %Y, %Y
%M = mul nsw i32 %XX, %YY
%C = icmp sge i32 %M, 0
ret i1 %C
; CHECK: ret i1 true
}