[llvm-commits] [llvm] r71284 - in /llvm/trunk: lib/Analysis/ScalarEvolution.cpp test/Analysis/ScalarEvolution/div-overflow.ll

[Dan Gohman]

Author: djg
Date: Fri May  8 18:11:16 2009
New Revision: 71284

URL: http://llvm.org/viewvc/llvm-project?rev=71284&view=rev
Log:
Fix bogus overflow checks by replacing them with actual
overflow checks.

Added:
    llvm/trunk/test/Analysis/ScalarEvolution/div-overflow.ll
Modified:
    llvm/trunk/lib/Analysis/ScalarEvolution.cpp

Modified: llvm/trunk/lib/Analysis/ScalarEvolution.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ScalarEvolution.cpp?rev=71284&r1=71283&r2=71284&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/ScalarEvolution.cpp (original)
+++ llvm/trunk/lib/Analysis/ScalarEvolution.cpp Fri May  8 18:11:16 2009
@@ -1381,29 +1381,39 @@
             dyn_cast<SCEVConstant>(AR->getStepRecurrence(*this)))
         if (!Step->getValue()->getValue()
               .urem(RHSC->getValue()->getValue()) &&
-            getTruncateExpr(getZeroExtendExpr(AR, ExtTy), Ty) == AR) {
+            getZeroExtendExpr(AR, ExtTy) ==
+            getAddRecExpr(getZeroExtendExpr(AR->getStart(), ExtTy),
+                          getZeroExtendExpr(Step, ExtTy),
+                          AR->getLoop())) {
           std::vector<SCEVHandle> Operands;
           for (unsigned i = 0, e = AR->getNumOperands(); i != e; ++i)
             Operands.push_back(getUDivExpr(AR->getOperand(i), RHS));
           return getAddRecExpr(Operands, AR->getLoop());
         }
     // (A*B)/C --> A*(B/C) if safe and B/C can be folded.
-    if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(LHS))
-      if (getTruncateExpr(getZeroExtendExpr(M, ExtTy), Ty) == M)
+    if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(LHS)) {
+      std::vector<SCEVHandle> Operands;
+      for (unsigned i = 0, e = M->getNumOperands(); i != e; ++i)
+        Operands.push_back(getZeroExtendExpr(M->getOperand(i), ExtTy));
+      if (getZeroExtendExpr(M, ExtTy) == getMulExpr(Operands))
         // Find an operand that's safely divisible.
         for (unsigned i = 0, e = M->getNumOperands(); i != e; ++i) {
           SCEVHandle Op = M->getOperand(i);
           SCEVHandle Div = getUDivExpr(Op, RHSC);
           if (!isa<SCEVUDivExpr>(Div) && getMulExpr(Div, RHSC) == Op) {
-            std::vector<SCEVHandle> Operands = M->getOperands();
+            Operands = M->getOperands();
             Operands[i] = Div;
             return getMulExpr(Operands);
           }
         }
+    }
     // (A+B)/C --> (A/C + B/C) if safe and A/C and B/C can be folded.
-    if (const SCEVAddRecExpr *A = dyn_cast<SCEVAddRecExpr>(LHS))
-      if (getTruncateExpr(getZeroExtendExpr(A, ExtTy), Ty) == A) {
-        std::vector<SCEVHandle> Operands;
+    if (const SCEVAddRecExpr *A = dyn_cast<SCEVAddRecExpr>(LHS)) {
+      std::vector<SCEVHandle> Operands;
+      for (unsigned i = 0, e = A->getNumOperands(); i != e; ++i)
+        Operands.push_back(getZeroExtendExpr(A->getOperand(i), ExtTy));
+      if (getZeroExtendExpr(A, ExtTy) == getAddExpr(Operands)) {
+        Operands.clear();
         for (unsigned i = 0, e = A->getNumOperands(); i != e; ++i) {
           SCEVHandle Op = getUDivExpr(A->getOperand(i), RHS);
           if (isa<SCEVUDivExpr>(Op) || getMulExpr(Op, RHS) != A->getOperand(i))
@@ -1413,6 +1423,7 @@
         if (Operands.size() == A->getNumOperands())
           return getAddExpr(Operands);
       }
+    }
 
     // Fold if both operands are constant.
     if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {

Added: llvm/trunk/test/Analysis/ScalarEvolution/div-overflow.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/ScalarEvolution/div-overflow.ll?rev=71284&view=auto

==============================================================================
--- llvm/trunk/test/Analysis/ScalarEvolution/div-overflow.ll (added)
+++ llvm/trunk/test/Analysis/ScalarEvolution/div-overflow.ll Fri May  8 18:11:16 2009
@@ -0,0 +1,10 @@
+; RUN: llvm-as < %s | opt -scalar-evolution -analyze -disable-output \
+; RUN:  | grep {\\-->  ((-128 \\* %a) /u -128)}
+
+; Don't let ScalarEvolution fold this div away.
+
+define i8 @foo(i8 %a) {
+        %t0 = shl i8 %a, 7
+        %t1 = lshr i8 %t0, 7
+        ret i8 %t1
+}