llvm/test/Analysis/ScalarEvolution/nsw.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
   2 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
   3
   4 ; The addrecs in this loop are analyzable only by using nsw information.
   5
   6 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64"
   7
   8 define void @test1(ptr %p) nounwind {
   9 ; CHECK-LABEL: 'test1'
  10 ; CHECK-NEXT:  Classifying expressions for: @test1
  11 ; CHECK-NEXT:    %i.01 = phi i32 [ %tmp8, %bb1 ], [ 0, %bb.nph ]
  12 ; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%bb> U: [0,-2147483648) S: [0,-2147483648) Exits: <<Unknown>> LoopDispositions: { %bb: Computable }
  13 ; CHECK-NEXT:    %tmp2 = sext i32 %i.01 to i64
  14 ; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%bb> U: [0,-9223372036854775808) S: [0,-9223372036854775808) Exits: <<Unknown>> LoopDispositions: { %bb: Computable }
  15 ; CHECK-NEXT:    %tmp3 = getelementptr double, ptr %p, i64 %tmp2
  16 ; CHECK-NEXT:    --> {%p,+,8}<%bb> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb: Computable }
  17 ; CHECK-NEXT:    %tmp6 = sext i32 %i.01 to i64
  18 ; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%bb> U: [0,-9223372036854775808) S: [0,-9223372036854775808) Exits: <<Unknown>> LoopDispositions: { %bb: Computable }
  19 ; CHECK-NEXT:    %tmp7 = getelementptr double, ptr %p, i64 %tmp6
  20 ; CHECK-NEXT:    --> {%p,+,8}<%bb> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb: Computable }
  21 ; CHECK-NEXT:    %tmp8 = add nsw i32 %i.01, 1
  22 ; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%bb> U: [1,-2147483648) S: [1,-2147483648) Exits: <<Unknown>> LoopDispositions: { %bb: Computable }
  23 ; CHECK-NEXT:    %p.gep = getelementptr double, ptr %p, i32 %tmp8
  24 ; CHECK-NEXT:    --> {(8 + %p),+,8}<%bb> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb: Computable }
  25 ; CHECK-NEXT:    %phitmp = sext i32 %tmp8 to i64
  26 ; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%bb> U: [1,-9223372036854775808) S: [1,-9223372036854775808) Exits: <<Unknown>> LoopDispositions: { %bb: Computable }
  27 ; CHECK-NEXT:    %tmp9 = getelementptr inbounds double, ptr %p, i64 %phitmp
  28 ; CHECK-NEXT:    --> {(8 + %p),+,8}<%bb> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb: Computable }
  29 ; CHECK-NEXT:  Determining loop execution counts for: @test1
  30 ; CHECK-NEXT:  Loop %bb: Unpredictable backedge-taken count.
  31 ; CHECK-NEXT:  Loop %bb: Unpredictable constant max backedge-taken count.
  32 ; CHECK-NEXT:  Loop %bb: Unpredictable symbolic max backedge-taken count.
  33 ;
  34 entry:
  35   %tmp = load double, ptr %p, align 8           ; <double> [#uses=1]
  36   %tmp1 = fcmp ogt double %tmp, 2.000000e+00            ; <i1> [#uses=1]
  37   br i1 %tmp1, label %bb.nph, label %return
  38
  39 bb.nph:         ; preds = %entry
  40   br label %bb
  41
  42 bb:             ; preds = %bb1, %bb.nph
  43   %i.01 = phi i32 [ %tmp8, %bb1 ], [ 0, %bb.nph ]               ; <i32> [#uses=3]
  44   %tmp2 = sext i32 %i.01 to i64         ; <i64> [#uses=1]
  45   %tmp3 = getelementptr double, ptr %p, i64 %tmp2               ; <ptr> [#uses=1]
  46   %tmp4 = load double, ptr %tmp3, align 8               ; <double> [#uses=1]
  47   %tmp5 = fmul double %tmp4, 9.200000e+00               ; <double> [#uses=1]
  48   %tmp6 = sext i32 %i.01 to i64         ; <i64> [#uses=1]
  49   %tmp7 = getelementptr double, ptr %p, i64 %tmp6               ; <ptr> [#uses=1]
  50   store double %tmp5, ptr %tmp7, align 8
  51   %tmp8 = add nsw i32 %i.01, 1          ; <i32> [#uses=2]
  52   %p.gep = getelementptr double, ptr %p, i32 %tmp8
  53   %p.val = load double, ptr %p.gep
  54   br label %bb1
  55
  56 bb1:            ; preds = %bb
  57   %phitmp = sext i32 %tmp8 to i64               ; <i64> [#uses=1]
  58   %tmp9 = getelementptr inbounds double, ptr %p, i64 %phitmp            ; <ptr> [#uses=1]
  59   %tmp10 = load double, ptr %tmp9, align 8              ; <double> [#uses=1]
  60   %tmp11 = fcmp ogt double %tmp10, 2.000000e+00         ; <i1> [#uses=1]
  61   br i1 %tmp11, label %bb, label %bb1.return_crit_edge
  62
  63 bb1.return_crit_edge:           ; preds = %bb1
  64   br label %return
  65
  66 return:         ; preds = %bb1.return_crit_edge, %entry
  67   ret void
  68 }
  69
  70 define void @test2(ptr %begin, ptr %end) ssp {
  71 ; CHECK-LABEL: 'test2'
  72 ; CHECK-NEXT:  Classifying expressions for: @test2
  73 ; CHECK-NEXT:    %__first.addr.02.i.i = phi ptr [ %begin, %for.body.lr.ph.i.i ], [ %ptrincdec.i.i, %for.body.i.i ]
  74 ; CHECK-NEXT:    --> {%begin,+,4}<nuw><%for.body.i.i> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4))<nuw> + %begin) LoopDispositions: { %for.body.i.i: Computable }
  75 ; CHECK-NEXT:    %ptrincdec.i.i = getelementptr inbounds i32, ptr %__first.addr.02.i.i, i64 1
  76 ; CHECK-NEXT:    --> {(4 + %begin),+,4}<nuw><%for.body.i.i> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4))<nuw> + %begin) LoopDispositions: { %for.body.i.i: Computable }
  77 ; CHECK-NEXT:  Determining loop execution counts for: @test2
  78 ; CHECK-NEXT:  Loop %for.body.i.i: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)
  79 ; CHECK-NEXT:  Loop %for.body.i.i: constant max backedge-taken count is i64 4611686018427387903
  80 ; CHECK-NEXT:  Loop %for.body.i.i: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)
  81 ; CHECK-NEXT:  Loop %for.body.i.i: Trip multiple is 1
  82 ;
  83 entry:
  84   %cmp1.i.i = icmp eq ptr %begin, %end
  85   br i1 %cmp1.i.i, label %_ZSt4fillIPiiEvT_S1_RKT0_.exit, label %for.body.lr.ph.i.i
  86
  87 for.body.lr.ph.i.i:                               ; preds = %entry
  88   br label %for.body.i.i
  89
  90 for.body.i.i:                                     ; preds = %for.body.i.i, %for.body.lr.ph.i.i
  91   %__first.addr.02.i.i = phi ptr [ %begin, %for.body.lr.ph.i.i ], [ %ptrincdec.i.i, %for.body.i.i ]
  92   store i32 0, ptr %__first.addr.02.i.i, align 4
  93   %ptrincdec.i.i = getelementptr inbounds i32, ptr %__first.addr.02.i.i, i64 1
  94   %cmp.i.i = icmp eq ptr %ptrincdec.i.i, %end
  95   br i1 %cmp.i.i, label %for.cond.for.end_crit_edge.i.i, label %for.body.i.i
  96
  97 for.cond.for.end_crit_edge.i.i:                   ; preds = %for.body.i.i
  98   br label %_ZSt4fillIPiiEvT_S1_RKT0_.exit
  99
 100 _ZSt4fillIPiiEvT_S1_RKT0_.exit:                   ; preds = %entry, %for.cond.for.end_crit_edge.i.i
 101   ret void
 102 }
 103
 104 ; Various checks for inbounds geps.
 105 define void @test3(ptr %begin, ptr %end) nounwind ssp {
 106 ; CHECK-LABEL: 'test3'
 107 ; CHECK-NEXT:  Classifying expressions for: @test3
 108 ; CHECK-NEXT:    %indvar.i.i = phi i64 [ %tmp, %for.body.i.i ], [ 0, %entry ]
 109 ; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body.i.i> U: [0,4611686018427387904) S: [0,4611686018427387904) Exits: ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4) LoopDispositions: { %for.body.i.i: Computable }
 110 ; CHECK-NEXT:    %tmp = add nsw i64 %indvar.i.i, 1
 111 ; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%for.body.i.i> U: [1,4611686018427387905) S: [1,4611686018427387905) Exits: (1 + ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4))<nuw><nsw> LoopDispositions: { %for.body.i.i: Computable }
 112 ; CHECK-NEXT:    %ptrincdec.i.i = getelementptr inbounds i32, ptr %begin, i64 %tmp
 113 ; CHECK-NEXT:    --> {(4 + %begin),+,4}<nuw><%for.body.i.i> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4))<nuw> + %begin) LoopDispositions: { %for.body.i.i: Computable }
 114 ; CHECK-NEXT:    %__first.addr.08.i.i = getelementptr inbounds i32, ptr %begin, i64 %indvar.i.i
 115 ; CHECK-NEXT:    --> {%begin,+,4}<nuw><%for.body.i.i> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4))<nuw> + %begin) LoopDispositions: { %for.body.i.i: Computable }
 116 ; CHECK-NEXT:  Determining loop execution counts for: @test3
 117 ; CHECK-NEXT:  Loop %for.body.i.i: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)
 118 ; CHECK-NEXT:  Loop %for.body.i.i: constant max backedge-taken count is i64 4611686018427387903
 119 ; CHECK-NEXT:  Loop %for.body.i.i: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)
 120 ; CHECK-NEXT:  Loop %for.body.i.i: Trip multiple is 1
 121 ;
 122 entry:
 123   %cmp7.i.i = icmp eq ptr %begin, %end
 124   br i1 %cmp7.i.i, label %_ZSt4fillIPiiEvT_S1_RKT0_.exit, label %for.body.i.i
 125
 126 for.body.i.i:                                     ; preds = %entry, %for.body.i.i
 127   %indvar.i.i = phi i64 [ %tmp, %for.body.i.i ], [ 0, %entry ]
 128   %tmp = add nsw i64 %indvar.i.i, 1
 129   %ptrincdec.i.i = getelementptr inbounds i32, ptr %begin, i64 %tmp
 130   %__first.addr.08.i.i = getelementptr inbounds i32, ptr %begin, i64 %indvar.i.i
 131   store i32 0, ptr %__first.addr.08.i.i, align 4
 132   %cmp.i.i = icmp eq ptr %ptrincdec.i.i, %end
 133   br i1 %cmp.i.i, label %_ZSt4fillIPiiEvT_S1_RKT0_.exit, label %for.body.i.i
 134 _ZSt4fillIPiiEvT_S1_RKT0_.exit:                   ; preds = %for.body.i.i, %entry
 135   ret void
 136 }
 137
 138 ; A single AddExpr exists for (%a + %b), which is not always <nsw>.
 139 define i32 @addnsw(i32 %a, i32 %b) nounwind ssp {
 140 ; CHECK-LABEL: 'addnsw'
 141 ; CHECK-NEXT:  Classifying expressions for: @addnsw
 142 ; CHECK-NEXT:    %tmp = add i32 %a, %b
 143 ; CHECK-NEXT:    --> (%a + %b) U: full-set S: full-set
 144 ; CHECK-NEXT:    %tmp2 = add nsw i32 %a, %b
 145 ; CHECK-NEXT:    --> (%a + %b) U: full-set S: full-set
 146 ; CHECK-NEXT:    %result = phi i32 [ %a, %entry ], [ %tmp2, %greater ]
 147 ; CHECK-NEXT:    --> %result U: full-set S: full-set
 148 ; CHECK-NEXT:  Determining loop execution counts for: @addnsw
 149 ;
 150 entry:
 151   %tmp = add i32 %a, %b
 152   %cmp = icmp sgt i32 %tmp, 0
 153   br i1 %cmp, label %greater, label %exit
 154
 155 greater:
 156   %tmp2 = add nsw i32 %a, %b
 157   br label %exit
 158
 159 exit:
 160   %result = phi i32 [ %a, %entry ], [ %tmp2, %greater ]
 161   ret i32 %result
 162 }
 163
 164 define i32 @PR12375(ptr readnone %arg) {
 165 ; CHECK-LABEL: 'PR12375'
 166 ; CHECK-NEXT:  Classifying expressions for: @PR12375
 167 ; CHECK-NEXT:    %tmp = getelementptr inbounds i32, ptr %arg, i64 2
 168 ; CHECK-NEXT:    --> (8 + %arg)<nuw> U: [8,0) S: [8,0)
 169 ; CHECK-NEXT:    %tmp2 = phi ptr [ %arg, %bb ], [ %tmp5, %bb1 ]
 170 ; CHECK-NEXT:    --> {%arg,+,4}<nuw><%bb1> U: full-set S: full-set Exits: (4 + %arg)<nuw> LoopDispositions: { %bb1: Computable }
 171 ; CHECK-NEXT:    %tmp3 = phi i32 [ 0, %bb ], [ %tmp4, %bb1 ]
 172 ; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%bb1> U: [0,2) S: [0,2) Exits: 1 LoopDispositions: { %bb1: Computable }
 173 ; CHECK-NEXT:    %tmp4 = add nsw i32 %tmp3, 1
 174 ; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%bb1> U: [1,3) S: [1,3) Exits: 2 LoopDispositions: { %bb1: Computable }
 175 ; CHECK-NEXT:    %tmp5 = getelementptr inbounds i32, ptr %tmp2, i64 1
 176 ; CHECK-NEXT:    --> {(4 + %arg)<nuw>,+,4}<nuw><%bb1> U: [4,0) S: [4,0) Exits: (8 + %arg)<nuw> LoopDispositions: { %bb1: Computable }
 177 ; CHECK-NEXT:  Determining loop execution counts for: @PR12375
 178 ; CHECK-NEXT:  Loop %bb1: backedge-taken count is i64 1
 179 ; CHECK-NEXT:  Loop %bb1: constant max backedge-taken count is i64 1
 180 ; CHECK-NEXT:  Loop %bb1: symbolic max backedge-taken count is i64 1
 181 ; CHECK-NEXT:  Loop %bb1: Trip multiple is 2
 182 ;
 183 bb:
 184   %tmp = getelementptr inbounds i32, ptr %arg, i64 2
 185   br label %bb1
 186
 187 bb1:                                              ; preds = %bb1, %bb
 188   %tmp2 = phi ptr [ %arg, %bb ], [ %tmp5, %bb1 ]
 189   %tmp3 = phi i32 [ 0, %bb ], [ %tmp4, %bb1 ]
 190   %tmp4 = add nsw i32 %tmp3, 1
 191   %tmp5 = getelementptr inbounds i32, ptr %tmp2, i64 1
 192   %tmp6 = icmp ult ptr %tmp5, %tmp
 193   br i1 %tmp6, label %bb1, label %bb7
 194
 195 bb7:                                              ; preds = %bb1
 196   ret i32 %tmp4
 197 }
 198
 199 define void @PR12376(ptr nocapture %arg, ptr nocapture %arg1)  {
 200 ; CHECK-LABEL: 'PR12376'
 201 ; CHECK-NEXT:  Classifying expressions for: @PR12376
 202 ; CHECK-NEXT:    %tmp = phi ptr [ %arg, %bb ], [ %tmp4, %bb2 ]
 203 ; CHECK-NEXT:    --> {%arg,+,4}<nuw><%bb2> U: full-set S: full-set Exits: ((4 * ((-1 + (-1 * (ptrtoint ptr %arg to i64)) + ((4 + (ptrtoint ptr %arg to i64))<nuw> umax (ptrtoint ptr %arg1 to i64))) /u 4))<nuw> + %arg) LoopDispositions: { %bb2: Computable }
 204 ; CHECK-NEXT:    %tmp4 = getelementptr inbounds i32, ptr %tmp, i64 1
 205 ; CHECK-NEXT:    --> {(4 + %arg)<nuw>,+,4}<nuw><%bb2> U: [4,0) S: [4,0) Exits: (4 + (4 * ((-1 + (-1 * (ptrtoint ptr %arg to i64)) + ((4 + (ptrtoint ptr %arg to i64))<nuw> umax (ptrtoint ptr %arg1 to i64))) /u 4))<nuw> + %arg) LoopDispositions: { %bb2: Computable }
 206 ; CHECK-NEXT:  Determining loop execution counts for: @PR12376
 207 ; CHECK-NEXT:  Loop %bb2: backedge-taken count is ((-1 + (-1 * (ptrtoint ptr %arg to i64)) + ((4 + (ptrtoint ptr %arg to i64))<nuw> umax (ptrtoint ptr %arg1 to i64))) /u 4)
 208 ; CHECK-NEXT:  Loop %bb2: constant max backedge-taken count is i64 4611686018427387902
 209 ; CHECK-NEXT:  Loop %bb2: symbolic max backedge-taken count is ((-1 + (-1 * (ptrtoint ptr %arg to i64)) + ((4 + (ptrtoint ptr %arg to i64))<nuw> umax (ptrtoint ptr %arg1 to i64))) /u 4)
 210 ; CHECK-NEXT:  Loop %bb2: Trip multiple is 1
 211 ;
 212 bb:
 213   br label %bb2
 214
 215 bb2:                                              ; preds = %bb2, %bb
 216   %tmp = phi ptr [ %arg, %bb ], [ %tmp4, %bb2 ]
 217   %tmp4 = getelementptr inbounds i32, ptr %tmp, i64 1
 218   %tmp3 = icmp ult ptr %tmp4, %arg1
 219   br i1 %tmp3, label %bb2, label %bb5
 220
 221 bb5:                                              ; preds = %bb2
 222   ret void
 223 }
 224
 225 declare void @f(i32)
 226
 227 define void @nswnowrap(i32 %v, ptr %buf) {
 228 ; CHECK-LABEL: 'nswnowrap'
 229 ; CHECK-NEXT:  Classifying expressions for: @nswnowrap
 230 ; CHECK-NEXT:    %add = add nsw i32 %v, 1
 231 ; CHECK-NEXT:    --> (1 + %v) U: full-set S: full-set
 232 ; CHECK-NEXT:    %i.04 = phi i32 [ %v, %entry ], [ %inc, %for.body ]
 233 ; CHECK-NEXT:    --> {%v,+,1}<nsw><%for.body> U: full-set S: full-set Exits: ((1 + %v) smax %v) LoopDispositions: { %for.body: Computable }
 234 ; CHECK-NEXT:    %inc = add nsw i32 %i.04, 1
 235 ; CHECK-NEXT:    --> {(1 + %v)<nsw>,+,1}<nsw><%for.body> U: full-set S: full-set Exits: (1 + ((1 + %v)<nsw> smax %v)) LoopDispositions: { %for.body: Computable }
 236 ; CHECK-NEXT:    %buf.gep = getelementptr inbounds i32, ptr %buf, i32 %inc
 237 ; CHECK-NEXT:    --> {(4 + (4 * (sext i32 %v to i64))<nsw> + %buf),+,4}<nw><%for.body> U: full-set S: full-set Exits: (4 + (4 * (zext i32 ((-1 * %v) + ((1 + %v)<nsw> smax %v)) to i64))<nuw><nsw> + (4 * (sext i32 %v to i64))<nsw> + %buf) LoopDispositions: { %for.body: Computable }
 238 ; CHECK-NEXT:    %buf.val = load i32, ptr %buf.gep, align 4
 239 ; CHECK-NEXT:    --> %buf.val U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.body: Variant }
 240 ; CHECK-NEXT:  Determining loop execution counts for: @nswnowrap
 241 ; CHECK-NEXT:  Loop %for.body: backedge-taken count is ((-1 * %v) + ((1 + %v)<nsw> smax %v))
 242 ; CHECK-NEXT:  Loop %for.body: constant max backedge-taken count is i32 1, actual taken count either this or zero.
 243 ; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is ((-1 * %v) + ((1 + %v)<nsw> smax %v)), actual taken count either this or zero.
 244 ; CHECK-NEXT:  Loop %for.body: Trip multiple is 1
 245 ;
 246 entry:
 247   %add = add nsw i32 %v, 1
 248   br label %for.body
 249
 250 for.body:
 251   %i.04 = phi i32 [ %v, %entry ], [ %inc, %for.body ]
 252   %inc = add nsw i32 %i.04, 1
 253   %buf.gep = getelementptr inbounds i32, ptr %buf, i32 %inc
 254   %buf.val = load i32, ptr %buf.gep
 255   %cmp = icmp slt i32 %i.04, %add
 256   tail call void @f(i32 %i.04)
 257   br i1 %cmp, label %for.body, label %for.end
 258
 259 for.end:
 260   ret void
 261 }
 262
 263 ; This test checks if no-wrap flags are propagated when folding {S,+,X}+T ==> {S+T,+,X}
 264 define void @test4(i32 %arg) {
 265 ; CHECK-LABEL: 'test4'
 266 ; CHECK-NEXT:  Classifying expressions for: @test4
 267 ; CHECK-NEXT:    %array = alloca [10 x i32], align 4
 268 ; CHECK-NEXT:    --> %array U: [4,-43) S: [-9223372036854775808,9223372036854775805)
 269 ; CHECK-NEXT:    %index = phi i32 [ %inc5, %for.body ], [ %arg, %entry ]
 270 ; CHECK-NEXT:    --> {%arg,+,1}<nsw><%for.body> U: full-set S: full-set Exits: (-1 + (10 smax (1 + %arg)<nsw>))<nsw> LoopDispositions: { %for.body: Computable }
 271 ; CHECK-NEXT:    %sub = add nsw i32 %index, -2
 272 ; CHECK-NEXT:    --> {(-2 + %arg)<nsw>,+,1}<nsw><%for.body> U: full-set S: full-set Exits: (-3 + (10 smax (1 + %arg)<nsw>))<nsw> LoopDispositions: { %for.body: Computable }
 273 ; CHECK-NEXT:    %idxprom = sext i32 %sub to i64
 274 ; CHECK-NEXT:    --> {(-2 + (sext i32 %arg to i64))<nsw>,+,1}<nsw><%for.body> U: [-2147483650,4294967303) S: [-2147483650,4294967303) Exits: (-2 + (zext i32 (-1 + (-1 * %arg) + (10 smax (1 + %arg)<nsw>)) to i64) + (sext i32 %arg to i64)) LoopDispositions: { %for.body: Computable }
 275 ; CHECK-NEXT:    %arrayidx = getelementptr inbounds [10 x i32], ptr %array, i64 0, i64 %idxprom
 276 ; CHECK-NEXT:    --> {(-8 + (4 * (sext i32 %arg to i64))<nsw> + %array),+,4}<nw><%for.body> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (-8 + (4 * (zext i32 (-1 + (-1 * %arg) + (10 smax (1 + %arg)<nsw>)) to i64))<nuw><nsw> + (4 * (sext i32 %arg to i64))<nsw> + %array) LoopDispositions: { %for.body: Computable }
 277 ; CHECK-NEXT:    %data = load i32, ptr %arrayidx, align 4
 278 ; CHECK-NEXT:    --> %data U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.body: Variant }
 279 ; CHECK-NEXT:    %inc5 = add nsw i32 %index, 1
 280 ; CHECK-NEXT:    --> {(1 + %arg)<nsw>,+,1}<nsw><%for.body> U: [-2147483647,-2147483648) S: [-2147483647,-2147483648) Exits: (10 smax (1 + %arg)<nsw>) LoopDispositions: { %for.body: Computable }
 281 ; CHECK-NEXT:  Determining loop execution counts for: @test4
 282 ; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + (-1 * %arg) + (10 smax (1 + %arg)<nsw>))
 283 ; CHECK-NEXT:  Loop %for.body: constant max backedge-taken count is i32 -2147483639
 284 ; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + (-1 * %arg) + (10 smax (1 + %arg)<nsw>))
 285 ; CHECK-NEXT:  Loop %for.body: Trip multiple is 1
 286 ;
 287 entry:
 288   %array = alloca [10 x i32], align 4
 289   br label %for.body
 290
 291 for.body:
 292   %index = phi i32 [ %inc5, %for.body ], [ %arg, %entry ]
 293   %sub = add nsw i32 %index, -2
 294   %idxprom = sext i32 %sub to i64
 295   %arrayidx = getelementptr inbounds [10 x i32], ptr %array, i64 0, i64 %idxprom
 296   %data = load i32, ptr %arrayidx, align 4
 297   %inc5 = add nsw i32 %index, 1
 298   %cmp2 = icmp slt i32 %inc5, 10
 299   br i1 %cmp2, label %for.body, label %for.end
 300
 301 for.end:
 302   ret void
 303 }
 304
 305
 306 define void @bad_postinc_nsw_a(i32 %n) {
 307 ; CHECK-LABEL: 'bad_postinc_nsw_a'
 308 ; CHECK-NEXT:  Classifying expressions for: @bad_postinc_nsw_a
 309 ; CHECK-NEXT:    %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
 310 ; CHECK-NEXT:    --> {0,+,7}<nuw><nsw><%loop> U: [0,-2147483648) S: [0,-2147483648) Exits: (7 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n))) LoopDispositions: { %loop: Computable }
 311 ; CHECK-NEXT:    %iv.inc = add nsw i32 %iv, 7
 312 ; CHECK-NEXT:    --> {7,+,7}<nuw><%loop> U: [7,-3) S: [7,0) Exits: (7 + (7 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n)))) LoopDispositions: { %loop: Computable }
 313 ; CHECK-NEXT:  Determining loop execution counts for: @bad_postinc_nsw_a
 314 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n))
 315 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is i32 613566756
 316 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n))
 317 ; CHECK-NEXT:  Loop %loop: Trip multiple is 1
 318 ;
 319 entry:
 320   br label %loop
 321
 322 loop:
 323   %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
 324   %iv.inc = add nsw i32 %iv, 7
 325   %becond = icmp ult i32 %iv, %n
 326   br i1 %becond, label %loop, label %leave
 327
 328 leave:
 329   ret void
 330 }
 331
 332 ; Unlike @bad_postinc_nsw_a(), the SCEV expression of %iv.inc has <nsw> flag
 333 ; because poison can be propagated through 'and %iv.inc, 0'.
 334 define void @postinc_poison_prop_through_and(i32 %n) {
 335 ; CHECK-LABEL: 'postinc_poison_prop_through_and'
 336 ; CHECK-NEXT:  Classifying expressions for: @postinc_poison_prop_through_and
 337 ; CHECK-NEXT:    %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
 338 ; CHECK-NEXT:    --> {0,+,7}<nuw><nsw><%loop> U: [0,-2147483648) S: [0,-2147483648) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
 339 ; CHECK-NEXT:    %iv.inc = add nsw i32 %iv, 7
 340 ; CHECK-NEXT:    --> {7,+,7}<nuw><nsw><%loop> U: [7,-2147483648) S: [7,-2147483648) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
 341 ; CHECK-NEXT:    %iv.inc.and = and i32 %iv.inc, 0
 342 ; CHECK-NEXT:    --> 0 U: [0,1) S: [0,1) Exits: 0 LoopDispositions: { %loop: Invariant }
 343 ; CHECK-NEXT:  Determining loop execution counts for: @postinc_poison_prop_through_and
 344 ; CHECK-NEXT:  Loop %loop: Unpredictable backedge-taken count.
 345 ; CHECK-NEXT:  Loop %loop: Unpredictable constant max backedge-taken count.
 346 ; CHECK-NEXT:  Loop %loop: Unpredictable symbolic max backedge-taken count.
 347 ;
 348 entry:
 349   br label %loop
 350
 351 loop:
 352   %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
 353   %iv.inc = add nsw i32 %iv, 7
 354   %iv.inc.and = and i32 %iv.inc, 0
 355   %becond = icmp ult i32 %iv.inc.and, %n
 356   br i1 %becond, label %loop, label %leave
 357
 358 leave:
 359   ret void
 360 }
 361
 362 declare void @may_exit() nounwind
 363
 364 define void @pr28012(i32 %n) {
 365 ; CHECK-LABEL: 'pr28012'
 366 ; CHECK-NEXT:  Classifying expressions for: @pr28012
 367 ; CHECK-NEXT:    %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
 368 ; CHECK-NEXT:    --> {0,+,7}<nuw><nsw><%loop> U: [0,-2147483648) S: [0,-2147483648) Exits: (7 * ((-1 + (7 umax %n)) /u 7))<nuw> LoopDispositions: { %loop: Computable }
 369 ; CHECK-NEXT:    %iv.inc = add nsw i32 %iv, 7
 370 ; CHECK-NEXT:    --> {7,+,7}<nuw><%loop> U: [7,-3) S: [7,-3) Exits: (7 + (7 * ((-1 + (7 umax %n)) /u 7))<nuw>) LoopDispositions: { %loop: Computable }
 371 ; CHECK-NEXT:  Determining loop execution counts for: @pr28012
 372 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-1 + (7 umax %n)) /u 7)
 373 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is i32 613566755
 374 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-1 + (7 umax %n)) /u 7)
 375 ; CHECK-NEXT:  Loop %loop: Trip multiple is 1
 376 ;
 377 entry:
 378   br label %loop
 379
 380 loop:
 381   %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
 382   %iv.inc = add nsw i32 %iv, 7
 383   %becond = icmp ult i32 %iv.inc, %n
 384   call void @may_exit()
 385   br i1 %becond, label %loop, label %leave
 386
 387 leave:
 388   ret void
 389 }
 390
 391 define void @select_cond_poison_propagation(ptr %p, i32 %x) nounwind {
 392 ; CHECK-LABEL: 'select_cond_poison_propagation'
 393 ; CHECK-NEXT:  Classifying expressions for: @select_cond_poison_propagation
 394 ; CHECK-NEXT:    %iv = phi i32 [ %iv.next, %loop ], [ 0, %entry ]
 395 ; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%loop> U: [0,-2147483648) S: [0,-2147483648) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
 396 ; CHECK-NEXT:    %iv.next = add nsw i32 %iv, 1
 397 ; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%loop> U: [1,-2147483648) S: [1,-2147483648) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
 398 ; CHECK-NEXT:    %sel = select i1 %cmp, i32 10, i32 20
 399 ; CHECK-NEXT:    --> %sel U: [0,31) S: [0,31) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
 400 ; CHECK-NEXT:    %cond = call i1 @cond()
 401 ; CHECK-NEXT:    --> %cond U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
 402 ; CHECK-NEXT:  Determining loop execution counts for: @select_cond_poison_propagation
 403 ; CHECK-NEXT:  Loop %loop: Unpredictable backedge-taken count.
 404 ; CHECK-NEXT:  Loop %loop: Unpredictable constant max backedge-taken count.
 405 ; CHECK-NEXT:  Loop %loop: Unpredictable symbolic max backedge-taken count.
 406 ;
 407 entry:
 408   br label %loop
 409
 410 loop:
 411   %iv = phi i32 [ %iv.next, %loop ], [ 0, %entry ]
 412   %iv.next = add nsw i32 %iv, 1
 413   %cmp = icmp ult i32 %iv.next, %x
 414   %sel = select i1 %cmp, i32 10, i32 20
 415   call void @foo(i32 noundef %sel)
 416   %cond = call i1 @cond()
 417   br i1 %cond, label %loop, label %return
 418
 419 return:
 420   ret void
 421 }
 422
 423 ; {-128,+,-128} should not be <nsw>.
 424 define void @pr66066() {
 425 ; CHECK-LABEL: 'pr66066'
 426 ; CHECK-NEXT:  Classifying expressions for: @pr66066
 427 ; CHECK-NEXT:    %iv = phi i8 [ 1, %entry ], [ %iv.dec, %loop ]
 428 ; CHECK-NEXT:    --> {1,+,-1}<nsw><%loop> U: [0,2) S: [0,2) Exits: 0 LoopDispositions: { %loop: Computable }
 429 ; CHECK-NEXT:    %iv.dec = add i8 %iv, -1
 430 ; CHECK-NEXT:    --> {0,+,-1}<nsw><%loop> U: [-1,1) S: [-1,1) Exits: -1 LoopDispositions: { %loop: Computable }
 431 ; CHECK-NEXT:    %shl = shl i8 %iv, 7
 432 ; CHECK-NEXT:    --> {-128,+,-128}<%loop> U: [0,-127) S: [-128,1) Exits: 0 LoopDispositions: { %loop: Computable }
 433 ; CHECK-NEXT:  Determining loop execution counts for: @pr66066
 434 ; CHECK-NEXT:  Loop %loop: backedge-taken count is i8 1
 435 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is i8 1
 436 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is i8 1
 437 ; CHECK-NEXT:  Loop %loop: Trip multiple is 2
 438 ;
 439 entry:
 440   br label %loop
 441
 442 loop:
 443   %iv = phi i8 [ 1, %entry ], [ %iv.dec, %loop ]
 444   %iv.dec = add i8 %iv, -1
 445   %shl = shl i8 %iv, 7
 446   %cmp1 = icmp eq i8 %shl, 0
 447   br i1 %cmp1, label %exit, label %loop
 448
 449 exit:
 450   ret void
 451 }
 452
 453 declare void @print(i32)
 454
 455 declare void @foo(i32)
 456
 457 declare i1 @cond()