[llvm-commits] [llvm] r143102 - in /llvm/trunk: lib/Analysis/ValueTracking.cpp test/Transforms/InstSimplify/compare.ll

[Bob Wilson]

Author: bwilson
Date: Thu Oct 27 10:47:25 2011
New Revision: 143102

URL: http://llvm.org/viewvc/llvm-project?rev=143102&view=rev
Log:
Revert Duncan's r143028 expression folding which appears to be the culprit
behind a compile failure on 483.xalancbmk.

Modified:
    llvm/trunk/lib/Analysis/ValueTracking.cpp
    llvm/trunk/test/Transforms/InstSimplify/compare.ll

Modified: llvm/trunk/lib/Analysis/ValueTracking.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ValueTracking.cpp?rev=143102&r1=143101&r2=143102&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/ValueTracking.cpp (original)
+++ llvm/trunk/lib/Analysis/ValueTracking.cpp Thu Oct 27 10:47:25 2011
@@ -201,36 +201,9 @@
     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 @@
     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 @@
   }
 
   // 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 @@
     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) &&

Modified: llvm/trunk/test/Transforms/InstSimplify/compare.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstSimplify/compare.ll?rev=143102&r1=143101&r2=143102&view=diff
==============================================================================
--- llvm/trunk/test/Transforms/InstSimplify/compare.ll (original)
+++ llvm/trunk/test/Transforms/InstSimplify/compare.ll Thu Oct 27 10:47:25 2011
@@ -323,34 +323,3 @@
   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
-}