diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -4788,7 +4788,10 @@
     const SCEV *Result = Expr;
     bool InvariantF = SE.isLoopInvariant(Expr, L);
 
-    if (!InvariantF) {
+    // FIXME: while SCEVUnknown was originally created for an opaque IR Value
+    //        which was an Instruction, later said Values was RAUW'd
+    //        by a constant integer. Are we missing an invalidation?
+    if (!InvariantF && isa<Instruction>(Expr->getValue())) {
       Instruction *I = cast<Instruction>(Expr->getValue());
       switch (I->getOpcode()) {
       case Instruction::Select: {
@@ -6029,23 +6032,28 @@
 
 const SCEV *ScalarEvolution::createNodeForSelectOrPHIViaUMinSeq(
     Value *V, Value *Cond, Value *TrueVal, Value *FalseVal) {
-  // For now, only deal with i1-typed `select`s.
-  if (!V->getType()->isIntegerTy(1) || !Cond->getType()->isIntegerTy(1) ||
-      !TrueVal->getType()->isIntegerTy(1) ||
-      !FalseVal->getType()->isIntegerTy(1))
+  assert(V->getType() == TrueVal->getType() &&
+         TrueVal->getType() == FalseVal->getType() &&
+         "Expected the type of V and of the operands to match.");
+
+  // For now, only deal with integer-typed `select`s.
+  if (!V->getType()->isIntegerTy() || !Cond->getType()->isIntegerTy(1))
     return getUnknown(V);
 
-  // i1 cond ? i1 x : i1 C  -->  C + (i1  cond ? (i1 x - i1 C) : i1 0)
-  //                        -->  C + (umin_seq  cond, x - C)
+  // i1 cond ? iN x : iN C  -->  C + (i1  cond ? (iN x - iN C) : iN 0)
+  //                        -->  C + (umin_seq  (sext   cond), x - C)
   //
-  // i1 cond ? i1 C : i1 x  -->  C + (i1  cond ? i1 0 : (i1 x - i1 C))
-  //                        -->  C + (i1 ~cond ? (i1 x - i1 C) : i1 0)
-  //                        -->  C + (umin_seq ~cond, x - C)
+  // i1 cond ? iN C : iN x  -->  C + (i1  cond ? iN 0 : (iN x - iN C))
+  //                        -->  C + (i1 ~cond ? (iN x - iN C) : iN 0)
+  //                        -->  C + (umin_seq  (sext ~cond), x - C)
+  //                        -->  C + (umin_seq ~(sext  cond), x - C)
   if (isa<ConstantInt>(TrueVal) || isa<ConstantInt>(FalseVal)) {
     const SCEV *CondExpr = getSCEV(Cond);
     const SCEV *TrueExpr = getSCEV(TrueVal);
     const SCEV *FalseExpr = getSCEV(FalseVal);
     const SCEV *X, *C;
+    if (getTypeSizeInBits(V->getType()) > getTypeSizeInBits(Cond->getType()))
+      CondExpr = getSignExtendExpr(CondExpr, V->getType());
     if (isa<ConstantInt>(TrueVal)) {
       CondExpr = getNotSCEV(CondExpr);
       X = FalseExpr;
diff --git a/llvm/test/Analysis/ScalarEvolution/increasing-or-decreasing-iv.ll b/llvm/test/Analysis/ScalarEvolution/increasing-or-decreasing-iv.ll
--- a/llvm/test/Analysis/ScalarEvolution/increasing-or-decreasing-iv.ll
+++ b/llvm/test/Analysis/ScalarEvolution/increasing-or-decreasing-iv.ll
@@ -5,15 +5,15 @@
 ; CHECK-LABEL: 'f0'
 ; CHECK-NEXT:  Classifying expressions for: @f0
 ; CHECK-NEXT:    %start = select i1 %c, i32 127, i32 0
-; CHECK-NEXT:    --> %start U: [0,128) S: [0,128)
+; CHECK-NEXT:    --> (127 + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) U: [127,1) S: [127,1)
 ; CHECK-NEXT:    %step = select i1 %c, i32 -1, i32 1
-; CHECK-NEXT:    --> %step U: [1,0) S: [-2,2)
+; CHECK-NEXT:    --> (-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw> U: [-1,2) S: [-1,2)
 ; CHECK-NEXT:    %loop.iv = phi i32 [ 0, %entry ], [ %loop.iv.inc, %loop ]
 ; CHECK-NEXT:    --> {0,+,1}<%loop> U: [0,128) S: [0,128) Exits: 127 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv = phi i32 [ %start, %entry ], [ %iv.next, %loop ]
-; CHECK-NEXT:    --> {%start,+,%step}<%loop> U: [0,128) S: [0,128) Exits: ((127 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(127 + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: ((127 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.next = add i32 %iv, %step
-; CHECK-NEXT:    --> {(%step + %start),+,%step}<%loop> U: [-256,256) S: [-256,256) Exits: ((128 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(126 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (-1 + (128 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %loop.iv.inc = add i32 %loop.iv, 1
 ; CHECK-NEXT:    --> {1,+,1}<%loop> U: [1,129) S: [1,129) Exits: 128 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @f0
@@ -44,43 +44,43 @@
 ; CHECK-LABEL: 'f1'
 ; CHECK-NEXT:  Classifying expressions for: @f1
 ; CHECK-NEXT:    %start = select i1 %c, i32 120, i32 0
-; CHECK-NEXT:    --> %start U: [0,121) S: [0,121)
+; CHECK-NEXT:    --> (120 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) U: [120,1) S: [120,1)
 ; CHECK-NEXT:    %step = select i1 %c, i32 -8, i32 8
-; CHECK-NEXT:    --> %step U: [8,-7) S: [-16,16)
+; CHECK-NEXT:    --> (-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw> U: [-8,9) S: [-8,9)
 ; CHECK-NEXT:    %loop.iv = phi i32 [ 0, %entry ], [ %loop.iv.inc, %loop ]
 ; CHECK-NEXT:    --> {0,+,1}<%loop> U: [0,16) S: [0,16) Exits: 15 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv = phi i32 [ %start, %entry ], [ %iv.next, %loop ]
-; CHECK-NEXT:    --> {%start,+,%step}<%loop> U: [0,121) S: [0,121) Exits: ((15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(120 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: ((15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.1 = add i32 %iv, 1
-; CHECK-NEXT:    --> {(1 + %start)<nuw><nsw>,+,%step}<%loop> U: [1,122) S: [1,122) Exits: (1 + (15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(121 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (1 + (15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.2 = add i32 %iv, 2
-; CHECK-NEXT:    --> {(2 + %start)<nuw><nsw>,+,%step}<%loop> U: [2,123) S: [2,123) Exits: (2 + (15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(122 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (2 + (15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.3 = add i32 %iv, 3
-; CHECK-NEXT:    --> {(3 + %start)<nuw><nsw>,+,%step}<%loop> U: [3,124) S: [3,124) Exits: (3 + (15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(123 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (3 + (15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.4 = add i32 %iv, 4
-; CHECK-NEXT:    --> {(4 + %start)<nuw><nsw>,+,%step}<%loop> U: [4,125) S: [4,125) Exits: (4 + (15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(124 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (4 + (15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.5 = add i32 %iv, 5
-; CHECK-NEXT:    --> {(5 + %start)<nuw><nsw>,+,%step}<%loop> U: [5,126) S: [5,126) Exits: (5 + (15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(125 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (5 + (15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.6 = add i32 %iv, 6
-; CHECK-NEXT:    --> {(6 + %start)<nuw><nsw>,+,%step}<%loop> U: [6,127) S: [6,127) Exits: (6 + (15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(126 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (6 + (15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.7 = add i32 %iv, 7
-; CHECK-NEXT:    --> {(7 + %start)<nuw><nsw>,+,%step}<%loop> U: [7,128) S: [7,128) Exits: (7 + (15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(127 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (7 + (15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.m1 = sub i32 %iv, 1
-; CHECK-NEXT:    --> {(-1 + %start)<nsw>,+,%step}<%loop> U: [-1,120) S: [-1,120) Exits: (-1 + (15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(119 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw>,+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (-1 + (15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.m2 = sub i32 %iv, 2
-; CHECK-NEXT:    --> {(-2 + %start)<nsw>,+,%step}<%loop> U: [0,-1) S: [-2,119) Exits: (-2 + (15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(118 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw>,+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (-2 + (15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.m3 = sub i32 %iv, 3
-; CHECK-NEXT:    --> {(-3 + %start)<nsw>,+,%step}<%loop> U: [-3,118) S: [-3,118) Exits: (-3 + (15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(117 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw>,+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (-3 + (15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.m4 = sub i32 %iv, 4
-; CHECK-NEXT:    --> {(-4 + %start)<nsw>,+,%step}<%loop> U: [0,-3) S: [-4,117) Exits: (-4 + (15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(116 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw>,+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (-4 + (15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.m5 = sub i32 %iv, 5
-; CHECK-NEXT:    --> {(-5 + %start)<nsw>,+,%step}<%loop> U: [-5,116) S: [-5,116) Exits: (-5 + (15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(115 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw>,+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (-5 + (15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.m6 = sub i32 %iv, 6
-; CHECK-NEXT:    --> {(-6 + %start)<nsw>,+,%step}<%loop> U: [0,-1) S: [-6,115) Exits: (-6 + (15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(114 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw>,+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (-6 + (15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.m7 = sub i32 %iv, 7
-; CHECK-NEXT:    --> {(-7 + %start)<nsw>,+,%step}<%loop> U: [-7,114) S: [-7,114) Exits: (-7 + (15 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(113 + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw>,+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (-7 + (15 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.next = add i32 %iv, %step
-; CHECK-NEXT:    --> {(%step + %start),+,%step}<%loop> U: [0,-7) S: [-256,361) Exits: ((16 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(112 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-8 + (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (-8 + (16 * (16 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-120 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %loop.iv.inc = add i32 %loop.iv, 1
 ; CHECK-NEXT:    --> {1,+,1}<%loop> U: [1,17) S: [1,17) Exits: 16 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @f1
@@ -130,17 +130,17 @@
 ; CHECK-LABEL: 'f2'
 ; CHECK-NEXT:  Classifying expressions for: @f2
 ; CHECK-NEXT:    %start = select i1 %c, i32 127, i32 0
-; CHECK-NEXT:    --> %start U: [0,128) S: [0,128)
+; CHECK-NEXT:    --> (127 + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) U: [127,1) S: [127,1)
 ; CHECK-NEXT:    %step = select i1 %c, i32 -1, i32 1
-; CHECK-NEXT:    --> %step U: [1,0) S: [-2,2)
+; CHECK-NEXT:    --> (-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw> U: [-1,2) S: [-1,2)
 ; CHECK-NEXT:    %loop.iv = phi i32 [ 0, %entry ], [ %loop.iv.inc, %loop ]
 ; CHECK-NEXT:    --> {0,+,1}<%loop> U: [0,128) S: [0,128) Exits: 127 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv = phi i32 [ %start, %entry ], [ %iv.next, %loop ]
-; CHECK-NEXT:    --> {%start,+,%step}<%loop> U: [0,128) S: [0,128) Exits: ((127 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(127 + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: ((127 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.sext = sext i32 %iv to i64
-; CHECK-NEXT:    --> {(zext i32 %start to i64),+,(sext i32 %step to i64)}<nsw><%loop> U: [0,128) S: [0,128) Exits: ((zext i32 %start to i64) + (127 * (sext i32 %step to i64))<nsw>) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> (sext i32 {(127 + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) Exits: (sext i32 ((127 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) to i64) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.next = add i32 %iv, %step
-; CHECK-NEXT:    --> {(%step + %start),+,%step}<nw><%loop> U: [-256,256) S: [-256,256) Exits: ((128 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(126 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (-1 + (128 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %loop.iv.inc = add i32 %loop.iv, 1
 ; CHECK-NEXT:    --> {1,+,1}<%loop> U: [1,129) S: [1,129) Exits: 128 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @f2
@@ -172,17 +172,17 @@
 ; CHECK-LABEL: 'f3'
 ; CHECK-NEXT:  Classifying expressions for: @f3
 ; CHECK-NEXT:    %start = select i1 %c, i16 1000, i16 0
-; CHECK-NEXT:    --> %start U: [0,1001) S: [0,1001)
+; CHECK-NEXT:    --> (1000 + (-1000 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>)) U: [1000,1) S: [1000,1)
 ; CHECK-NEXT:    %step = select i1 %c, i16 1, i16 509
-; CHECK-NEXT:    --> %step U: [1,510) S: [1,510)
+; CHECK-NEXT:    --> (1 + (508 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>))<nuw><nsw> U: [1,510) S: [1,510)
 ; CHECK-NEXT:    %loop.iv = phi i16 [ 0, %entry ], [ %loop.iv.inc, %loop ]
 ; CHECK-NEXT:    --> {0,+,1}<%loop> U: [0,128) S: [0,128) Exits: 127 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv = phi i16 [ %start, %entry ], [ %iv.next, %loop ]
-; CHECK-NEXT:    --> {%start,+,%step}<%loop> U: [0,-892) S: [0,-892) Exits: ((127 * %step)<nuw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(1000 + (-1000 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>)),+,(1 + (508 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>))<nuw><nsw>}<%loop> U: full-set S: full-set Exits: (1127 + (127 * (508 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>))<nuw> + (-1000 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.zext = zext i16 %iv to i64
-; CHECK-NEXT:    --> {(zext i16 %start to i64),+,(zext i16 %step to i64)}<nuw><%loop> U: [0,64644) S: [0,64644) Exits: ((zext i16 %start to i64) + (127 * (zext i16 %step to i64))<nuw><nsw>) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> (zext i16 {(1000 + (-1000 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>)),+,(1 + (508 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>))<nuw><nsw>}<%loop> to i64) U: [0,65536) S: [0,65536) Exits: (zext i16 (1127 + (127 * (508 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>))<nuw> + (-1000 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>)) to i64) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.next = add i16 %iv, %step
-; CHECK-NEXT:    --> {(%step + %start),+,%step}<nw><%loop> U: full-set S: full-set Exits: ((128 * %step)<nuw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(1001 + (508 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>) + (-1000 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>)),+,(1 + (508 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>))<nuw><nsw>}<%loop> U: full-set S: full-set Exits: (1128 + (128 * (508 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>))<nuw> + (-1000 umin (-1 + (-1 * (sext i1 %c to i16))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %loop.iv.inc = add i16 %loop.iv, 1
 ; CHECK-NEXT:    --> {1,+,1}<%loop> U: [1,129) S: [1,129) Exits: 128 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @f3
@@ -221,17 +221,17 @@
 ; CHECK-LABEL: 'f4'
 ; CHECK-NEXT:  Classifying expressions for: @f4
 ; CHECK-NEXT:    %start = select i1 %c, i32 127, i32 0
-; CHECK-NEXT:    --> %start U: [0,128) S: [0,128)
+; CHECK-NEXT:    --> (127 + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) U: [127,1) S: [127,1)
 ; CHECK-NEXT:    %step = select i1 %c, i32 -1, i32 1
-; CHECK-NEXT:    --> %step U: [1,0) S: [-2,2)
+; CHECK-NEXT:    --> (-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw> U: [-1,2) S: [-1,2)
 ; CHECK-NEXT:    %loop.iv = phi i32 [ 0, %entry ], [ %loop.iv.inc, %loop ]
 ; CHECK-NEXT:    --> {0,+,1}<%loop> U: [0,128) S: [0,128) Exits: 127 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv = phi i32 [ %start, %entry ], [ %iv.next, %loop ]
-; CHECK-NEXT:    --> {%start,+,%step}<%loop> U: [0,128) S: [0,128) Exits: ((127 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(127 + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: ((127 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.trunc = trunc i32 %iv to i16
-; CHECK-NEXT:    --> {(trunc i32 %start to i16),+,(trunc i32 %step to i16)}<%loop> U: full-set S: full-set Exits: ((trunc i32 %start to i16) + (127 * (trunc i32 %step to i16))<nsw>) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(127 + (trunc i32 (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16)),+,(-1 + (trunc i32 (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16))<nsw>}<%loop> U: full-set S: full-set Exits: ((trunc i32 (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16) + (127 * (trunc i32 (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16))<nuw><nsw>) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.next = add i32 %iv, %step
-; CHECK-NEXT:    --> {(%step + %start),+,%step}<%loop> U: [-256,256) S: [-256,256) Exits: ((128 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(126 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (-1 + (128 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %loop.iv.inc = add i32 %loop.iv, 1
 ; CHECK-NEXT:    --> {1,+,1}<%loop> U: [1,129) S: [1,129) Exits: 128 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @f4
@@ -269,17 +269,17 @@
 ; CHECK-LABEL: 'f5'
 ; CHECK-NEXT:  Classifying expressions for: @f5
 ; CHECK-NEXT:    %start = select i1 %c, i32 127, i32 0
-; CHECK-NEXT:    --> %start U: [0,128) S: [0,128)
+; CHECK-NEXT:    --> (127 + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) U: [127,1) S: [127,1)
 ; CHECK-NEXT:    %step = select i1 %c, i32 -1, i32 1
-; CHECK-NEXT:    --> %step U: [1,0) S: [-2,2)
+; CHECK-NEXT:    --> (-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw> U: [-1,2) S: [-1,2)
 ; CHECK-NEXT:    %loop.iv = phi i16 [ 0, %entry ], [ %loop.iv.inc, %loop ]
 ; CHECK-NEXT:    --> {0,+,1}<%loop> U: [0,128) S: [0,128) Exits: 127 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv = phi i32 [ %start, %entry ], [ %iv.next, %loop ]
-; CHECK-NEXT:    --> {%start,+,%step}<%loop> U: [0,128) S: [0,128) Exits: ((127 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(127 + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: ((127 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.trunc = trunc i32 %iv to i16
-; CHECK-NEXT:    --> {(trunc i32 %start to i16),+,(trunc i32 %step to i16)}<%loop> U: [0,128) S: [0,128) Exits: ((trunc i32 %start to i16) + (127 * (trunc i32 %step to i16))<nsw>) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(127 + (trunc i32 (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16)),+,(-1 + (trunc i32 (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16))<nsw>}<%loop> U: full-set S: full-set Exits: ((trunc i32 (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16) + (127 * (trunc i32 (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16))<nuw><nsw>) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.next = add i32 %iv, %step
-; CHECK-NEXT:    --> {(%step + %start),+,%step}<%loop> U: [-256,256) S: [-256,256) Exits: ((128 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(126 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (-1 + (128 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %loop.iv.inc = add i16 %loop.iv, 1
 ; CHECK-NEXT:    --> {1,+,1}<%loop> U: [1,129) S: [1,129) Exits: 128 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @f5
@@ -312,19 +312,19 @@
 ; CHECK-LABEL: 'f6'
 ; CHECK-NEXT:  Classifying expressions for: @f6
 ; CHECK-NEXT:    %start = select i1 %c, i32 127, i32 0
-; CHECK-NEXT:    --> %start U: [0,128) S: [0,128)
+; CHECK-NEXT:    --> (127 + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) U: [127,1) S: [127,1)
 ; CHECK-NEXT:    %step = select i1 %c, i32 -2, i32 0
-; CHECK-NEXT:    --> %step U: [0,-1) S: [-2,2)
+; CHECK-NEXT:    --> (-2 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw> U: [-2,1) S: [-2,1)
 ; CHECK-NEXT:    %loop.iv = phi i16 [ 0, %entry ], [ %loop.iv.inc, %loop ]
 ; CHECK-NEXT:    --> {0,+,1}<%loop> U: [0,128) S: [0,128) Exits: 127 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv = phi i32 [ %start, %entry ], [ %iv.next, %loop ]
-; CHECK-NEXT:    --> {%start,+,(1 + %step)<nuw><nsw>}<%loop> U: [0,128) S: [0,128) Exits: (127 + (127 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(127 + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: ((127 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %step.plus.one = add i32 %step, 1
-; CHECK-NEXT:    --> (1 + %step)<nuw><nsw> U: [1,0) S: [-1,3) Exits: (1 + %step)<nuw><nsw> LoopDispositions: { %loop: Invariant }
+; CHECK-NEXT:    --> (-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw> U: [-1,2) S: [-1,2) Exits: (-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw> LoopDispositions: { %loop: Invariant }
 ; CHECK-NEXT:    %iv.next = add i32 %iv, %step.plus.one
-; CHECK-NEXT:    --> {(1 + %step + %start),+,(1 + %step)<nuw><nsw>}<%loop> U: [-128,384) S: [-128,384) Exits: (128 + (128 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(126 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (-1 + (128 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.sext = sext i32 %iv to i64
-; CHECK-NEXT:    --> {(zext i32 %start to i64),+,(1 + (sext i32 %step to i64))<nuw><nsw>}<nsw><%loop> U: [0,128) S: [0,128) Exits: (127 + (zext i32 %start to i64) + (127 * (sext i32 %step to i64))<nsw>) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> (sext i32 {(127 + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) Exits: (sext i32 ((127 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) to i64) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %loop.iv.inc = add i16 %loop.iv, 1
 ; CHECK-NEXT:    --> {1,+,1}<%loop> U: [1,129) S: [1,129) Exits: 128 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @f6
@@ -358,21 +358,21 @@
 ; CHECK-LABEL: 'f7'
 ; CHECK-NEXT:  Classifying expressions for: @f7
 ; CHECK-NEXT:    %start = select i1 %c, i32 127, i32 0
-; CHECK-NEXT:    --> %start U: [0,128) S: [0,128)
+; CHECK-NEXT:    --> (127 + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) U: [127,1) S: [127,1)
 ; CHECK-NEXT:    %step = select i1 %c, i32 -1, i32 1
-; CHECK-NEXT:    --> %step U: [1,0) S: [-2,2)
+; CHECK-NEXT:    --> (-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw> U: [-1,2) S: [-1,2)
 ; CHECK-NEXT:    %loop.iv = phi i16 [ 0, %entry ], [ %loop.iv.inc, %loop ]
 ; CHECK-NEXT:    --> {0,+,1}<%loop> U: [0,128) S: [0,128) Exits: 127 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv = phi i32 [ %start, %entry ], [ %iv.next, %loop ]
-; CHECK-NEXT:    --> {%start,+,%step}<%loop> U: [0,128) S: [0,128) Exits: ((127 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(127 + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: ((127 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.trunc = trunc i32 %iv to i16
-; CHECK-NEXT:    --> {(trunc i32 %start to i16),+,(trunc i32 %step to i16)}<%loop> U: [0,128) S: [0,128) Exits: ((trunc i32 %start to i16) + (127 * (trunc i32 %step to i16))<nsw>) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(127 + (trunc i32 (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16)),+,(-1 + (trunc i32 (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16))<nsw>}<%loop> U: full-set S: full-set Exits: ((trunc i32 (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16) + (127 * (trunc i32 (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16))<nuw><nsw>) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.next = add i32 %iv, %step
-; CHECK-NEXT:    --> {(%step + %start),+,%step}<%loop> U: [-256,256) S: [-256,256) Exits: ((128 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(126 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<%loop> U: full-set S: full-set Exits: (-1 + (128 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.trunc.plus.one = add i16 %iv.trunc, 1
-; CHECK-NEXT:    --> {(1 + (trunc i32 %start to i16))<nuw><nsw>,+,(trunc i32 %step to i16)}<%loop> U: [1,129) S: [1,129) Exits: (1 + (trunc i32 %start to i16) + (127 * (trunc i32 %step to i16))<nsw>) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(128 + (trunc i32 (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16)),+,(-1 + (trunc i32 (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16))<nsw>}<%loop> U: full-set S: full-set Exits: (1 + (trunc i32 (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16) + (127 * (trunc i32 (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16))<nuw><nsw>) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.trunc.plus.two = add i16 %iv.trunc, 2
-; CHECK-NEXT:    --> {(2 + (trunc i32 %start to i16))<nuw><nsw>,+,(trunc i32 %step to i16)}<%loop> U: [2,130) S: [2,130) Exits: (2 + (trunc i32 %start to i16) + (127 * (trunc i32 %step to i16))<nsw>) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(129 + (trunc i32 (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16)),+,(-1 + (trunc i32 (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16))<nsw>}<%loop> U: full-set S: full-set Exits: (2 + (trunc i32 (-127 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16) + (127 * (trunc i32 (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i16))<nuw><nsw>) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %loop.iv.inc = add i16 %loop.iv, 1
 ; CHECK-NEXT:    --> {1,+,1}<%loop> U: [1,129) S: [1,129) Exits: 128 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @f7
diff --git a/llvm/test/Analysis/ScalarEvolution/logical-operations.ll b/llvm/test/Analysis/ScalarEvolution/logical-operations.ll
--- a/llvm/test/Analysis/ScalarEvolution/logical-operations.ll
+++ b/llvm/test/Analysis/ScalarEvolution/logical-operations.ll
@@ -191,7 +191,7 @@
 ; CHECK-LABEL: 'select_x_or_zero'
 ; CHECK-NEXT:  Classifying expressions for: @select_x_or_zero
 ; CHECK-NEXT:    %r = select i1 %c, i32 %x, i32 0
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> ((sext i1 %c to i32) umin_seq %x) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_zero
 ;
   %r = select i1 %c, i32 %x, i32 0
@@ -202,7 +202,7 @@
 ; CHECK-LABEL: 'select_zero_or_x'
 ; CHECK-NEXT:  Classifying expressions for: @select_zero_or_x
 ; CHECK-NEXT:    %r = select i1 %c, i32 0, i32 %x
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> ((-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw> umin_seq %x) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @select_zero_or_x
 ;
   %r = select i1 %c, i32 0, i32 %x
@@ -213,7 +213,7 @@
 ; CHECK-LABEL: 'select_x_or_allones'
 ; CHECK-NEXT:  Classifying expressions for: @select_x_or_allones
 ; CHECK-NEXT:    %r = select i1 %c, i32 %x, i32 -1
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> (-1 + ((sext i1 %c to i32) umin_seq (1 + %x))) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_allones
 ;
   %r = select i1 %c, i32 %x, i32 -1
@@ -224,7 +224,7 @@
 ; CHECK-LABEL: 'select_allones_or_x'
 ; CHECK-NEXT:  Classifying expressions for: @select_allones_or_x
 ; CHECK-NEXT:    %r = select i1 %c, i32 -1, i32 %x
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> (-1 + ((-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw> umin_seq (1 + %x))) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @select_allones_or_x
 ;
   %r = select i1 %c, i32 -1, i32 %x
@@ -235,7 +235,7 @@
 ; CHECK-LABEL: 'select_x_or_intmax'
 ; CHECK-NEXT:  Classifying expressions for: @select_x_or_intmax
 ; CHECK-NEXT:    %r = select i1 %c, i32 %x, i32 2147483647
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> (2147483647 + ((sext i1 %c to i32) umin_seq (-2147483647 + %x))) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_intmax
 ;
   %r = select i1 %c, i32 %x, i32 2147483647
@@ -246,7 +246,7 @@
 ; CHECK-LABEL: 'select_intmax_or_x'
 ; CHECK-NEXT:  Classifying expressions for: @select_intmax_or_x
 ; CHECK-NEXT:    %r = select i1 %c, i32 2147483647, i32 %x
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> (2147483647 + ((-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw> umin_seq (-2147483647 + %x))) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @select_intmax_or_x
 ;
   %r = select i1 %c, i32 2147483647, i32 %x
@@ -257,7 +257,7 @@
 ; CHECK-LABEL: 'select_x_or_intmin'
 ; CHECK-NEXT:  Classifying expressions for: @select_x_or_intmin
 ; CHECK-NEXT:    %r = select i1 %c, i32 %x, i32 -2147483648
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> (-2147483648 + ((sext i1 %c to i32) umin_seq (-2147483648 + %x))) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_intmin
 ;
   %r = select i1 %c, i32 %x, i32 -2147483648
@@ -268,7 +268,7 @@
 ; CHECK-LABEL: 'select_intmin_or_x'
 ; CHECK-NEXT:  Classifying expressions for: @select_intmin_or_x
 ; CHECK-NEXT:    %r = select i1 %c, i32 -2147483648, i32 %x
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> (-2147483648 + ((-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw> umin_seq (-2147483648 + %x))) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @select_intmin_or_x
 ;
   %r = select i1 %c, i32 -2147483648, i32 %x
@@ -279,7 +279,7 @@
 ; CHECK-LABEL: 'select_x_or_constant'
 ; CHECK-NEXT:  Classifying expressions for: @select_x_or_constant
 ; CHECK-NEXT:    %r = select i1 %c, i32 %x, i32 42
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> (42 + ((sext i1 %c to i32) umin_seq (-42 + %x))) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @select_x_or_constant
 ;
   %r = select i1 %c, i32 %x, i32 42
@@ -290,7 +290,7 @@
 ; CHECK-LABEL: 'select_constant_or_x'
 ; CHECK-NEXT:  Classifying expressions for: @select_constant_or_x
 ; CHECK-NEXT:    %r = select i1 %c, i32 42, i32 %y
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> (42 + ((-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw> umin_seq (-42 + %y))) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @select_constant_or_x
 ;
   %r = select i1 %c, i32 42, i32 %y
@@ -301,7 +301,7 @@
 ; CHECK-LABEL: 'select_between_constants'
 ; CHECK-NEXT:  Classifying expressions for: @select_between_constants
 ; CHECK-NEXT:    %r = select i1 %c, i32 42, i32 24
-; CHECK-NEXT:    --> %r U: [8,59) S: [8,59)
+; CHECK-NEXT:    --> (42 + (-18 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) U: [42,25) S: [42,25)
 ; CHECK-NEXT:  Determining loop execution counts for: @select_between_constants
 ;
   %r = select i1 %c, i32 42, i32 24
@@ -507,7 +507,7 @@
 ; CHECK-NEXT:    %umax = call i32 @llvm.umax.i32(i32 %y, i32 %x)
 ; CHECK-NEXT:    --> (%x umax %y) U: full-set S: full-set
 ; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umax
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> ((-1 + (-1 * (sext i1 %x.is.zero to i32))<nsw>)<nsw> umin_seq (%x umax %y)) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_wrongtype0
 ;
   %umax = call i32 @llvm.umax(i32 %y, i32 %x)
@@ -521,7 +521,7 @@
 ; CHECK-NEXT:    %smax = call i32 @llvm.smax.i32(i32 %y, i32 %x)
 ; CHECK-NEXT:    --> (%x smax %y) U: full-set S: full-set
 ; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %smax
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> ((-1 + (-1 * (sext i1 %x.is.zero to i32))<nsw>)<nsw> umin_seq (%x smax %y)) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_wrongtype1
 ;
   %smax = call i32 @llvm.smax(i32 %y, i32 %x)
@@ -535,7 +535,7 @@
 ; CHECK-NEXT:    %smin = call i32 @llvm.smin.i32(i32 %y, i32 %x)
 ; CHECK-NEXT:    --> (%x smin %y) U: full-set S: full-set
 ; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %smin
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> ((-1 + (-1 * (sext i1 %x.is.zero to i32))<nsw>)<nsw> umin_seq (%x smin %y)) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_wrongtype2
 ;
   %smin = call i32 @llvm.smin(i32 %y, i32 %x)
@@ -552,7 +552,7 @@
 ; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %umax, i32 %y)
 ; CHECK-NEXT:    --> ((%x umax %z) umin %y) U: full-set S: full-set
 ; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> ((-1 + (-1 * (sext i1 %x.is.zero to i32))<nsw>)<nsw> umin_seq ((%x umax %z) umin %y)) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_wrongtype3
 ;
   %umax = call i32 @llvm.umax(i32 %x, i32 %z)
@@ -744,7 +744,7 @@
 ; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %y, i32 %x)
 ; CHECK-NEXT:    --> ((sext i8 %x.narrow to i32) umin %y) U: full-set S: full-set
 ; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> ((-1 + (-1 * (sext i1 %x.is.zero to i32))<nsw>)<nsw> umin_seq ((sext i8 %x.narrow to i32) umin %y)) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_sext_in_umin
 ;
   %x = sext i8 %x.narrow to i32
@@ -762,7 +762,7 @@
 ; CHECK-NEXT:    %umin = call i8 @llvm.umin.i8(i8 %y, i8 %x)
 ; CHECK-NEXT:    --> (%x umin %y) U: full-set S: full-set
 ; CHECK-NEXT:    %r = select i1 %x.is.zero, i8 0, i8 %umin
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> ((-1 + (-1 * (sext i1 %x.is.zero to i8))<nsw>)<nsw> umin_seq (%x umin %y)) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_sext_in_iszero
 ;
   %x.wide = sext i8 %x to i32
@@ -780,7 +780,7 @@
 ; CHECK-NEXT:    %umin = sext i8 %umin.narrow to i32
 ; CHECK-NEXT:    --> (sext i8 (%x umin %y) to i32) U: [-128,128) S: [-128,128)
 ; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
-; CHECK-NEXT:    --> %r U: [-128,128) S: [-128,128)
+; CHECK-NEXT:    --> ((-1 + (-1 * (sext i1 %x.is.zero to i32))<nsw>)<nsw> umin_seq (sext i8 (%x umin %y) to i32)) U: [-128,128) S: [-128,128)
 ; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_sext_of_umin
 ;
   %umin.narrow = call i8 @llvm.umin.i8(i8 %y, i8 %x)
@@ -800,7 +800,7 @@
 ; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %y, i32 %x.zext)
 ; CHECK-NEXT:    --> ((zext i8 %x.narrow to i32) umin %y) U: [0,256) S: [0,256)
 ; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
-; CHECK-NEXT:    --> %r U: [0,256) S: [0,256)
+; CHECK-NEXT:    --> ((-1 + (-1 * (sext i1 %x.is.zero to i32))<nsw>)<nsw> umin_seq ((zext i8 %x.narrow to i32) umin %y)) U: [0,256) S: [0,256)
 ; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_zext_vs_sext
 ;
   %x.zext = zext i8 %x.narrow to i32
@@ -820,7 +820,7 @@
 ; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %y, i32 %x.sext)
 ; CHECK-NEXT:    --> ((sext i8 %x.narrow to i32) umin %y) U: full-set S: full-set
 ; CHECK-NEXT:    %r = select i1 %x.is.zero, i32 0, i32 %umin
-; CHECK-NEXT:    --> %r U: full-set S: full-set
+; CHECK-NEXT:    --> ((-1 + (-1 * (sext i1 %x.is.zero to i32))<nsw>)<nsw> umin_seq ((sext i8 %x.narrow to i32) umin %y)) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @umin_seq_x_y_sext_vs_zext
 ;
   %x.zext = zext i8 %x.narrow to i32
diff --git a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info-rewrite-expressions.ll b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info-rewrite-expressions.ll
--- a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info-rewrite-expressions.ll
+++ b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info-rewrite-expressions.ll
@@ -278,17 +278,15 @@
 ; CHECK-NEXT:    %N.ext = zext i32 %N to i64
 ; CHECK-NEXT:    --> (zext i32 %N to i64) U: [0,4294967296) S: [0,4294967296)
 ; CHECK-NEXT:    %init = phi i64 [ 2, %entry ], [ 4, %bb1 ]
-; CHECK-NEXT:    --> %init U: [2,5) S: [2,5)
+; CHECK-NEXT:    --> (4 + (-2 umin (-1 + (-1 * (sext i1 %c to i64))<nsw>)<nsw>)) U: [4,3) S: [4,3)
 ; CHECK-NEXT:    %iv = phi i64 [ %iv.next, %loop ], [ %init, %loop.ph ]
-; CHECK-NEXT:    --> {%init,+,2}<%loop> U: [2,17) S: [2,17) Exits: ((2 * ((14 + (-1 * %init)<nsw>)<nsw> /u 2))<nuw><nsw> + %init) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(4 + (-2 umin (-1 + (-1 * (sext i1 %c to i64))<nsw>)<nsw>)),+,2}<%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.next = add i64 %iv, 2
-; CHECK-NEXT:    --> {(2 + %init)<nuw><nsw>,+,2}<%loop> U: [4,19) S: [4,19) Exits: (2 + (2 * ((14 + (-1 * %init)<nsw>)<nsw> /u 2))<nuw><nsw> + %init) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(6 + (-2 umin (-1 + (-1 * (sext i1 %c to i64))<nsw>)<nsw>)),+,2}<%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @guard_pessimizes_analysis_step2
-; CHECK-NEXT:  Loop %loop: backedge-taken count is ((14 + (-1 * %init)<nsw>)<nsw> /u 2)
-; CHECK-NEXT:  Loop %loop: max backedge-taken count is 6
-; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((14 + (-1 * %init)<nsw>)<nsw> /u 2)
-; CHECK-NEXT:   Predicates:
-; CHECK:       Loop %loop: Trip multiple is 1
+; CHECK-NEXT:  Loop %loop: Unpredictable backedge-taken count.
+; CHECK-NEXT:  Loop %loop: Unpredictable max backedge-taken count.
+; CHECK-NEXT:  Loop %loop: Unpredictable predicated backedge-taken count.
 ;
 entry:
   %N.ext = zext i32 %N to i64
diff --git a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll
--- a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll
+++ b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll
@@ -826,15 +826,15 @@
 ; CHECK-LABEL: 'guard_pessimizes_analysis_step1'
 ; CHECK-NEXT:  Classifying expressions for: @guard_pessimizes_analysis_step1
 ; CHECK-NEXT:    %init = phi i32 [ 2, %entry ], [ 3, %bb1 ]
-; CHECK-NEXT:    --> %init U: [2,4) S: [2,4)
+; CHECK-NEXT:    --> (2 + (-1 * (sext i1 %c to i32))<nsw>)<nuw><nsw> U: [2,4) S: [2,4)
 ; CHECK-NEXT:    %iv = phi i32 [ %iv.next, %loop ], [ %init, %loop.ph ]
-; CHECK-NEXT:    --> {%init,+,1}<%loop> U: [2,11) S: [2,11) Exits: 9 LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(2 + (-1 * (sext i1 %c to i32))<nsw>)<nuw><nsw>,+,1}<%loop> U: [2,11) S: [2,11) Exits: 9 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.next = add i32 %iv, 1
-; CHECK-NEXT:    --> {(1 + %init)<nuw><nsw>,+,1}<%loop> U: [3,12) S: [3,12) Exits: 10 LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(3 + (-1 * (sext i1 %c to i32))<nsw>)<nuw><nsw>,+,1}<%loop> U: [3,12) S: [3,12) Exits: 10 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @guard_pessimizes_analysis_step1
-; CHECK-NEXT:  Loop %loop: backedge-taken count is (9 + (-1 * %init)<nsw>)<nsw>
+; CHECK-NEXT:  Loop %loop: backedge-taken count is (7 + (sext i1 %c to i32))<nsw>
 ; CHECK-NEXT:  Loop %loop: max backedge-taken count is 7
-; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is (9 + (-1 * %init)<nsw>)<nsw>
+; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is (7 + (sext i1 %c to i32))<nsw>
 ; CHECK-NEXT:   Predicates:
 ; CHECK:       Loop %loop: Trip multiple is 1
 ;
@@ -866,15 +866,15 @@
 ; CHECK-LABEL: 'guard_pessimizes_analysis_step2'
 ; CHECK-NEXT:  Classifying expressions for: @guard_pessimizes_analysis_step2
 ; CHECK-NEXT:    %init = phi i32 [ 2, %entry ], [ 3, %bb1 ]
-; CHECK-NEXT:    --> %init U: [2,4) S: [2,4)
+; CHECK-NEXT:    --> (2 + (-1 * (sext i1 %c to i32))<nsw>)<nuw><nsw> U: [2,4) S: [2,4)
 ; CHECK-NEXT:    %iv = phi i32 [ %iv.next, %loop ], [ %init, %loop.ph ]
-; CHECK-NEXT:    --> {%init,+,2}<nuw><nsw><%loop> U: [2,10) S: [2,10) Exits: ((2 * ((8 + (-1 * %init)<nsw>)<nsw> /u 2))<nuw><nsw> + %init) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(2 + (-1 * (sext i1 %c to i32))<nsw>)<nuw><nsw>,+,2}<nuw><nsw><%loop> U: [2,10) S: [2,10) Exits: (2 + (2 * ((6 + (sext i1 %c to i32))<nsw> /u 2))<nuw><nsw> + (-1 * (sext i1 %c to i32))<nsw>) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.next = add nuw nsw i32 %iv, 2
-; CHECK-NEXT:    --> {(2 + %init)<nuw><nsw>,+,2}<nuw><nsw><%loop> U: [4,12) S: [4,12) Exits: (2 + (2 * ((8 + (-1 * %init)<nsw>)<nsw> /u 2))<nuw><nsw> + %init) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(4 + (-1 * (sext i1 %c to i32))<nsw>)<nuw><nsw>,+,2}<nuw><nsw><%loop> U: [4,12) S: [4,12) Exits: (4 + (2 * ((6 + (sext i1 %c to i32))<nsw> /u 2))<nuw><nsw> + (-1 * (sext i1 %c to i32))<nsw>) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @guard_pessimizes_analysis_step2
-; CHECK-NEXT:  Loop %loop: backedge-taken count is ((8 + (-1 * %init)<nsw>)<nsw> /u 2)
+; CHECK-NEXT:  Loop %loop: backedge-taken count is ((6 + (sext i1 %c to i32))<nsw> /u 2)
 ; CHECK-NEXT:  Loop %loop: max backedge-taken count is 3
-; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((8 + (-1 * %init)<nsw>)<nsw> /u 2)
+; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((6 + (sext i1 %c to i32))<nsw> /u 2)
 ; CHECK-NEXT:   Predicates:
 ; CHECK:       Loop %loop: Trip multiple is 1
 ;
@@ -1368,19 +1368,19 @@
 ; CHECK-LABEL: 'optimized_range_check_unsigned3'
 ; CHECK-NEXT:  Classifying expressions for: @optimized_range_check_unsigned3
 ; CHECK-NEXT:    %N = select i1 %c, i32 2, i32 3
-; CHECK-NEXT:    --> %N U: [2,4) S: [2,4)
+; CHECK-NEXT:    --> (2 + (1 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> U: [2,4) S: [2,4)
 ; CHECK-NEXT:    %N.off = add i32 %N, -1
-; CHECK-NEXT:    --> (-1 + %N)<nsw> U: [1,3) S: [1,3)
+; CHECK-NEXT:    --> (1 + (1 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> U: [1,3) S: [1,3)
 ; CHECK-NEXT:    %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
-; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%loop> U: [0,3) S: [0,3) Exits: (-1 + %N)<nsw> LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%loop> U: [0,3) S: [0,3) Exits: (1 + (1 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %gep = getelementptr inbounds i16, i16* %pred, i32 %iv
-; CHECK-NEXT:    --> {%pred,+,2}<nuw><%loop> U: full-set S: full-set Exits: ((2 * (zext i32 (-1 + %N)<nsw> to i64))<nuw><nsw> + %pred) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {%pred,+,2}<nuw><%loop> U: full-set S: full-set Exits: (2 + (2 * (zext i32 (1 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i64))<nuw><nsw> + %pred) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.next = add nuw nsw i32 %iv, 1
-; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%loop> U: [1,4) S: [1,4) Exits: %N LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%loop> U: [1,4) S: [1,4) Exits: (2 + (1 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @optimized_range_check_unsigned3
-; CHECK-NEXT:  Loop %loop: backedge-taken count is (-1 + %N)<nsw>
+; CHECK-NEXT:  Loop %loop: backedge-taken count is (1 + (1 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw>
 ; CHECK-NEXT:  Loop %loop: max backedge-taken count is 2
-; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is (-1 + %N)<nsw>
+; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is (1 + (1 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw>
 ; CHECK-NEXT:   Predicates:
 ; CHECK:       Loop %loop: Trip multiple is 1
 ;
diff --git a/llvm/test/Analysis/ScalarEvolution/nsw.ll b/llvm/test/Analysis/ScalarEvolution/nsw.ll
--- a/llvm/test/Analysis/ScalarEvolution/nsw.ll
+++ b/llvm/test/Analysis/ScalarEvolution/nsw.ll
@@ -402,7 +402,7 @@
 ; CHECK-NEXT:    %iv.next = add nsw i32 %iv, 1
 ; CHECK-NEXT:    --> {1,+,1}<nuw><%loop> U: [1,0) S: [1,0) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %sel = select i1 %cmp, i32 10, i32 20
-; CHECK-NEXT:    --> %sel U: [0,31) S: [0,31) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
+; CHECK-NEXT:    --> (10 + (10 umin (-1 + (-1 * (sext i1 %cmp to i32))<nsw>)<nsw>))<nuw><nsw> U: [10,21) S: [10,21) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
 ; CHECK-NEXT:    %cond = call i1 @cond()
 ; CHECK-NEXT:    --> %cond U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
 ; CHECK-NEXT:  Determining loop execution counts for: @select_cond_poison_propagation
diff --git a/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll
--- a/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll
+++ b/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll
@@ -276,7 +276,7 @@
 ; PTR64_IDX64-NEXT:    %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32)
 ; PTR64_IDX64-NEXT:    --> ((-1 * (trunc i64 (ptrtoint [0 x i8]* @global to i64) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (trunc i64 (ptrtoint [0 x i8]* @global to i64) to i32)) + %arg) LoopDispositions: { %bb7: Invariant }
 ; PTR64_IDX64-NEXT:    %tmp9 = select i1 %tmp8, i16 0, i16 1
-; PTR64_IDX64-NEXT:    --> %tmp9 U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; PTR64_IDX64-NEXT:    --> (1 umin (-1 + (-1 * (sext i1 %tmp8 to i16))<nsw>)<nsw>) U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
 ; PTR64_IDX64-NEXT:  Determining loop execution counts for: @zext_ptr_to_i32
 ; PTR64_IDX64-NEXT:  Loop %bb7: Unpredictable backedge-taken count.
 ; PTR64_IDX64-NEXT:  Loop %bb7: Unpredictable max backedge-taken count.
@@ -287,7 +287,7 @@
 ; PTR64_IDX32-NEXT:    %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32)
 ; PTR64_IDX32-NEXT:    --> ((-1 * ptrtoint ([0 x i8]* @global to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * ptrtoint ([0 x i8]* @global to i32)) + %arg) LoopDispositions: { %bb7: Invariant }
 ; PTR64_IDX32-NEXT:    %tmp9 = select i1 %tmp8, i16 0, i16 1
-; PTR64_IDX32-NEXT:    --> %tmp9 U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; PTR64_IDX32-NEXT:    --> (1 umin (-1 + (-1 * (sext i1 %tmp8 to i16))<nsw>)<nsw>) U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
 ; PTR64_IDX32-NEXT:  Determining loop execution counts for: @zext_ptr_to_i32
 ; PTR64_IDX32-NEXT:  Loop %bb7: Unpredictable backedge-taken count.
 ; PTR64_IDX32-NEXT:  Loop %bb7: Unpredictable max backedge-taken count.
@@ -298,7 +298,7 @@
 ; PTR16_IDX16-NEXT:    %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32)
 ; PTR16_IDX16-NEXT:    --> ((-1 * (zext i16 (ptrtoint [0 x i8]* @global to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (zext i16 (ptrtoint [0 x i8]* @global to i16) to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
 ; PTR16_IDX16-NEXT:    %tmp9 = select i1 %tmp8, i16 0, i16 1
-; PTR16_IDX16-NEXT:    --> %tmp9 U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; PTR16_IDX16-NEXT:    --> (1 umin (-1 + (-1 * (sext i1 %tmp8 to i16))<nsw>)<nsw>) U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
 ; PTR16_IDX16-NEXT:  Determining loop execution counts for: @zext_ptr_to_i32
 ; PTR16_IDX16-NEXT:  Loop %bb7: Unpredictable backedge-taken count.
 ; PTR16_IDX16-NEXT:  Loop %bb7: Unpredictable max backedge-taken count.
@@ -309,7 +309,7 @@
 ; PTR16_IDX32-NEXT:    %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32)
 ; PTR16_IDX32-NEXT:    --> ((-1 * ptrtoint ([0 x i8]* @global to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * ptrtoint ([0 x i8]* @global to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
 ; PTR16_IDX32-NEXT:    %tmp9 = select i1 %tmp8, i16 0, i16 1
-; PTR16_IDX32-NEXT:    --> %tmp9 U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; PTR16_IDX32-NEXT:    --> (1 umin (-1 + (-1 * (sext i1 %tmp8 to i16))<nsw>)<nsw>) U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
 ; PTR16_IDX32-NEXT:  Determining loop execution counts for: @zext_ptr_to_i32
 ; PTR16_IDX32-NEXT:  Loop %bb7: Unpredictable backedge-taken count.
 ; PTR16_IDX32-NEXT:  Loop %bb7: Unpredictable max backedge-taken count.
@@ -335,7 +335,7 @@
 ; PTR64_IDX64-NEXT:    %tmp = sub i32 %arg, sext (i16 ptrtoint ([0 x i8]* @global to i16) to i32)
 ; PTR64_IDX64-NEXT:    --> ((-1 * (sext i16 (trunc i64 (ptrtoint [0 x i8]* @global to i64) to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (trunc i64 (ptrtoint [0 x i8]* @global to i64) to i16) to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
 ; PTR64_IDX64-NEXT:    %tmp9 = select i1 %tmp8, i16 0, i16 1
-; PTR64_IDX64-NEXT:    --> %tmp9 U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; PTR64_IDX64-NEXT:    --> (1 umin (-1 + (-1 * (sext i1 %tmp8 to i16))<nsw>)<nsw>) U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
 ; PTR64_IDX64-NEXT:  Determining loop execution counts for: @sext_to_i32
 ; PTR64_IDX64-NEXT:  Loop %bb7: Unpredictable backedge-taken count.
 ; PTR64_IDX64-NEXT:  Loop %bb7: Unpredictable max backedge-taken count.
@@ -346,7 +346,7 @@
 ; PTR64_IDX32-NEXT:    %tmp = sub i32 %arg, sext (i16 ptrtoint ([0 x i8]* @global to i16) to i32)
 ; PTR64_IDX32-NEXT:    --> ((-1 * (sext i16 ptrtoint ([0 x i8]* @global to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint ([0 x i8]* @global to i16) to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
 ; PTR64_IDX32-NEXT:    %tmp9 = select i1 %tmp8, i16 0, i16 1
-; PTR64_IDX32-NEXT:    --> %tmp9 U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; PTR64_IDX32-NEXT:    --> (1 umin (-1 + (-1 * (sext i1 %tmp8 to i16))<nsw>)<nsw>) U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
 ; PTR64_IDX32-NEXT:  Determining loop execution counts for: @sext_to_i32
 ; PTR64_IDX32-NEXT:  Loop %bb7: Unpredictable backedge-taken count.
 ; PTR64_IDX32-NEXT:  Loop %bb7: Unpredictable max backedge-taken count.
@@ -357,7 +357,7 @@
 ; PTR16_IDX16-NEXT:    %tmp = sub i32 %arg, sext (i16 ptrtoint ([0 x i8]* @global to i16) to i32)
 ; PTR16_IDX16-NEXT:    --> ((-1 * (sext i16 (ptrtoint [0 x i8]* @global to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (ptrtoint [0 x i8]* @global to i16) to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
 ; PTR16_IDX16-NEXT:    %tmp9 = select i1 %tmp8, i16 0, i16 1
-; PTR16_IDX16-NEXT:    --> %tmp9 U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; PTR16_IDX16-NEXT:    --> (1 umin (-1 + (-1 * (sext i1 %tmp8 to i16))<nsw>)<nsw>) U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
 ; PTR16_IDX16-NEXT:  Determining loop execution counts for: @sext_to_i32
 ; PTR16_IDX16-NEXT:  Loop %bb7: Unpredictable backedge-taken count.
 ; PTR16_IDX16-NEXT:  Loop %bb7: Unpredictable max backedge-taken count.
@@ -368,7 +368,7 @@
 ; PTR16_IDX32-NEXT:    %tmp = sub i32 %arg, sext (i16 ptrtoint ([0 x i8]* @global to i16) to i32)
 ; PTR16_IDX32-NEXT:    --> ((-1 * (sext i16 ptrtoint ([0 x i8]* @global to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint ([0 x i8]* @global to i16) to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
 ; PTR16_IDX32-NEXT:    %tmp9 = select i1 %tmp8, i16 0, i16 1
-; PTR16_IDX32-NEXT:    --> %tmp9 U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; PTR16_IDX32-NEXT:    --> (1 umin (-1 + (-1 * (sext i1 %tmp8 to i16))<nsw>)<nsw>) U: [0,2) S: [0,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
 ; PTR16_IDX32-NEXT:  Determining loop execution counts for: @sext_to_i32
 ; PTR16_IDX32-NEXT:  Loop %bb7: Unpredictable backedge-taken count.
 ; PTR16_IDX32-NEXT:  Loop %bb7: Unpredictable max backedge-taken count.
diff --git a/llvm/test/Analysis/ScalarEvolution/sext-to-zext.ll b/llvm/test/Analysis/ScalarEvolution/sext-to-zext.ll
--- a/llvm/test/Analysis/ScalarEvolution/sext-to-zext.ll
+++ b/llvm/test/Analysis/ScalarEvolution/sext-to-zext.ll
@@ -5,19 +5,19 @@
 ; CHECK-LABEL: 'f'
 ; CHECK-NEXT:  Classifying expressions for: @f
 ; CHECK-NEXT:    %start = select i1 %c, i32 100, i32 0
-; CHECK-NEXT:    --> %start U: [0,101) S: [0,101)
+; CHECK-NEXT:    --> (100 + (-100 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) U: [100,1) S: [100,1)
 ; CHECK-NEXT:    %step = select i1 %c, i32 -1, i32 1
-; CHECK-NEXT:    --> %step U: [1,0) S: [-2,2)
+; CHECK-NEXT:    --> (-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw> U: [-1,2) S: [-1,2)
 ; CHECK-NEXT:    %iv = phi i32 [ %start, %entry ], [ %iv.dec, %loop ]
-; CHECK-NEXT:    --> {%start,+,%step}<nsw><%loop> U: [0,101) S: [0,101) Exits: ((99 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(100 + (-100 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<nsw><%loop> U: full-set S: full-set Exits: (1 + (99 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-100 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.tc = phi i32 [ 0, %entry ], [ %iv.tc.inc, %loop ]
 ; CHECK-NEXT:    --> {0,+,1}<%loop> U: [0,100) S: [0,100) Exits: 99 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.tc.inc = add i32 %iv.tc, 1
 ; CHECK-NEXT:    --> {1,+,1}<%loop> U: [1,101) S: [1,101) Exits: 100 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.dec = add nsw i32 %iv, %step
-; CHECK-NEXT:    --> {(%step + %start),+,%step}<nw><%loop> U: [-200,201) S: [-200,201) Exits: ((100 * %step)<nsw> + %start) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(99 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) + (-100 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)),+,(-1 + (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nsw>}<nw><%loop> U: full-set S: full-set Exits: ((100 * (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>))<nuw><nsw> + (-100 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.sext = sext i32 %iv to i64
-; CHECK-NEXT:    --> {(zext i32 %start to i64),+,(sext i32 %step to i64)}<nsw><%loop> U: [0,101) S: [0,101) Exits: ((zext i32 %start to i64) + (99 * (sext i32 %step to i64))<nsw>) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {(sext i32 (100 + (-100 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) to i64),+,(-1 + (zext i32 (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i64))<nsw>}<nsw><%loop> U: [-2147483747,2147483747) S: [-2147483747,2147483747) Exits: (-99 + (sext i32 (100 + (-100 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>)) to i64) + (99 * (zext i32 (2 umin (-1 + (-1 * (sext i1 %c to i32))<nsw>)<nsw>) to i64))<nuw><nsw>) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @f
 ; CHECK-NEXT:  Loop %loop: backedge-taken count is 99
 ; CHECK-NEXT:  Loop %loop: max backedge-taken count is 99
diff --git a/llvm/test/Analysis/ScalarEvolution/shift-recurrences.ll b/llvm/test/Analysis/ScalarEvolution/shift-recurrences.ll
--- a/llvm/test/Analysis/ScalarEvolution/shift-recurrences.ll
+++ b/llvm/test/Analysis/ScalarEvolution/shift-recurrences.ll
@@ -222,7 +222,7 @@
 ; CHECK-LABEL: 'test_shl3'
 ; CHECK-NEXT:  Classifying expressions for: @test_shl3
 ; CHECK-NEXT:    %shiftamt = select i1 %c, i64 1, i64 0
-; CHECK-NEXT:    --> %shiftamt U: [0,2) S: [0,2)
+; CHECK-NEXT:    --> (-1 * (sext i1 %c to i64))<nsw> U: [0,2) S: [0,2)
 ; CHECK-NEXT:    %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
 ; CHECK-NEXT:    --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.shl = phi i64 [ 4, %entry ], [ %iv.shl.next, %loop ]
diff --git a/llvm/test/Analysis/StackSafetyAnalysis/local.ll b/llvm/test/Analysis/StackSafetyAnalysis/local.ll
--- a/llvm/test/Analysis/StackSafetyAnalysis/local.ll
+++ b/llvm/test/Analysis/StackSafetyAnalysis/local.ll
@@ -357,7 +357,7 @@
 ; CHECK-NEXT: args uses:
 ; CHECK-NEXT: allocas uses:
 ; FIXME: SCEV can't look through selects.
-; CHECK-NEXT: x[4]: [0,4){{$}}
+; CHECK-NEXT: x[4]: [1,3){{$}}
 ; GLOBAL-NEXT: safe accesses:
 ; GLOBAL-NEXT: store i8 0, i8* %x2, align 1
 ; CHECK-EMPTY:
@@ -402,7 +402,7 @@
 ; CHECK-LABEL: @NonConstantOffsetOOB dso_preemptable{{$}}
 ; CHECK-NEXT: args uses:
 ; CHECK-NEXT: allocas uses:
-; CHECK-NEXT: x[4]: [0,6){{$}}
+; CHECK-NEXT: x[4]: [1,5){{$}}
 ; GLOBAL-NEXT: safe accesses:
 ; CHECK-EMPTY:
 entry:
@@ -596,7 +596,7 @@
 ; GLOBAL-NEXT: safe accesses:
 ; GLOBAL-NEXT: store %zerosize_type undef, %zerosize_type* %x, align 4
 ; GLOBAL-NEXT: store %zerosize_type undef, %zerosize_type* undef, align 4
-; GLOBAL-NEXT: load %zerosize_type, %zerosize_type* %p, align 
+; GLOBAL-NEXT: load %zerosize_type, %zerosize_type* %p, align
 ; CHECK-EMPTY:
 entry:
   %x = alloca %zerosize_type, align 4
diff --git a/llvm/test/Analysis/StackSafetyAnalysis/memintrin.ll b/llvm/test/Analysis/StackSafetyAnalysis/memintrin.ll
--- a/llvm/test/Analysis/StackSafetyAnalysis/memintrin.ll
+++ b/llvm/test/Analysis/StackSafetyAnalysis/memintrin.ll
@@ -74,8 +74,9 @@
 ; CHECK-LABEL: MemsetNonConstInBounds dso_preemptable{{$}}
 ; CHECK-NEXT: args uses:
 ; CHECK-NEXT: allocas uses:
-; CHECK-NEXT: x[4]: [0,7){{$}}
+; CHECK-NEXT: x[4]: [0,4){{$}}
 ; GLOBAL-NEXT: safe accesses:
+; GLOBAL-NEXT: call void @llvm.memset.p0i8.i32(i8* %x1, i8 42, i32 %size, i1 false)
 ; CHECK-EMPTY:
 entry:
   %x = alloca i32, align 4
diff --git a/llvm/test/CodeGen/PowerPC/prefer-dqform.ll b/llvm/test/CodeGen/PowerPC/prefer-dqform.ll
--- a/llvm/test/CodeGen/PowerPC/prefer-dqform.ll
+++ b/llvm/test/CodeGen/PowerPC/prefer-dqform.ll
@@ -33,35 +33,36 @@
 ; CHECK-P9-NEXT:    bgtlr cr0
 ; CHECK-P9-NEXT:  # %bb.1: # %_loop_2_do_.lr.ph
 ; CHECK-P9-NEXT:    extswsli r5, r5, 3
-; CHECK-P9-NEXT:    extsw r10, r4
+; CHECK-P9-NEXT:    clrldi r10, r3, 32
+; CHECK-P9-NEXT:    extsw r11, r4
+; CHECK-P9-NEXT:    rldic r3, r3, 3, 29
 ; CHECK-P9-NEXT:    add r5, r8, r5
-; CHECK-P9-NEXT:    clrldi r8, r3, 32
-; CHECK-P9-NEXT:    lwa r3, 0(r7)
-; CHECK-P9-NEXT:    addi r4, r8, 1
-; CHECK-P9-NEXT:    addi r5, r5, -8
-; CHECK-P9-NEXT:    lxvdsx vs0, 0, r5
-; CHECK-P9-NEXT:    sub r3, r4, r3
+; CHECK-P9-NEXT:    addi r3, r3, -8
+; CHECK-P9-NEXT:    addi r8, r5, -8
+; CHECK-P9-NEXT:    lwa r5, 0(r7)
+; CHECK-P9-NEXT:    lxvdsx vs0, 0, r8
+; CHECK-P9-NEXT:    extswsli r7, r5, 3
+; CHECK-P9-NEXT:    subfic r4, r5, 2
+; CHECK-P9-NEXT:    sub r5, r6, r7
+; CHECK-P9-NEXT:    sub r7, r11, r10
 ; CHECK-P9-NEXT:    sldi r4, r4, 3
-; CHECK-P9-NEXT:    sldi r3, r3, 3
-; CHECK-P9-NEXT:    add r4, r9, r4
-; CHECK-P9-NEXT:    add r3, r6, r3
-; CHECK-P9-NEXT:    sub r6, r10, r8
-; CHECK-P9-NEXT:    rldicl r6, r6, 60, 4
-; CHECK-P9-NEXT:    addi r6, r6, 1
-; CHECK-P9-NEXT:    mtctr r6
+; CHECK-P9-NEXT:    rldicl r7, r7, 60, 4
+; CHECK-P9-NEXT:    add r4, r6, r4
+; CHECK-P9-NEXT:    addi r6, r9, 16
+; CHECK-P9-NEXT:    addi r7, r7, 1
+; CHECK-P9-NEXT:    mtctr r7
 ; CHECK-P9-NEXT:    .p2align 4
 ; CHECK-P9-NEXT:  .LBB0_2: # %_loop_2_do_
 ; CHECK-P9-NEXT:    #
-; CHECK-P9-NEXT:    lxv vs1, -16(r4)
-; CHECK-P9-NEXT:    lxv vs2, 0(r4)
-; CHECK-P9-NEXT:    lxv vs3, -16(r3)
-; CHECK-P9-NEXT:    lxv vs4, 0(r3)
-; CHECK-P9-NEXT:    addi r3, r3, 128
+; CHECK-P9-NEXT:    lxvx vs1, r9, r3
+; CHECK-P9-NEXT:    lxvx vs2, r6, r3
+; CHECK-P9-NEXT:    lxvx vs3, r5, r3
+; CHECK-P9-NEXT:    lxvx vs4, r4, r3
 ; CHECK-P9-NEXT:    xvmaddadp vs1, vs3, vs1
-; CHECK-P9-NEXT:    stxv vs1, -16(r4)
 ; CHECK-P9-NEXT:    xvmaddadp vs2, vs4, vs0
-; CHECK-P9-NEXT:    stxv vs2, 0(r4)
-; CHECK-P9-NEXT:    addi r4, r4, 128
+; CHECK-P9-NEXT:    stxvx vs1, r9, r3
+; CHECK-P9-NEXT:    stxvx vs2, r6, r3
+; CHECK-P9-NEXT:    addi r3, r3, 128
 ; CHECK-P9-NEXT:    bdnz .LBB0_2
 ; CHECK-P9-NEXT:  # %bb.3: # %_return_bb
 ; CHECK-P9-NEXT:    blr
@@ -87,35 +88,36 @@
 ; CHECK-P10-NEXT:    bgtlr cr0
 ; CHECK-P10-NEXT:  # %bb.1: # %_loop_2_do_.lr.ph
 ; CHECK-P10-NEXT:    extswsli r5, r5, 3
-; CHECK-P10-NEXT:    extsw r10, r4
+; CHECK-P10-NEXT:    clrldi r10, r3, 32
+; CHECK-P10-NEXT:    extsw r11, r4
+; CHECK-P10-NEXT:    rldic r3, r3, 3, 29
 ; CHECK-P10-NEXT:    add r5, r8, r5
-; CHECK-P10-NEXT:    clrldi r8, r3, 32
-; CHECK-P10-NEXT:    lwa r3, 0(r7)
-; CHECK-P10-NEXT:    addi r4, r8, 1
-; CHECK-P10-NEXT:    addi r5, r5, -8
-; CHECK-P10-NEXT:    lxvdsx vs0, 0, r5
-; CHECK-P10-NEXT:    sub r3, r4, r3
+; CHECK-P10-NEXT:    addi r3, r3, -8
+; CHECK-P10-NEXT:    addi r8, r5, -8
+; CHECK-P10-NEXT:    lwa r5, 0(r7)
+; CHECK-P10-NEXT:    lxvdsx vs0, 0, r8
+; CHECK-P10-NEXT:    extswsli r7, r5, 3
+; CHECK-P10-NEXT:    subfic r4, r5, 2
+; CHECK-P10-NEXT:    sub r5, r6, r7
+; CHECK-P10-NEXT:    sub r7, r11, r10
 ; CHECK-P10-NEXT:    sldi r4, r4, 3
-; CHECK-P10-NEXT:    add r4, r9, r4
-; CHECK-P10-NEXT:    sldi r3, r3, 3
-; CHECK-P10-NEXT:    add r3, r6, r3
-; CHECK-P10-NEXT:    sub r6, r10, r8
-; CHECK-P10-NEXT:    rldicl r6, r6, 60, 4
-; CHECK-P10-NEXT:    addi r6, r6, 1
-; CHECK-P10-NEXT:    mtctr r6
+; CHECK-P10-NEXT:    add r4, r6, r4
+; CHECK-P10-NEXT:    addi r6, r9, 16
+; CHECK-P10-NEXT:    rldicl r7, r7, 60, 4
+; CHECK-P10-NEXT:    addi r7, r7, 1
+; CHECK-P10-NEXT:    mtctr r7
 ; CHECK-P10-NEXT:    .p2align 4
 ; CHECK-P10-NEXT:  .LBB0_2: # %_loop_2_do_
 ; CHECK-P10-NEXT:    #
-; CHECK-P10-NEXT:    lxv vs1, -16(r4)
-; CHECK-P10-NEXT:    lxv vs2, 0(r4)
-; CHECK-P10-NEXT:    lxv vs3, -16(r3)
+; CHECK-P10-NEXT:    lxvx vs1, r9, r3
+; CHECK-P10-NEXT:    lxvx vs2, r6, r3
+; CHECK-P10-NEXT:    lxvx vs3, r5, r3
 ; CHECK-P10-NEXT:    xvmaddadp vs1, vs3, vs1
-; CHECK-P10-NEXT:    lxv vs4, 0(r3)
+; CHECK-P10-NEXT:    lxvx vs4, r4, r3
 ; CHECK-P10-NEXT:    xvmaddadp vs2, vs4, vs0
+; CHECK-P10-NEXT:    stxvx vs1, r9, r3
+; CHECK-P10-NEXT:    stxvx vs2, r6, r3
 ; CHECK-P10-NEXT:    addi r3, r3, 128
-; CHECK-P10-NEXT:    stxv vs1, -16(r4)
-; CHECK-P10-NEXT:    stxv vs2, 0(r4)
-; CHECK-P10-NEXT:    addi r4, r4, 128
 ; CHECK-P10-NEXT:    bdnz .LBB0_2
 ; CHECK-P10-NEXT:  # %bb.3: # %_return_bb
 ; CHECK-P10-NEXT:    blr
diff --git a/llvm/test/CodeGen/Thumb2/mve-memtp-loop.ll b/llvm/test/CodeGen/Thumb2/mve-memtp-loop.ll
--- a/llvm/test/CodeGen/Thumb2/mve-memtp-loop.ll
+++ b/llvm/test/CodeGen/Thumb2/mve-memtp-loop.ll
@@ -550,68 +550,68 @@
 ; CHECK-NEXT:    push.w {r4, r5, r6, r7, r8, r9, r10, r11, lr}
 ; CHECK-NEXT:    .pad #12
 ; CHECK-NEXT:    sub sp, #12
+; CHECK-NEXT:    mov.w r3, #418
 ; CHECK-NEXT:    cmp r0, #0
-; CHECK-NEXT:    mov.w r1, #11
-; CHECK-NEXT:    cinc r1, r1, ne
-; CHECK-NEXT:    movs r0, #38
-; CHECK-NEXT:    mul r2, r1, r0
-; CHECK-NEXT:    str r1, [sp, #8] @ 4-byte Spill
-; CHECK-NEXT:    movw r0, :lower16:arr_22
+; CHECK-NEXT:    it ne
+; CHECK-NEXT:    movne.w r3, #456
+; CHECK-NEXT:    add.w r2, r3, #15
+; CHECK-NEXT:    movw r1, :lower16:arr_22
 ; CHECK-NEXT:    vmov.i32 q0, #0x0
-; CHECK-NEXT:    movt r0, :upper16:arr_22
-; CHECK-NEXT:    add.w r1, r2, #15
-; CHECK-NEXT:    lsrs r3, r1, #4
-; CHECK-NEXT:    strd r3, r2, [sp] @ 8-byte Folded Spill
-; CHECK-NEXT:    wlstp.8 lr, r2, .LBB19_2
+; CHECK-NEXT:    lsrs r7, r2, #4
+; CHECK-NEXT:    movt r1, :upper16:arr_22
+; CHECK-NEXT:    str r3, [sp, #8] @ 4-byte Spill
+; CHECK-NEXT:    str r7, [sp] @ 4-byte Spill
+; CHECK-NEXT:    wlstp.8 lr, r3, .LBB19_2
 ; CHECK-NEXT:  .LBB19_1: @ =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    vstrb.8 q0, [r0], #16
+; CHECK-NEXT:    vstrb.8 q0, [r1], #16
 ; CHECK-NEXT:    letp lr, .LBB19_1
 ; CHECK-NEXT:  .LBB19_2: @ %entry
-; CHECK-NEXT:    ldr r0, [sp, #8] @ 4-byte Reload
-; CHECK-NEXT:    movw r6, :lower16:arr_20
-; CHECK-NEXT:    movt r6, :upper16:arr_20
-; CHECK-NEXT:    add.w r3, r6, #80
+; CHECK-NEXT:    movw r12, :lower16:arr_20
+; CHECK-NEXT:    movw r1, :lower16:arr_21
+; CHECK-NEXT:    adds r0, #11
+; CHECK-NEXT:    str r0, [sp, #4] @ 4-byte Spill
+; CHECK-NEXT:    movt r12, :upper16:arr_20
+; CHECK-NEXT:    movt r1, :upper16:arr_21
 ; CHECK-NEXT:    dls lr, r0
-; CHECK-NEXT:    movw r0, :lower16:arr_21
-; CHECK-NEXT:    movt r0, :upper16:arr_21
-; CHECK-NEXT:    add.w r5, r0, #36
-; CHECK-NEXT:    add.w r11, r6, #128
-; CHECK-NEXT:    add.w r7, r6, #112
-; CHECK-NEXT:    add.w r2, r6, #96
-; CHECK-NEXT:    add.w r4, r6, #64
-; CHECK-NEXT:    add.w r0, r6, #48
-; CHECK-NEXT:    add.w r1, r6, #32
-; CHECK-NEXT:    add.w r12, r6, #16
-; CHECK-NEXT:    adr r6, .LCPI19_0
-; CHECK-NEXT:    vldrw.u32 q0, [r6]
-; CHECK-NEXT:    movw r6, :lower16:arr_20
-; CHECK-NEXT:    mov.w r8, #327685
-; CHECK-NEXT:    mov.w r9, #5
+; CHECK-NEXT:    adr r0, .LCPI19_0
+; CHECK-NEXT:    add.w r5, r1, #36
+; CHECK-NEXT:    vldrw.u32 q0, [r0]
+; CHECK-NEXT:    movw r0, :lower16:arr_20
+; CHECK-NEXT:    add.w r4, r12, #80
+; CHECK-NEXT:    add.w r11, r12, #128
+; CHECK-NEXT:    add.w r7, r12, #112
+; CHECK-NEXT:    add.w r3, r12, #96
+; CHECK-NEXT:    add.w r1, r12, #64
+; CHECK-NEXT:    add.w r2, r12, #48
+; CHECK-NEXT:    add.w r6, r12, #32
+; CHECK-NEXT:    add.w r12, r12, #16
+; CHECK-NEXT:    mov.w r9, #327685
+; CHECK-NEXT:    mov.w r8, #5
 ; CHECK-NEXT:    vmov.i16 q1, #0x5
 ; CHECK-NEXT:    mov.w r10, #0
-; CHECK-NEXT:    movt r6, :upper16:arr_20
+; CHECK-NEXT:    movt r0, :upper16:arr_20
 ; CHECK-NEXT:  .LBB19_3: @ %for.cond8.preheader
 ; CHECK-NEXT:    @ =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    str r8, [r5, #-4]
+; CHECK-NEXT:    str r9, [r5, #-4]
 ; CHECK-NEXT:    vstrh.16 q1, [r5, #-36]
-; CHECK-NEXT:    strh.w r9, [r5]
+; CHECK-NEXT:    strh.w r8, [r5]
 ; CHECK-NEXT:    vstrh.16 q1, [r5, #-20]
-; CHECK-NEXT:    vstrw.32 q0, [r3]
+; CHECK-NEXT:    vstrw.32 q0, [r4]
 ; CHECK-NEXT:    vstrh.16 q0, [r12], #152
-; CHECK-NEXT:    vstrh.16 q0, [r6], #152
-; CHECK-NEXT:    vstrh.16 q0, [r1], #152
 ; CHECK-NEXT:    vstrh.16 q0, [r0], #152
-; CHECK-NEXT:    vstrh.16 q0, [r4], #152
+; CHECK-NEXT:    vstrh.16 q0, [r6], #152
 ; CHECK-NEXT:    vstrh.16 q0, [r2], #152
+; CHECK-NEXT:    vstrh.16 q0, [r1], #152
+; CHECK-NEXT:    vstrh.16 q0, [r3], #152
 ; CHECK-NEXT:    vstrh.16 q0, [r7], #152
 ; CHECK-NEXT:    vstrh.16 q0, [r11], #152
-; CHECK-NEXT:    strd r9, r10, [r3, #64]
+; CHECK-NEXT:    strd r8, r10, [r4, #64]
 ; CHECK-NEXT:    adds r5, #38
-; CHECK-NEXT:    adds r3, #152
+; CHECK-NEXT:    adds r4, #152
 ; CHECK-NEXT:    le lr, .LBB19_3
 ; CHECK-NEXT:  @ %bb.4: @ %for.cond.cleanup6
 ; CHECK-NEXT:    movw r0, :lower16:arr_22
-; CHECK-NEXT:    ldr r2, [sp, #4] @ 4-byte Reload
+; CHECK-NEXT:    ldr r2, [sp, #8] @ 4-byte Reload
 ; CHECK-NEXT:    movt r0, :upper16:arr_22
 ; CHECK-NEXT:    ldr r3, [sp] @ 4-byte Reload
 ; CHECK-NEXT:    add.w r0, r0, #1824
@@ -621,52 +621,52 @@
 ; CHECK-NEXT:    vstrb.8 q1, [r0], #16
 ; CHECK-NEXT:    letp lr, .LBB19_5
 ; CHECK-NEXT:  .LBB19_6: @ %for.cond.cleanup6
-; CHECK-NEXT:    movw r6, :lower16:arr_20
+; CHECK-NEXT:    movw r3, :lower16:arr_20
 ; CHECK-NEXT:    movw r0, #7376
-; CHECK-NEXT:    movt r6, :upper16:arr_20
-; CHECK-NEXT:    adds r3, r6, r0
+; CHECK-NEXT:    movt r3, :upper16:arr_20
+; CHECK-NEXT:    adds r4, r3, r0
 ; CHECK-NEXT:    movw r0, #7408
-; CHECK-NEXT:    add.w r12, r6, r0
+; CHECK-NEXT:    add.w r12, r3, r0
 ; CHECK-NEXT:    movw r0, #7344
-; CHECK-NEXT:    add.w r9, r6, r0
+; CHECK-NEXT:    add.w r11, r3, r0
 ; CHECK-NEXT:    movw r0, #7312
-; CHECK-NEXT:    adds r2, r6, r0
+; CHECK-NEXT:    ldr r1, [sp, #4] @ 4-byte Reload
+; CHECK-NEXT:    add.w r8, r3, r0
 ; CHECK-NEXT:    movw r0, :lower16:arr_21
-; CHECK-NEXT:    add.w r1, r6, #7424
-; CHECK-NEXT:    add.w r7, r6, #7392
-; CHECK-NEXT:    add.w r4, r6, #7360
-; CHECK-NEXT:    add.w r5, r6, #7328
-; CHECK-NEXT:    add.w r8, r6, #7296
-; CHECK-NEXT:    ldr r6, [sp, #8] @ 4-byte Reload
 ; CHECK-NEXT:    movt r0, :upper16:arr_21
-; CHECK-NEXT:    addw r0, r0, #1860
-; CHECK-NEXT:    mov.w r10, #5
-; CHECK-NEXT:    dls lr, r6
-; CHECK-NEXT:    mov.w r6, #327685
+; CHECK-NEXT:    addw r2, r0, #1860
+; CHECK-NEXT:    dls lr, r1
+; CHECK-NEXT:    add.w r7, r3, #7424
+; CHECK-NEXT:    add.w r6, r3, #7392
+; CHECK-NEXT:    add.w r0, r3, #7360
+; CHECK-NEXT:    add.w r5, r3, #7328
+; CHECK-NEXT:    add.w r3, r3, #7296
+; CHECK-NEXT:    mov.w r1, #327685
+; CHECK-NEXT:    mov.w r9, #5
 ; CHECK-NEXT:    vmov.i16 q1, #0x5
-; CHECK-NEXT:    mov.w r11, #0
+; CHECK-NEXT:    mov.w r10, #0
 ; CHECK-NEXT:  .LBB19_7: @ %for.cond8.preheader.1
 ; CHECK-NEXT:    @ =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    str r6, [r0, #-4]
-; CHECK-NEXT:    vstrh.16 q1, [r0, #-36]
-; CHECK-NEXT:    strh.w r10, [r0]
-; CHECK-NEXT:    vstrh.16 q1, [r0, #-20]
-; CHECK-NEXT:    vstrw.32 q0, [r3]
-; CHECK-NEXT:    vstrh.16 q0, [r2], #152
+; CHECK-NEXT:    str r1, [r2, #-4]
+; CHECK-NEXT:    vstrh.16 q1, [r2, #-36]
+; CHECK-NEXT:    strh.w r9, [r2]
+; CHECK-NEXT:    vstrh.16 q1, [r2, #-20]
+; CHECK-NEXT:    vstrw.32 q0, [r4]
 ; CHECK-NEXT:    vstrh.16 q0, [r8], #152
+; CHECK-NEXT:    vstrh.16 q0, [r3], #152
 ; CHECK-NEXT:    vstrh.16 q0, [r5], #152
-; CHECK-NEXT:    vstrh.16 q0, [r9], #152
-; CHECK-NEXT:    vstrh.16 q0, [r4], #152
-; CHECK-NEXT:    vstrh.16 q0, [r7], #152
+; CHECK-NEXT:    vstrh.16 q0, [r11], #152
+; CHECK-NEXT:    vstrh.16 q0, [r0], #152
+; CHECK-NEXT:    vstrh.16 q0, [r6], #152
 ; CHECK-NEXT:    vstrh.16 q0, [r12], #152
-; CHECK-NEXT:    vstrh.16 q0, [r1], #152
-; CHECK-NEXT:    strd r10, r11, [r3, #64]
-; CHECK-NEXT:    adds r0, #38
-; CHECK-NEXT:    adds r3, #152
+; CHECK-NEXT:    vstrh.16 q0, [r7], #152
+; CHECK-NEXT:    strd r9, r10, [r4, #64]
+; CHECK-NEXT:    adds r2, #38
+; CHECK-NEXT:    adds r4, #152
 ; CHECK-NEXT:    le lr, .LBB19_7
 ; CHECK-NEXT:  @ %bb.8: @ %for.cond.cleanup6.1
 ; CHECK-NEXT:    movw r0, :lower16:arr_22
-; CHECK-NEXT:    ldr r2, [sp, #4] @ 4-byte Reload
+; CHECK-NEXT:    ldr r2, [sp, #8] @ 4-byte Reload
 ; CHECK-NEXT:    movt r0, :upper16:arr_22
 ; CHECK-NEXT:    ldr r3, [sp] @ 4-byte Reload
 ; CHECK-NEXT:    add.w r0, r0, #3648
@@ -676,57 +676,58 @@
 ; CHECK-NEXT:    vstrb.8 q1, [r0], #16
 ; CHECK-NEXT:    letp lr, .LBB19_9
 ; CHECK-NEXT:  .LBB19_10: @ %for.cond.cleanup6.1
-; CHECK-NEXT:    movw r7, :lower16:arr_20
+; CHECK-NEXT:    movw r6, :lower16:arr_20
 ; CHECK-NEXT:    movw r0, #14672
-; CHECK-NEXT:    movt r7, :upper16:arr_20
-; CHECK-NEXT:    adds r3, r7, r0
+; CHECK-NEXT:    movt r6, :upper16:arr_20
+; CHECK-NEXT:    adds r4, r6, r0
 ; CHECK-NEXT:    movw r0, #14704
-; CHECK-NEXT:    add.w r12, r7, r0
+; CHECK-NEXT:    add.w r12, r6, r0
 ; CHECK-NEXT:    movw r0, #14688
-; CHECK-NEXT:    add.w r8, r7, r0
+; CHECK-NEXT:    add.w r11, r6, r0
 ; CHECK-NEXT:    movw r0, #14640
-; CHECK-NEXT:    add.w r9, r7, r0
+; CHECK-NEXT:    add.w r8, r6, r0
 ; CHECK-NEXT:    movw r0, #14624
-; CHECK-NEXT:    adds r2, r7, r0
+; CHECK-NEXT:    adds r1, r6, r0
 ; CHECK-NEXT:    movw r0, #14608
-; CHECK-NEXT:    movw r1, :lower16:arr_21
-; CHECK-NEXT:    add r0, r7
-; CHECK-NEXT:    add.w r4, r7, #14720
-; CHECK-NEXT:    add.w r5, r7, #14656
-; CHECK-NEXT:    add.w r6, r7, #14592
-; CHECK-NEXT:    ldr r7, [sp, #8] @ 4-byte Reload
-; CHECK-NEXT:    movt r1, :upper16:arr_21
-; CHECK-NEXT:    addw r1, r1, #3684
-; CHECK-NEXT:    mov.w r10, #5
-; CHECK-NEXT:    dls lr, r7
-; CHECK-NEXT:    mov.w r7, #327685
+; CHECK-NEXT:    ldr r3, [sp, #4] @ 4-byte Reload
+; CHECK-NEXT:    adds r2, r6, r0
+; CHECK-NEXT:    movw r0, :lower16:arr_21
+; CHECK-NEXT:    movt r0, :upper16:arr_21
+; CHECK-NEXT:    addw r7, r0, #3684
+; CHECK-NEXT:    dls lr, r3
+; CHECK-NEXT:    add.w r0, r6, #14720
+; CHECK-NEXT:    add.w r5, r6, #14656
+; CHECK-NEXT:    add.w r6, r6, #14592
+; CHECK-NEXT:    mov.w r3, #327685
+; CHECK-NEXT:    mov.w r9, #5
 ; CHECK-NEXT:    vmov.i16 q1, #0x5
-; CHECK-NEXT:    mov.w r11, #0
+; CHECK-NEXT:    mov.w r10, #0
 ; CHECK-NEXT:  .LBB19_11: @ %for.cond8.preheader.2
 ; CHECK-NEXT:    @ =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    str r7, [r1, #-4]
-; CHECK-NEXT:    vstrh.16 q1, [r1, #-36]
-; CHECK-NEXT:    strh.w r10, [r1]
-; CHECK-NEXT:    vstrh.16 q1, [r1, #-20]
-; CHECK-NEXT:    vstrw.32 q0, [r3]
-; CHECK-NEXT:    vstrh.16 q0, [r0], #152
-; CHECK-NEXT:    vstrh.16 q0, [r6], #152
+; CHECK-NEXT:    str r3, [r7, #-4]
+; CHECK-NEXT:    vstrh.16 q1, [r7, #-36]
+; CHECK-NEXT:    strh.w r9, [r7]
+; CHECK-NEXT:    vstrh.16 q1, [r7, #-20]
+; CHECK-NEXT:    vstrw.32 q0, [r4]
 ; CHECK-NEXT:    vstrh.16 q0, [r2], #152
-; CHECK-NEXT:    vstrh.16 q0, [r9], #152
-; CHECK-NEXT:    vstrh.16 q0, [r5], #152
+; CHECK-NEXT:    vstrh.16 q0, [r6], #152
+; CHECK-NEXT:    vstrh.16 q0, [r1], #152
 ; CHECK-NEXT:    vstrh.16 q0, [r8], #152
+; CHECK-NEXT:    vstrh.16 q0, [r5], #152
+; CHECK-NEXT:    vstrh.16 q0, [r11], #152
 ; CHECK-NEXT:    vstrh.16 q0, [r12], #152
-; CHECK-NEXT:    vstrh.16 q0, [r4], #152
-; CHECK-NEXT:    strd r10, r11, [r3, #64]
-; CHECK-NEXT:    adds r1, #38
-; CHECK-NEXT:    adds r3, #152
+; CHECK-NEXT:    vstrh.16 q0, [r0], #152
+; CHECK-NEXT:    strd r9, r10, [r4, #64]
+; CHECK-NEXT:    adds r7, #38
+; CHECK-NEXT:    adds r4, #152
 ; CHECK-NEXT:    le lr, .LBB19_11
 ; CHECK-NEXT:  @ %bb.12: @ %for.cond.cleanup6.2
 ; CHECK-NEXT:    movw r0, :lower16:arr_22
-; CHECK-NEXT:    ldrd r2, r1, [sp] @ 8-byte Folded Reload
+; CHECK-NEXT:    ldr r1, [sp, #8] @ 4-byte Reload
 ; CHECK-NEXT:    movt r0, :upper16:arr_22
-; CHECK-NEXT:    vmov.i32 q1, #0x0
+; CHECK-NEXT:    ldr r2, [sp] @ 4-byte Reload
 ; CHECK-NEXT:    add.w r0, r0, #5472
+; CHECK-NEXT:    vmov.i32 q1, #0x0
 ; CHECK-NEXT:    wlstp.8 lr, r1, .LBB19_14
 ; CHECK-NEXT:  .LBB19_13: @ =>This Inner Loop Header: Depth=1
 ; CHECK-NEXT:    vstrb.8 q1, [r0], #16
@@ -736,47 +737,47 @@
 ; CHECK-NEXT:    movw r1, #5508
 ; CHECK-NEXT:    movt r2, :upper16:arr_21
 ; CHECK-NEXT:    movw r7, :lower16:arr_20
-; CHECK-NEXT:    add r2, r1
-; CHECK-NEXT:    movw r1, #22000
+; CHECK-NEXT:    add r1, r2
+; CHECK-NEXT:    movw r2, #22000
 ; CHECK-NEXT:    movt r7, :upper16:arr_20
-; CHECK-NEXT:    add.w r12, r7, r1
-; CHECK-NEXT:    movw r1, #21984
-; CHECK-NEXT:    add.w r8, r7, r1
-; CHECK-NEXT:    movw r1, #21952
-; CHECK-NEXT:    add.w r9, r7, r1
-; CHECK-NEXT:    movw r1, #21936
+; CHECK-NEXT:    add.w r12, r7, r2
+; CHECK-NEXT:    movw r2, #21984
+; CHECK-NEXT:    ldr r6, [sp, #4] @ 4-byte Reload
+; CHECK-NEXT:    add.w r8, r7, r2
+; CHECK-NEXT:    movw r2, #21952
+; CHECK-NEXT:    movw r3, #21920
 ; CHECK-NEXT:    movw r0, #21968
-; CHECK-NEXT:    adds r5, r7, r1
-; CHECK-NEXT:    movw r1, #21920
+; CHECK-NEXT:    add.w r9, r7, r2
+; CHECK-NEXT:    movw r2, #21936
+; CHECK-NEXT:    adds r5, r7, r3
 ; CHECK-NEXT:    movw r3, #21904
 ; CHECK-NEXT:    adds r4, r7, r3
+; CHECK-NEXT:    dls lr, r6
 ; CHECK-NEXT:    add r0, r7
-; CHECK-NEXT:    add r1, r7
+; CHECK-NEXT:    add r2, r7
 ; CHECK-NEXT:    add.w r3, r7, #22016
-; CHECK-NEXT:    add.w r6, r7, #21888
-; CHECK-NEXT:    ldr r7, [sp, #8] @ 4-byte Reload
+; CHECK-NEXT:    add.w r7, r7, #21888
+; CHECK-NEXT:    mov.w r6, #327685
 ; CHECK-NEXT:    mov.w r10, #5
 ; CHECK-NEXT:    vmov.i16 q1, #0x5
 ; CHECK-NEXT:    mov.w r11, #0
-; CHECK-NEXT:    dls lr, r7
-; CHECK-NEXT:    mov.w r7, #327685
 ; CHECK-NEXT:  .LBB19_15: @ %for.cond8.preheader.3
 ; CHECK-NEXT:    @ =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    str r7, [r2, #-4]
-; CHECK-NEXT:    vstrh.16 q1, [r2, #-36]
-; CHECK-NEXT:    strh.w r10, [r2]
-; CHECK-NEXT:    vstrh.16 q1, [r2, #-20]
+; CHECK-NEXT:    str r6, [r1, #-4]
+; CHECK-NEXT:    vstrh.16 q1, [r1, #-36]
+; CHECK-NEXT:    strh.w r10, [r1]
+; CHECK-NEXT:    vstrh.16 q1, [r1, #-20]
 ; CHECK-NEXT:    vstrw.32 q0, [r0]
 ; CHECK-NEXT:    vstrh.16 q0, [r4], #152
-; CHECK-NEXT:    vstrh.16 q0, [r6], #152
-; CHECK-NEXT:    vstrh.16 q0, [r1], #152
+; CHECK-NEXT:    vstrh.16 q0, [r7], #152
 ; CHECK-NEXT:    vstrh.16 q0, [r5], #152
+; CHECK-NEXT:    vstrh.16 q0, [r2], #152
 ; CHECK-NEXT:    vstrh.16 q0, [r9], #152
 ; CHECK-NEXT:    vstrh.16 q0, [r8], #152
 ; CHECK-NEXT:    vstrh.16 q0, [r12], #152
 ; CHECK-NEXT:    vstrh.16 q0, [r3], #152
 ; CHECK-NEXT:    strd r10, r11, [r0, #64]
-; CHECK-NEXT:    adds r2, #38
+; CHECK-NEXT:    adds r1, #38
 ; CHECK-NEXT:    adds r0, #152
 ; CHECK-NEXT:    le lr, .LBB19_15
 ; CHECK-NEXT:  @ %bb.16: @ %for.cond.cleanup6.3
diff --git a/llvm/test/CodeGen/X86/2007-11-30-LoadFolding-Bug.ll b/llvm/test/CodeGen/X86/2007-11-30-LoadFolding-Bug.ll
--- a/llvm/test/CodeGen/X86/2007-11-30-LoadFolding-Bug.ll
+++ b/llvm/test/CodeGen/X86/2007-11-30-LoadFolding-Bug.ll
@@ -33,6 +33,7 @@
 ; CHECK-NEXT:    movl $0, 0
 ; CHECK-NEXT:    movzbl %al, %ebp
 ; CHECK-NEXT:    andl $1, %ebp
+; CHECK-NEXT:    negl %ebp
 ; CHECK-NEXT:    xorpd %xmm0, %xmm0
 ; CHECK-NEXT:    xorl %eax, %eax
 ; CHECK-NEXT:    xorl %ecx, %ecx
@@ -49,7 +50,7 @@
 ; CHECK-NEXT:    xorpd %xmm1, %xmm1
 ; CHECK-NEXT:    subsd %xmm2, %xmm1
 ; CHECK-NEXT:    mulsd %xmm0, %xmm1
-; CHECK-NEXT:    addl $-2, %ebp
+; CHECK-NEXT:    addl $2, %ebp
 ; CHECK-NEXT:    jne .LBB0_5
 ; CHECK-NEXT:  # %bb.6: # %mp_unexp_d2mp.exit29.i
 ; CHECK-NEXT:    movl $0, 0
diff --git a/llvm/test/CodeGen/X86/dag-update-nodetomatch.ll b/llvm/test/CodeGen/X86/dag-update-nodetomatch.ll
--- a/llvm/test/CodeGen/X86/dag-update-nodetomatch.ll
+++ b/llvm/test/CodeGen/X86/dag-update-nodetomatch.ll
@@ -121,13 +121,13 @@
 ; CHECK-NEXT:    movq x4@GOTPCREL(%rip), %rax
 ; CHECK-NEXT:    movl %r13d, (%rax)
 ; CHECK-NEXT:    movq x3@GOTPCREL(%rip), %rax
-; CHECK-NEXT:    movl (%rax), %edx
-; CHECK-NEXT:    testl %edx, %edx
+; CHECK-NEXT:    movl (%rax), %r10d
+; CHECK-NEXT:    testl %r10d, %r10d
 ; CHECK-NEXT:    je .LBB1_18
 ; CHECK-NEXT:  # %bb.1: # %for.cond1thread-pre-split.lr.ph
 ; CHECK-NEXT:    movq x5@GOTPCREL(%rip), %rax
 ; CHECK-NEXT:    movq (%rax), %r12
-; CHECK-NEXT:    movl %edx, %eax
+; CHECK-NEXT:    movl %r10d, %eax
 ; CHECK-NEXT:    notl %eax
 ; CHECK-NEXT:    leaq 8(,%rax,8), %r14
 ; CHECK-NEXT:    imulq %r13, %r14
@@ -138,7 +138,7 @@
 ; CHECK-NEXT:    movq %rcx, {{[-0-9]+}}(%r{{[sb]}}p) # 8-byte Spill
 ; CHECK-NEXT:    leaq 8(%r12), %rcx
 ; CHECK-NEXT:    movq %rcx, {{[-0-9]+}}(%r{{[sb]}}p) # 8-byte Spill
-; CHECK-NEXT:    leaq 32(%r12), %rbx
+; CHECK-NEXT:    leaq 48(%r12), %rbx
 ; CHECK-NEXT:    shlq $3, %r13
 ; CHECK-NEXT:    xorl %esi, %esi
 ; CHECK-NEXT:    movq x0@GOTPCREL(%rip), %rcx
@@ -153,7 +153,7 @@
 ; CHECK-NEXT:    addq %r13, %rdi
 ; CHECK-NEXT:    incq %rsi
 ; CHECK-NEXT:    addq %r13, %rbx
-; CHECK-NEXT:    incl %edx
+; CHECK-NEXT:    incl %r10d
 ; CHECK-NEXT:    je .LBB1_17
 ; CHECK-NEXT:  .LBB1_2: # %for.cond1thread-pre-split
 ; CHECK-NEXT:    # =>This Loop Header: Depth=1
@@ -178,27 +178,27 @@
 ; CHECK-NEXT:    je .LBB1_14
 ; CHECK-NEXT:  # %bb.5: # %vector.memcheck
 ; CHECK-NEXT:    # in Loop: Header=BB1_2 Depth=1
-; CHECK-NEXT:    movq {{[-0-9]+}}(%r{{[sb]}}p), %r10 # 8-byte Reload
-; CHECK-NEXT:    imulq %rsi, %r10
-; CHECK-NEXT:    leaq (%r12,%r10), %rax
-; CHECK-NEXT:    leaq (%rax,%r9,8), %rax
+; CHECK-NEXT:    movq {{[-0-9]+}}(%r{{[sb]}}p), %rax # 8-byte Reload
+; CHECK-NEXT:    imulq %rsi, %rax
+; CHECK-NEXT:    leaq (%r12,%rax), %rdx
+; CHECK-NEXT:    leaq (%rdx,%r9,8), %r11
 ; CHECK-NEXT:    testq %r9, %r9
-; CHECK-NEXT:    movq $-1, %r11
-; CHECK-NEXT:    cmovnsq %r9, %r11
-; CHECK-NEXT:    cmpq %rcx, %rax
+; CHECK-NEXT:    movq $-1, %rdx
+; CHECK-NEXT:    cmovnsq %r9, %rdx
+; CHECK-NEXT:    cmpq %rcx, %r11
 ; CHECK-NEXT:    jae .LBB1_7
 ; CHECK-NEXT:  # %bb.6: # %vector.memcheck
 ; CHECK-NEXT:    # in Loop: Header=BB1_2 Depth=1
-; CHECK-NEXT:    addq {{[-0-9]+}}(%r{{[sb]}}p), %r10 # 8-byte Folded Reload
-; CHECK-NEXT:    leaq (%r10,%r11,8), %rax
+; CHECK-NEXT:    addq {{[-0-9]+}}(%r{{[sb]}}p), %rax # 8-byte Folded Reload
+; CHECK-NEXT:    leaq (%rax,%rdx,8), %rax
 ; CHECK-NEXT:    cmpq %rcx, %rax
 ; CHECK-NEXT:    ja .LBB1_14
 ; CHECK-NEXT:  .LBB1_7: # %vector.body.preheader
 ; CHECK-NEXT:    # in Loop: Header=BB1_2 Depth=1
-; CHECK-NEXT:    leaq -4(%r8), %rax
-; CHECK-NEXT:    movq %rax, %r10
-; CHECK-NEXT:    shrq $2, %r10
-; CHECK-NEXT:    btl $2, %eax
+; CHECK-NEXT:    leaq -4(%r8), %rdx
+; CHECK-NEXT:    movq %rdx, %rax
+; CHECK-NEXT:    shrq $2, %rax
+; CHECK-NEXT:    btl $2, %edx
 ; CHECK-NEXT:    jb .LBB1_8
 ; CHECK-NEXT:  # %bb.9: # %vector.body.prol.preheader
 ; CHECK-NEXT:    # in Loop: Header=BB1_2 Depth=1
@@ -207,30 +207,31 @@
 ; CHECK-NEXT:    movdqu %xmm0, (%rdi,%r9,8)
 ; CHECK-NEXT:    movdqu %xmm0, 16(%rdi,%r9,8)
 ; CHECK-NEXT:    movl $4, %r11d
-; CHECK-NEXT:    testq %r10, %r10
+; CHECK-NEXT:    testq %rax, %rax
 ; CHECK-NEXT:    jne .LBB1_11
 ; CHECK-NEXT:    jmp .LBB1_13
 ; CHECK-NEXT:  .LBB1_8: # in Loop: Header=BB1_2 Depth=1
 ; CHECK-NEXT:    xorl %r11d, %r11d
-; CHECK-NEXT:    testq %r10, %r10
+; CHECK-NEXT:    testq %rax, %rax
 ; CHECK-NEXT:    je .LBB1_13
 ; CHECK-NEXT:  .LBB1_11: # %vector.body.preheader.new
 ; CHECK-NEXT:    # in Loop: Header=BB1_2 Depth=1
 ; CHECK-NEXT:    movq {{.*#+}} xmm0 = mem[0],zero
 ; CHECK-NEXT:    pshufd {{.*#+}} xmm0 = xmm0[0,1,0,1]
-; CHECK-NEXT:    movq %r11, %rax
+; CHECK-NEXT:    leaq -4(%r11), %rax
 ; CHECK-NEXT:    subq %r8, %rax
-; CHECK-NEXT:    addq %r9, %r11
-; CHECK-NEXT:    leaq (%rbx,%r11,8), %r11
+; CHECK-NEXT:    addq $4, %rax
+; CHECK-NEXT:    leaq -4(%r11,%r9), %rdx
+; CHECK-NEXT:    leaq (%rbx,%rdx,8), %rdx
 ; CHECK-NEXT:    .p2align 4, 0x90
 ; CHECK-NEXT:  .LBB1_12: # %vector.body
 ; CHECK-NEXT:    # Parent Loop BB1_2 Depth=1
 ; CHECK-NEXT:    # => This Inner Loop Header: Depth=2
-; CHECK-NEXT:    movdqu %xmm0, -32(%r11)
-; CHECK-NEXT:    movdqu %xmm0, -16(%r11)
-; CHECK-NEXT:    movdqu %xmm0, (%r11)
-; CHECK-NEXT:    movdqu %xmm0, 16(%r11)
-; CHECK-NEXT:    addq $64, %r11
+; CHECK-NEXT:    movdqu %xmm0, -16(%rdx)
+; CHECK-NEXT:    movdqu %xmm0, (%rdx)
+; CHECK-NEXT:    movdqu %xmm0, 16(%rdx)
+; CHECK-NEXT:    movdqu %xmm0, 32(%rdx)
+; CHECK-NEXT:    addq $64, %rdx
 ; CHECK-NEXT:    addq $8, %rax
 ; CHECK-NEXT:    jne .LBB1_12
 ; CHECK-NEXT:  .LBB1_13: # %middle.block
diff --git a/llvm/test/Transforms/IndVarSimplify/lftr-pr20680.ll b/llvm/test/Transforms/IndVarSimplify/lftr-pr20680.ll
--- a/llvm/test/Transforms/IndVarSimplify/lftr-pr20680.ll
+++ b/llvm/test/Transforms/IndVarSimplify/lftr-pr20680.ll
@@ -38,6 +38,7 @@
 ; CHECK:       cond.false.us.us:
 ; CHECK-NEXT:    br label [[COND_END_US_US]]
 ; CHECK:       cond.end.us.us:
+; CHECK-NEXT:    [[COND_US_US:%.*]] = phi i32 [ [[DIV]], [[COND_FALSE_US_US]] ], [ [[INDVARS_IV]], [[FOR_BODY3_US_US]] ]
 ; CHECK-NEXT:    [[TMP4:%.*]] = load i32, i32* @b, align 4
 ; CHECK-NEXT:    [[CMP91_US_US:%.*]] = icmp slt i32 [[TMP4]], 1
 ; CHECK-NEXT:    br i1 [[CMP91_US_US]], label [[FOR_INC_LR_PH_US_US:%.*]], label [[FOR_COND2_LOOPEXIT_US_US:%.*]]
@@ -54,6 +55,7 @@
 ; CHECK-NEXT:    [[EXITCOND3:%.*]] = icmp ne i32 [[INC_US_US]], 1
 ; CHECK-NEXT:    br i1 [[EXITCOND3]], label [[FOR_INC_US_US]], label [[FOR_COND8_FOR_COND2_LOOPEXIT_CRIT_EDGE_US_US:%.*]]
 ; CHECK:       for.cond2.for.inc13_crit_edge.us-lcssa.us.us-lcssa.us:
+; CHECK-NEXT:    [[COND_LCSSA_PH_US_PH_US:%.*]] = phi i32 [ [[COND_US_US]], [[FOR_COND2_LOOPEXIT_US_US]] ]
 ; CHECK-NEXT:    br label [[FOR_COND2_FOR_INC13_CRIT_EDGE_US_LCSSA_US:%.*]]
 ; CHECK:       for.body3.lr.ph.split.us.split:
 ; CHECK-NEXT:    br label [[FOR_BODY3_US:%.*]]
@@ -62,6 +64,7 @@
 ; CHECK:       cond.false.us:
 ; CHECK-NEXT:    br label [[COND_END_US]]
 ; CHECK:       cond.end.us:
+; CHECK-NEXT:    [[COND_US:%.*]] = phi i32 [ [[DIV]], [[COND_FALSE_US]] ], [ [[INDVARS_IV]], [[FOR_BODY3_US]] ]
 ; CHECK-NEXT:    [[TMP6:%.*]] = load i32, i32* @b, align 4
 ; CHECK-NEXT:    [[CMP91_US:%.*]] = icmp slt i32 [[TMP6]], 1
 ; CHECK-NEXT:    br i1 [[CMP91_US]], label [[FOR_INC_LR_PH_US:%.*]], label [[FOR_COND2_LOOPEXIT_US:%.*]]
@@ -78,9 +81,10 @@
 ; CHECK-NEXT:    store i32 1, i32* @b, align 4
 ; CHECK-NEXT:    br label [[FOR_COND2_LOOPEXIT_US]]
 ; CHECK:       for.cond2.for.inc13_crit_edge.us-lcssa.us.us-lcssa:
+; CHECK-NEXT:    [[COND_LCSSA_PH_US_PH:%.*]] = phi i32 [ [[COND_US]], [[FOR_COND2_LOOPEXIT_US]] ]
 ; CHECK-NEXT:    br label [[FOR_COND2_FOR_INC13_CRIT_EDGE_US_LCSSA_US]]
 ; CHECK:       for.cond2.for.inc13_crit_edge.us-lcssa.us:
-; CHECK-NEXT:    [[COND_LCSSA_PH_US:%.*]] = phi i32 [ [[DIV]], [[FOR_COND2_FOR_INC13_CRIT_EDGE_US_LCSSA_US_US_LCSSA]] ], [ [[DIV]], [[FOR_COND2_FOR_INC13_CRIT_EDGE_US_LCSSA_US_US_LCSSA_US]] ]
+; CHECK-NEXT:    [[COND_LCSSA_PH_US:%.*]] = phi i32 [ [[COND_LCSSA_PH_US_PH]], [[FOR_COND2_FOR_INC13_CRIT_EDGE_US_LCSSA_US_US_LCSSA]] ], [ [[COND_LCSSA_PH_US_PH_US]], [[FOR_COND2_FOR_INC13_CRIT_EDGE_US_LCSSA_US_US_LCSSA_US]] ]
 ; CHECK-NEXT:    br label [[FOR_COND2_FOR_INC13_CRIT_EDGE:%.*]]
 ; CHECK:       for.body3.lr.ph.split:
 ; CHECK-NEXT:    br i1 [[TOBOOL]], label [[FOR_BODY3_LR_PH_SPLIT_SPLIT_US:%.*]], label [[FOR_BODY3_LR_PH_SPLIT_FOR_BODY3_LR_PH_SPLIT_SPLIT_CRIT_EDGE:%.*]]
diff --git a/polly/test/CodeGen/only_non_affine_error_region.ll b/polly/test/CodeGen/only_non_affine_error_region.ll
--- a/polly/test/CodeGen/only_non_affine_error_region.ll
+++ b/polly/test/CodeGen/only_non_affine_error_region.ll
@@ -5,7 +5,7 @@
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; Function Attrs: nounwind uwtable
-define void @f(i32 %argc, i32* %A) #0 {
+define void @f(i32 %argc, i32* %A, i32 %v) #0 {
 entry:
   br i1 undef, label %for.end, label %for.body
 
@@ -13,7 +13,7 @@
   br label %for.end
 
 for.end:                                          ; preds = %for.body, %entry
-  %i.2 = phi i32 [ 1, %entry ], [ 1, %for.body ]
+  %i.2 = phi i32 [ %v, %entry ], [ %v, %for.body ]
   %cmp170 = icmp eq i32 %i.2, %argc
   br i1 %cmp170, label %if.then172, label %if.end174
 
diff --git a/polly/test/CodeGen/region_multiexit_partialwrite.ll b/polly/test/CodeGen/region_multiexit_partialwrite.ll
--- a/polly/test/CodeGen/region_multiexit_partialwrite.ll
+++ b/polly/test/CodeGen/region_multiexit_partialwrite.ll
@@ -38,7 +38,7 @@
 
 
 ; CHECK:      polly.stmt.bb10.exit:
-; CHECK-NEXT:   %polly.tmp11 = phi i32 [ %p_tmp8, %polly.stmt.bb7 ], [ undef, %polly.stmt.bb9 ]
+; CHECK-NEXT:   %polly.tmp11 = phi i32 [ %18, %polly.stmt.bb7 ], [ undef, %polly.stmt.bb9 ]
 
 ; CHECK: polly.stmt.bb10.exit.Stmt_bb3__TO__bb10_Write1.partial:
 ; CHECK:   store i32 %polly.tmp11
diff --git a/polly/test/ScheduleOptimizer/SIMDInParallelFor.ll b/polly/test/ScheduleOptimizer/SIMDInParallelFor.ll
--- a/polly/test/ScheduleOptimizer/SIMDInParallelFor.ll
+++ b/polly/test/ScheduleOptimizer/SIMDInParallelFor.ll
@@ -12,17 +12,17 @@
 @b = external dso_local unnamed_addr global [1984 x [1984 x double]], align 16
 @c = external dso_local unnamed_addr global [1984 x [1984 x double]], align 16
 
-define dso_local void @main() local_unnamed_addr {
+define dso_local void @main(i1 %c0, i1 %c1, i1 %c2, i32 %v0, i32 %v1, i32 %v2) local_unnamed_addr {
 entry:
-  %cond = select i1 undef, i32 undef, i32 1984
+  %cond = select i1 %c0, i32 %v0, i32 1984
   %tmp = zext i32 %cond to i64
-  %cond63 = select i1 undef, i32 undef, i32 1984
+  %cond63 = select i1 %c1, i32 %v1, i32 1984
   %tmp1 = zext i32 %cond63 to i64
   br label %for.cond51.preheader
 
 for.cond51.preheader:
   %indvars.iv213 = phi i64 [ 0, %entry ], [ %indvars.iv.next214, %for.inc98 ]
-  %cond73 = select i1 undef, i32 undef, i32 1984
+  %cond73 = select i1 %c2, i32 %v2, i32 1984
   %tmp2 = zext i32 %cond73 to i64
   br label %for.cond56.preheader
 
diff --git a/polly/test/ScopInfo/parameter_with_constant_factor_in_add.ll b/polly/test/ScopInfo/parameter_with_constant_factor_in_add.ll
--- a/polly/test/ScopInfo/parameter_with_constant_factor_in_add.ll
+++ b/polly/test/ScopInfo/parameter_with_constant_factor_in_add.ll
@@ -10,6 +10,8 @@
 ; ModuleID = 'bugpoint-reduced-simplified.bc'
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
+@constant = dso_local global i8 0, align 4
+
 ; Function Attrs: nounwind uwtable
 define void @BPredPartitionCost(i32* %A) #0 {
 entry:
@@ -17,7 +19,7 @@
   br label %for.cond261.preheader.lr.ph
 
 for.cond261.preheader.lr.ph:                      ; preds = %entry
-  %smax188 = select i1 undef, i32 undef, i32 -9
+  %smax188 = select i1 undef, i32 undef, i32 ptrtoint (i8* @constant to i32)
   %0 = sub i32 0, %smax188
   %1 = sext i32 %0 to i64
   %2 = add i64 %1, -1
diff --git a/polly/test/ScopInfo/phi_after_error_block.ll b/polly/test/ScopInfo/phi_after_error_block.ll
--- a/polly/test/ScopInfo/phi_after_error_block.ll
+++ b/polly/test/ScopInfo/phi_after_error_block.ll
@@ -2,7 +2,7 @@
 
 declare void @bar()
 
-define void @foo(float* %A, i64 %p) {
+define void @foo(float* %A, i64 %p, i64 %iv, i64 %iv2) {
 start:
    br label %next
 
@@ -18,7 +18,7 @@
    br label %merge
 
 merge:
-   %phi = phi i64 [0, %error], [1, %ok]
+   %phi = phi i64 [%iv, %error], [%iv2, %ok]
    store float 42.0, float* %A
    %cmp = icmp eq i64 %phi, %p
    br i1 %cmp, label %loop, label %exit
@@ -37,25 +37,25 @@
 ; CHECK:      Statements {
 ; CHECK-NEXT: 	Stmt_ok
 ; CHECK-NEXT:         Domain :=
-; CHECK-NEXT:             [p] -> { Stmt_ok[] : p > 0 };
+; CHECK-NEXT:             [p, iv2] -> { Stmt_ok[] : p > 0 };
 ; CHECK-NEXT:         Schedule :=
-; CHECK-NEXT:             [p] -> { Stmt_ok[] -> [0, 0] };
+; CHECK-NEXT:             [p, iv2] -> { Stmt_ok[] -> [0, 0] };
 ; CHECK-NEXT:         MustWriteAccess :=	[Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:             [p] -> { Stmt_ok[] -> MemRef_phi__phi[] };
+; CHECK-NEXT:             [p, iv2] -> { Stmt_ok[] -> MemRef_phi__phi[] };
 ; CHECK-NEXT: 	Stmt_merge
 ; CHECK-NEXT:         Domain :=
-; CHECK-NEXT:             [p] -> { Stmt_merge[] };
+; CHECK-NEXT:             [p, iv2] -> { Stmt_merge[] };
 ; CHECK-NEXT:         Schedule :=
-; CHECK-NEXT:             [p] -> { Stmt_merge[] -> [1, 0] };
+; CHECK-NEXT:             [p, iv2] -> { Stmt_merge[] -> [1, 0] };
 ; CHECK-NEXT:         ReadAccess :=	[Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:             [p] -> { Stmt_merge[] -> MemRef_phi__phi[] };
+; CHECK-NEXT:             [p, iv2] -> { Stmt_merge[] -> MemRef_phi__phi[] };
 ; CHECK-NEXT:         MustWriteAccess :=	[Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:             [p] -> { Stmt_merge[] -> MemRef_A[0] };
+; CHECK-NEXT:             [p, iv2] -> { Stmt_merge[] -> MemRef_A[0] };
 ; CHECK-NEXT: 	Stmt_loop
 ; CHECK-NEXT:         Domain :=
-; CHECK-NEXT:             [p] -> { Stmt_loop[i0] : p = 1 and 0 <= i0 <= 1025 };
+; CHECK-NEXT:             [p, iv2] -> { Stmt_loop[i0] : iv2 = p and 0 <= i0 <= 1025 };
 ; CHECK-NEXT:         Schedule :=
-; CHECK-NEXT:             [p] -> { Stmt_loop[i0] -> [2, i0] };
+; CHECK-NEXT:             [p, iv2] -> { Stmt_loop[i0] -> [2, i0] };
 ; CHECK-NEXT:         MustWriteAccess :=	[Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:             [p] -> { Stmt_loop[i0] -> MemRef_A[0] };
+; CHECK-NEXT:             [p, iv2] -> { Stmt_loop[i0] -> MemRef_A[0] };
 ; CHECK-NEXT: }