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