Index: lib/Analysis/ScalarEvolution.cpp
===================================================================
--- lib/Analysis/ScalarEvolution.cpp	(revision 60971)
+++ lib/Analysis/ScalarEvolution.cpp	(working copy)
@@ -2924,15 +2924,16 @@
   if (!R)
     return true;
 
-  if (isSigned)
-    return true;  // XXX: because we don't have an sdiv scev.
-
   // If negative, it wraps around every iteration, but we don't care about that.
   APInt S = SC->getValue()->getValue().abs();
 
-  APInt Dist = APInt::getMaxValue(R->getValue()->getBitWidth()) -
-               R->getValue()->getValue();
+  uint32_t Width = R->getValue()->getBitWidth();
+  APInt Dist = (isSigned ? APInt::getSignedMaxValue(Width)
+                         : APInt::getMaxValue(Width))
+               - R->getValue()->getValue();
 
+  // Because we're looking at distance, we perform an unsigned comparison,
+  // regardless of the sign of the computation.
   if (trueWhenEqual)
     return !S.ult(Dist);
   else
@@ -2961,24 +2962,15 @@
     // m.  So, we count the number of iterations in which {n,+,s} < m is true.
     // Note that we cannot simply return max(m-n,0)/s because it's not safe to
     // treat m-n as signed nor unsigned due to overflow possibility.
+    //
+    // Assuming that the loop will run at least once, we know that it will
+    // run (m-n)/s times.
 
     // First, we get the value of the LHS in the first iteration: n
     SCEVHandle Start = AddRec->getOperand(0);
 
     SCEVHandle One = SE.getIntegerSCEV(1, RHS->getType());
 
-    // Assuming that the loop will run at least once, we know that it will
-    // run (m-n)/s times.
-    SCEVHandle End = RHS;
-
-    if (!executesAtLeastOnce(L, isSigned, trueWhenEqual,
-                             SE.getMinusSCEV(Start, One), RHS)) {
-      // If not, we get the value of the LHS in the first iteration in which
-      // the above condition doesn't hold.  This equals to max(m,n).
-      End = isSigned ? SE.getSMaxExpr(RHS, Start)
-                     : SE.getUMaxExpr(RHS, Start);
-    }
-
     // If the expression is less-than-or-equal to, we need to extend the
     // loop by one iteration.
     //
@@ -2986,17 +2978,24 @@
     // might not divide cleanly. For example, if you have {2,+,5} u< 10 the
     // division would equal one, but the loop runs twice putting the
     // induction variable at 12.
-
+    SCEVHandle End = SE.getAddExpr(RHS, Stride);
     if (!trueWhenEqual)
-      // (Stride - 1) is correct only because we know it's unsigned.
-      // What we really want is to decrease the magnitude of Stride by one.
-      Start = SE.getMinusSCEV(Start, SE.getMinusSCEV(Stride, One));
-    else
-      Start = SE.getMinusSCEV(Start, Stride);
+      End = SE.getMinusSCEV(End, One);
 
+    if (!executesAtLeastOnce(L, isSigned, trueWhenEqual,
+                             SE.getMinusSCEV(Start, One), RHS)) {
+      // If not, we get the value of the LHS in the first iteration in which
+      // the above condition doesn't hold.  This equals to max(m,n).
+      End = isSigned ? SE.getSMaxExpr(End, Start)
+                     : SE.getUMaxExpr(End, Start);
+    }
+
     // Finally, we subtract these two values to get the number of times the
-    // backedge is executed: max(m,n)-n.
-    return SE.getUDivExpr(SE.getMinusSCEV(End, Start), Stride);
+    // backedge is executed: (max(m,n)-n)/s.
+    if (isSigned)
+      return SE.getSDivExpr(SE.getMinusSCEV(End, Start), Stride);
+    else
+      return SE.getUDivExpr(SE.getMinusSCEV(End, Start), Stride);
   }
 
   return UnknownValue;
Index: test/Analysis/ScalarEvolution/2008-12-08-FiniteSGE.ll
===================================================================
--- test/Analysis/ScalarEvolution/2008-12-08-FiniteSGE.ll	(revision 60971)
+++ test/Analysis/ScalarEvolution/2008-12-08-FiniteSGE.ll	(working copy)
@@ -1,5 +1,4 @@
 ; RUN: llvm-as < %s | opt -analyze -scalar-evolution | grep {255 iterations}
-; XFAIL: *
 
 define i32 @foo(i32 %x, i32 %y, i32* %lam, i32* %alp) nounwind {
 bb1.thread:
Index: test/Analysis/ScalarEvolution/2008-12-11-SMaxOverflow.ll
===================================================================
--- test/Analysis/ScalarEvolution/2008-12-11-SMaxOverflow.ll	(revision 60971)
+++ test/Analysis/ScalarEvolution/2008-12-11-SMaxOverflow.ll	(working copy)
@@ -1,5 +1,4 @@
 ; RUN: llvm-as < %s | opt -analyze -scalar-evolution | grep {0 smax}
-; XFAIL: *
 
 define i32 @f(i32 %c.idx.val) {
 
