[IRCE][NFC] Add no wrap flags to no-wrapping SCEV calculation

[mkazantsev]

Summary

In a lambda where we expect to have result within bounds, add respective nsw/nuw flags to
help SCEV just in case if it fails to figure them out on its own.

[anna]

lgtm

llvm/trunk/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

if (IsLatchSigned) {
       // So, if Y is positive, we substract Y safely.
       //   Rule 1: Y > 0 ---> Y.
       // If 0 <= -Y <= (SINT_MAX - X), we substract Y safely.
       //   Rule 2: Y >=s (X - SINT_MAX) ---> Y.
       // If 0 <= (SINT_MAX - X) < -Y, we can only substract (X - SINT_MAX).
       //   Rule 3: Y <s (X - SINT_MAX) ---> (X - SINT_MAX).
       // It gives us smax(Y, X - SINT_MAX) to substract in all cases.
       const SCEV *XMinusSIntMax = SE.getMinusSCEV(X, SIntMax);
-      return SE.getMinusSCEV(X, SE.getSMaxExpr(Y, XMinusSIntMax));
+      return SE.getMinusSCEV(X, SE.getSMaxExpr(Y, XMinusSIntMax),
+                             SCEV::FlagNSW);
     } else
       // X is a number from unsigned range, Y is interpreted as signed.
       // Even if Y is SINT_MIN, (X - Y) does not reach UINT_MAX. So the only
       // thing we should care about is that we didn't cross zero.
       // So, if Y is negative, we substract Y safely.
       //   Rule 1: Y <s 0 ---> Y.
       // If 0 <= Y <= X, we substract Y safely.
       //   Rule 2: Y <=s X ---> Y.
       // If 0 <= X < Y, we should stop at 0 and can only substract X.
       //   Rule 3: Y >s X ---> X.
       // It gives us smin(X, Y) to substract in all cases.
-      return SE.getMinusSCEV(X, SE.getSMinExpr(X, Y));
+      return SE.getMinusSCEV(X, SE.getSMinExpr(X, Y), SCEV::FlagNUW);
   };
   const SCEV *M = SE.getMinusSCEV(C, A);
   const SCEV *Zero = SE.getZero(M->getType());
   const SCEV *Begin = ClampedSubstract(Zero, M);
   const SCEV *L = nullptr;
 
   // We strengthen "0 <= I" to "0 <= I < INT_SMAX" and "I < L" to "0 <= I < L".
   // We can potentially do much better here.