| blob | cb40ddda9369d9766c374d149f18c174e7a1edc3 |
1 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
2 ; RUN: opt < %s --data-layout="e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck --check-prefixes=ALL,X64 %s
3 ; RUN: opt < %s --data-layout="e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128" -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck --check-prefixes=ALL,X32 %s
5 ; While we can't treat inttoptr/ptrtoint casts as fully transparent,
6 ; for ptrtoint cast, instead of modelling it as fully opaque (unknown),
7 ; we can at least model it as zext/trunc/self of an unknown,
8 ; iff it it's argument would be modelled as unknown anyways.
10 declare void @useptr(i8*)
12 ; Simple ptrtoint of an argument, with casts to potentially different bit widths.
13 define void @ptrtoint(i8* %in, i64* %out0, i32* %out1, i16* %out2, i128* %out3) {
14 ; X64-LABEL: 'ptrtoint'
15 ; X64-NEXT: Classifying expressions for: @ptrtoint
16 ; X64-NEXT: %p0 = ptrtoint i8* %in to i64
17 ; X64-NEXT: --> (ptrtoint i8* %in to i64) U: full-set S: full-set
18 ; X64-NEXT: %p1 = ptrtoint i8* %in to i32
19 ; X64-NEXT: --> (trunc i64 (ptrtoint i8* %in to i64) to i32) U: full-set S: full-set
20 ; X64-NEXT: %p2 = ptrtoint i8* %in to i16
21 ; X64-NEXT: --> (trunc i64 (ptrtoint i8* %in to i64) to i16) U: full-set S: full-set
22 ; X64-NEXT: %p3 = ptrtoint i8* %in to i128
23 ; X64-NEXT: --> (zext i64 (ptrtoint i8* %in to i64) to i128) U: [0,18446744073709551616) S: [0,18446744073709551616)
24 ; X64-NEXT: Determining loop execution counts for: @ptrtoint
25 ;
26 ; X32-LABEL: 'ptrtoint'
27 ; X32-NEXT: Classifying expressions for: @ptrtoint
28 ; X32-NEXT: %p0 = ptrtoint i8* %in to i64
29 ; X32-NEXT: --> (zext i32 (ptrtoint i8* %in to i32) to i64) U: [0,4294967296) S: [0,4294967296)
30 ; X32-NEXT: %p1 = ptrtoint i8* %in to i32
31 ; X32-NEXT: --> (ptrtoint i8* %in to i32) U: full-set S: full-set
32 ; X32-NEXT: %p2 = ptrtoint i8* %in to i16
33 ; X32-NEXT: --> (trunc i32 (ptrtoint i8* %in to i32) to i16) U: full-set S: full-set
34 ; X32-NEXT: %p3 = ptrtoint i8* %in to i128
35 ; X32-NEXT: --> (zext i32 (ptrtoint i8* %in to i32) to i128) U: [0,4294967296) S: [0,4294967296)
36 ; X32-NEXT: Determining loop execution counts for: @ptrtoint
37 ;
38 %p0 = ptrtoint i8* %in to i64
39 %p1 = ptrtoint i8* %in to i32
40 %p2 = ptrtoint i8* %in to i16
41 %p3 = ptrtoint i8* %in to i128
42 store i64 %p0, i64* %out0
43 store i32 %p1, i32* %out1
44 store i16 %p2, i16* %out2
45 store i128 %p3, i128* %out3
46 ret void
47 }
49 ; Same, but from non-zero/non-default address space.
50 define void @ptrtoint_as1(i8 addrspace(1)* %in, i64* %out0, i32* %out1, i16* %out2, i128* %out3) {
51 ; X64-LABEL: 'ptrtoint_as1'
52 ; X64-NEXT: Classifying expressions for: @ptrtoint_as1
53 ; X64-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in to i64
54 ; X64-NEXT: --> (ptrtoint i8 addrspace(1)* %in to i64) U: full-set S: full-set
55 ; X64-NEXT: %p1 = ptrtoint i8 addrspace(1)* %in to i32
56 ; X64-NEXT: --> (trunc i64 (ptrtoint i8 addrspace(1)* %in to i64) to i32) U: full-set S: full-set
57 ; X64-NEXT: %p2 = ptrtoint i8 addrspace(1)* %in to i16
58 ; X64-NEXT: --> (trunc i64 (ptrtoint i8 addrspace(1)* %in to i64) to i16) U: full-set S: full-set
59 ; X64-NEXT: %p3 = ptrtoint i8 addrspace(1)* %in to i128
60 ; X64-NEXT: --> (zext i64 (ptrtoint i8 addrspace(1)* %in to i64) to i128) U: [0,18446744073709551616) S: [0,18446744073709551616)
61 ; X64-NEXT: Determining loop execution counts for: @ptrtoint_as1
62 ;
63 ; X32-LABEL: 'ptrtoint_as1'
64 ; X32-NEXT: Classifying expressions for: @ptrtoint_as1
65 ; X32-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in to i64
66 ; X32-NEXT: --> (zext i32 (ptrtoint i8 addrspace(1)* %in to i32) to i64) U: [0,4294967296) S: [0,4294967296)
67 ; X32-NEXT: %p1 = ptrtoint i8 addrspace(1)* %in to i32
68 ; X32-NEXT: --> (ptrtoint i8 addrspace(1)* %in to i32) U: full-set S: full-set
69 ; X32-NEXT: %p2 = ptrtoint i8 addrspace(1)* %in to i16
70 ; X32-NEXT: --> (trunc i32 (ptrtoint i8 addrspace(1)* %in to i32) to i16) U: full-set S: full-set
71 ; X32-NEXT: %p3 = ptrtoint i8 addrspace(1)* %in to i128
72 ; X32-NEXT: --> (zext i32 (ptrtoint i8 addrspace(1)* %in to i32) to i128) U: [0,4294967296) S: [0,4294967296)
73 ; X32-NEXT: Determining loop execution counts for: @ptrtoint_as1
74 ;
75 %p0 = ptrtoint i8 addrspace(1)* %in to i64
76 %p1 = ptrtoint i8 addrspace(1)* %in to i32
77 %p2 = ptrtoint i8 addrspace(1)* %in to i16
78 %p3 = ptrtoint i8 addrspace(1)* %in to i128
79 store i64 %p0, i64* %out0
80 store i32 %p1, i32* %out1
81 store i16 %p2, i16* %out2
82 store i128 %p3, i128* %out3
83 ret void
84 }
86 ; Likewise, ptrtoint of a bitcast is fine, we simply skip it.
87 define void @ptrtoint_of_bitcast(i8* %in, i64* %out0) {
88 ; X64-LABEL: 'ptrtoint_of_bitcast'
89 ; X64-NEXT: Classifying expressions for: @ptrtoint_of_bitcast
90 ; X64-NEXT: %in_casted = bitcast i8* %in to float*
91 ; X64-NEXT: --> %in U: full-set S: full-set
92 ; X64-NEXT: %p0 = ptrtoint float* %in_casted to i64
93 ; X64-NEXT: --> (ptrtoint i8* %in to i64) U: full-set S: full-set
94 ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_bitcast
95 ;
96 ; X32-LABEL: 'ptrtoint_of_bitcast'
97 ; X32-NEXT: Classifying expressions for: @ptrtoint_of_bitcast
98 ; X32-NEXT: %in_casted = bitcast i8* %in to float*
99 ; X32-NEXT: --> %in U: full-set S: full-set
100 ; X32-NEXT: %p0 = ptrtoint float* %in_casted to i64
101 ; X32-NEXT: --> (zext i32 (ptrtoint i8* %in to i32) to i64) U: [0,4294967296) S: [0,4294967296)
102 ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_bitcast
103 ;
104 %in_casted = bitcast i8* %in to float*
105 %p0 = ptrtoint float* %in_casted to i64
106 store i64 %p0, i64* %out0
107 ret void
108 }
110 ; addrspacecast is fine too, but We don't model addrspacecast, so we stop there.
111 define void @ptrtoint_of_addrspacecast(i8* %in, i64* %out0) {
112 ; X64-LABEL: 'ptrtoint_of_addrspacecast'
113 ; X64-NEXT: Classifying expressions for: @ptrtoint_of_addrspacecast
114 ; X64-NEXT: %in_casted = addrspacecast i8* %in to i8 addrspace(1)*
115 ; X64-NEXT: --> %in_casted U: full-set S: full-set
116 ; X64-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in_casted to i64
117 ; X64-NEXT: --> (ptrtoint i8 addrspace(1)* %in_casted to i64) U: full-set S: full-set
118 ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_addrspacecast
119 ;
120 ; X32-LABEL: 'ptrtoint_of_addrspacecast'
121 ; X32-NEXT: Classifying expressions for: @ptrtoint_of_addrspacecast
122 ; X32-NEXT: %in_casted = addrspacecast i8* %in to i8 addrspace(1)*
123 ; X32-NEXT: --> %in_casted U: full-set S: full-set
124 ; X32-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in_casted to i64
125 ; X32-NEXT: --> (zext i32 (ptrtoint i8 addrspace(1)* %in_casted to i32) to i64) U: [0,4294967296) S: [0,4294967296)
126 ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_addrspacecast
127 ;
128 %in_casted = addrspacecast i8* %in to i8 addrspace(1)*
129 %p0 = ptrtoint i8 addrspace(1)* %in_casted to i64
130 store i64 %p0, i64* %out0
131 ret void
132 }
134 ; inttoptr is fine too, but we don't (and can't) model inttoptr, so we stop there.
135 define void @ptrtoint_of_inttoptr(i64 %in, i64* %out0) {
136 ; X64-LABEL: 'ptrtoint_of_inttoptr'
137 ; X64-NEXT: Classifying expressions for: @ptrtoint_of_inttoptr
138 ; X64-NEXT: %in_casted = inttoptr i64 %in to i8*
139 ; X64-NEXT: --> %in_casted U: full-set S: full-set
140 ; X64-NEXT: %p0 = ptrtoint i8* %in_casted to i64
141 ; X64-NEXT: --> (ptrtoint i8* %in_casted to i64) U: full-set S: full-set
142 ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_inttoptr
143 ;
144 ; X32-LABEL: 'ptrtoint_of_inttoptr'
145 ; X32-NEXT: Classifying expressions for: @ptrtoint_of_inttoptr
146 ; X32-NEXT: %in_casted = inttoptr i64 %in to i8*
147 ; X32-NEXT: --> %in_casted U: full-set S: full-set
148 ; X32-NEXT: %p0 = ptrtoint i8* %in_casted to i64
149 ; X32-NEXT: --> (zext i32 (ptrtoint i8* %in_casted to i32) to i64) U: [0,4294967296) S: [0,4294967296)
150 ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_inttoptr
151 ;
152 %in_casted = inttoptr i64 %in to i8*
153 %p0 = ptrtoint i8* %in_casted to i64
154 store i64 %p0, i64* %out0
155 ret void
156 }
158 ; A constant pointer is fine
159 define void @ptrtoint_of_nullptr(i64* %out0) {
160 ; ALL-LABEL: 'ptrtoint_of_nullptr'
161 ; ALL-NEXT: Classifying expressions for: @ptrtoint_of_nullptr
162 ; ALL-NEXT: %p0 = ptrtoint i8* null to i64
163 ; ALL-NEXT: --> 0 U: [0,1) S: [0,1)
164 ; ALL-NEXT: Determining loop execution counts for: @ptrtoint_of_nullptr
165 ;
166 %p0 = ptrtoint i8* null to i64
167 store i64 %p0, i64* %out0
168 ret void
169 }
171 ; A constant inttoptr argument of an ptrtoint is still bad.
172 define void @ptrtoint_of_constantexpr_inttoptr(i64* %out0) {
173 ; X64-LABEL: 'ptrtoint_of_constantexpr_inttoptr'
174 ; X64-NEXT: Classifying expressions for: @ptrtoint_of_constantexpr_inttoptr
175 ; X64-NEXT: %p0 = ptrtoint i8* inttoptr (i64 42 to i8*) to i64
176 ; X64-NEXT: --> (ptrtoint i8* inttoptr (i64 42 to i8*) to i64) U: [42,43) S: [42,43)
177 ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_constantexpr_inttoptr
178 ;
179 ; X32-LABEL: 'ptrtoint_of_constantexpr_inttoptr'
180 ; X32-NEXT: Classifying expressions for: @ptrtoint_of_constantexpr_inttoptr
181 ; X32-NEXT: %p0 = ptrtoint i8* inttoptr (i64 42 to i8*) to i64
182 ; X32-NEXT: --> (zext i32 (ptrtoint i8* inttoptr (i64 42 to i8*) to i32) to i64) U: [42,43) S: [42,43)
183 ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_constantexpr_inttoptr
184 ;
185 %p0 = ptrtoint i8* inttoptr (i64 42 to i8*) to i64
186 store i64 %p0, i64* %out0
187 ret void
188 }
190 ; ptrtoint of GEP is fine.
191 define void @ptrtoint_of_gep(i8* %in, i64* %out0) {
192 ; X64-LABEL: 'ptrtoint_of_gep'
193 ; X64-NEXT: Classifying expressions for: @ptrtoint_of_gep
194 ; X64-NEXT: %in_adj = getelementptr inbounds i8, i8* %in, i64 42
195 ; X64-NEXT: --> (42 + %in) U: full-set S: full-set
196 ; X64-NEXT: %p0 = ptrtoint i8* %in_adj to i64
197 ; X64-NEXT: --> (42 + (ptrtoint i8* %in to i64)) U: full-set S: full-set
198 ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_gep
199 ;
200 ; X32-LABEL: 'ptrtoint_of_gep'
201 ; X32-NEXT: Classifying expressions for: @ptrtoint_of_gep
202 ; X32-NEXT: %in_adj = getelementptr inbounds i8, i8* %in, i64 42
203 ; X32-NEXT: --> (42 + %in) U: full-set S: full-set
204 ; X32-NEXT: %p0 = ptrtoint i8* %in_adj to i64
205 ; X32-NEXT: --> (zext i32 (42 + (ptrtoint i8* %in to i32)) to i64) U: [0,4294967296) S: [0,4294967296)
206 ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_gep
207 ;
208 %in_adj = getelementptr inbounds i8, i8* %in, i64 42
209 %p0 = ptrtoint i8* %in_adj to i64
210 store i64 %p0, i64* %out0
211 ret void
212 }
214 ; It seems, we can't get ptrtoint of mul/udiv, or at least it's hard to come up with a test case.
216 ; ptrtoint of AddRec
217 define void @ptrtoint_of_addrec(i32* %in, i32 %count) {
218 ; X64-LABEL: 'ptrtoint_of_addrec'
219 ; X64-NEXT: Classifying expressions for: @ptrtoint_of_addrec
220 ; X64-NEXT: %i3 = zext i32 %count to i64
221 ; X64-NEXT: --> (zext i32 %count to i64) U: [0,4294967296) S: [0,4294967296)
222 ; X64-NEXT: %i6 = phi i64 [ 0, %entry ], [ %i9, %loop ]
223 ; X64-NEXT: --> {0,+,1}<nuw><nsw><%loop> U: [0,-9223372036854775808) S: [0,-9223372036854775808) Exits: (-1 + (zext i32 %count to i64))<nsw> LoopDispositions: { %loop: Computable }
224 ; X64-NEXT: %i7 = getelementptr inbounds i32, i32* %in, i64 %i6
225 ; X64-NEXT: --> {%in,+,4}<%loop> U: full-set S: full-set Exits: (-4 + (4 * (zext i32 %count to i64))<nuw><nsw> + %in) LoopDispositions: { %loop: Computable }
226 ; X64-NEXT: %i8 = ptrtoint i32* %i7 to i64
227 ; X64-NEXT: --> {(ptrtoint i32* %in to i64),+,4}<%loop> U: full-set S: full-set Exits: (-4 + (4 * (zext i32 %count to i64))<nuw><nsw> + (ptrtoint i32* %in to i64)) LoopDispositions: { %loop: Computable }
228 ; X64-NEXT: %i9 = add nuw nsw i64 %i6, 1
229 ; X64-NEXT: --> {1,+,1}<nuw><%loop> U: [1,0) S: [1,0) Exits: (zext i32 %count to i64) LoopDispositions: { %loop: Computable }
230 ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_addrec
231 ; X64-NEXT: Loop %loop: backedge-taken count is (-1 + (zext i32 %count to i64))<nsw>
232 ; X64-NEXT: Loop %loop: max backedge-taken count is -1
233 ; X64-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (zext i32 %count to i64))<nsw>
234 ; X64-NEXT: Predicates:
235 ; X64: Loop %loop: Trip multiple is 1
236 ;
237 ; X32-LABEL: 'ptrtoint_of_addrec'
238 ; X32-NEXT: Classifying expressions for: @ptrtoint_of_addrec
239 ; X32-NEXT: %i3 = zext i32 %count to i64
240 ; X32-NEXT: --> (zext i32 %count to i64) U: [0,4294967296) S: [0,4294967296)
241 ; X32-NEXT: %i6 = phi i64 [ 0, %entry ], [ %i9, %loop ]
242 ; X32-NEXT: --> {0,+,1}<nuw><nsw><%loop> U: [0,-9223372036854775808) S: [0,-9223372036854775808) Exits: (-1 + (zext i32 %count to i64))<nsw> LoopDispositions: { %loop: Computable }
243 ; X32-NEXT: %i7 = getelementptr inbounds i32, i32* %in, i64 %i6
244 ; X32-NEXT: --> {%in,+,4}<%loop> U: full-set S: full-set Exits: (-4 + (4 * %count) + %in) LoopDispositions: { %loop: Computable }
245 ; X32-NEXT: %i8 = ptrtoint i32* %i7 to i64
246 ; X32-NEXT: --> (zext i32 {(ptrtoint i32* %in to i32),+,4}<%loop> to i64) U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (-4 + (4 * %count) + (ptrtoint i32* %in to i32)) to i64) LoopDispositions: { %loop: Computable }
247 ; X32-NEXT: %i9 = add nuw nsw i64 %i6, 1
248 ; X32-NEXT: --> {1,+,1}<nuw><%loop> U: [1,0) S: [1,0) Exits: (zext i32 %count to i64) LoopDispositions: { %loop: Computable }
249 ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_addrec
250 ; X32-NEXT: Loop %loop: backedge-taken count is (-1 + (zext i32 %count to i64))<nsw>
251 ; X32-NEXT: Loop %loop: max backedge-taken count is -1
252 ; X32-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (zext i32 %count to i64))<nsw>
253 ; X32-NEXT: Predicates:
254 ; X32: Loop %loop: Trip multiple is 1
255 ;
256 entry:
257 %i3 = zext i32 %count to i64
258 br label %loop
260 loop:
261 %i6 = phi i64 [ 0, %entry ], [ %i9, %loop ]
262 %i7 = getelementptr inbounds i32, i32* %in, i64 %i6
263 %i8 = ptrtoint i32* %i7 to i64
264 tail call void @use(i64 %i8)
265 %i9 = add nuw nsw i64 %i6, 1
266 %i10 = icmp eq i64 %i9, %i3
267 br i1 %i10, label %end, label %loop
269 end:
270 ret void
271 }
272 declare void @use(i64)
274 ; ptrtoint of UMax
275 define void @ptrtoint_of_umax(i8* %in0, i8* %in1, i64* %out0) {
276 ; X64-LABEL: 'ptrtoint_of_umax'
277 ; X64-NEXT: Classifying expressions for: @ptrtoint_of_umax
278 ; X64-NEXT: %s = select i1 %c, i8* %in0, i8* %in1
279 ; X64-NEXT: --> (%in0 umax %in1) U: full-set S: full-set
280 ; X64-NEXT: %p0 = ptrtoint i8* %s to i64
281 ; X64-NEXT: --> ((ptrtoint i8* %in0 to i64) umax (ptrtoint i8* %in1 to i64)) U: full-set S: full-set
282 ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_umax
283 ;
284 ; X32-LABEL: 'ptrtoint_of_umax'
285 ; X32-NEXT: Classifying expressions for: @ptrtoint_of_umax
286 ; X32-NEXT: %s = select i1 %c, i8* %in0, i8* %in1
287 ; X32-NEXT: --> (%in0 umax %in1) U: full-set S: full-set
288 ; X32-NEXT: %p0 = ptrtoint i8* %s to i64
289 ; X32-NEXT: --> (zext i32 ((ptrtoint i8* %in0 to i32) umax (ptrtoint i8* %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296)
290 ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_umax
291 ;
292 %c = icmp uge i8* %in0, %in1
293 %s = select i1 %c, i8* %in0, i8* %in1
294 %p0 = ptrtoint i8* %s to i64
295 store i64 %p0, i64* %out0
296 ret void
297 }
298 ; ptrtoint of SMax
299 define void @ptrtoint_of_smax(i8* %in0, i8* %in1, i64* %out0) {
300 ; X64-LABEL: 'ptrtoint_of_smax'
301 ; X64-NEXT: Classifying expressions for: @ptrtoint_of_smax
302 ; X64-NEXT: %s = select i1 %c, i8* %in0, i8* %in1
303 ; X64-NEXT: --> (%in0 smax %in1) U: full-set S: full-set
304 ; X64-NEXT: %p0 = ptrtoint i8* %s to i64
305 ; X64-NEXT: --> ((ptrtoint i8* %in0 to i64) smax (ptrtoint i8* %in1 to i64)) U: full-set S: full-set
306 ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_smax
307 ;
308 ; X32-LABEL: 'ptrtoint_of_smax'
309 ; X32-NEXT: Classifying expressions for: @ptrtoint_of_smax
310 ; X32-NEXT: %s = select i1 %c, i8* %in0, i8* %in1
311 ; X32-NEXT: --> (%in0 smax %in1) U: full-set S: full-set
312 ; X32-NEXT: %p0 = ptrtoint i8* %s to i64
313 ; X32-NEXT: --> (zext i32 ((ptrtoint i8* %in0 to i32) smax (ptrtoint i8* %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296)
314 ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_smax
315 ;
316 %c = icmp sge i8* %in0, %in1
317 %s = select i1 %c, i8* %in0, i8* %in1
318 %p0 = ptrtoint i8* %s to i64
319 store i64 %p0, i64* %out0
320 ret void
321 }
322 ; ptrtoint of UMin
323 define void @ptrtoint_of_umin(i8* %in0, i8* %in1, i64* %out0) {
324 ; X64-LABEL: 'ptrtoint_of_umin'
325 ; X64-NEXT: Classifying expressions for: @ptrtoint_of_umin
326 ; X64-NEXT: %s = select i1 %c, i8* %in0, i8* %in1
327 ; X64-NEXT: --> (%in0 umin %in1) U: full-set S: full-set
328 ; X64-NEXT: %p0 = ptrtoint i8* %s to i64
329 ; X64-NEXT: --> ((ptrtoint i8* %in0 to i64) umin (ptrtoint i8* %in1 to i64)) U: full-set S: full-set
330 ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_umin
331 ;
332 ; X32-LABEL: 'ptrtoint_of_umin'
333 ; X32-NEXT: Classifying expressions for: @ptrtoint_of_umin
334 ; X32-NEXT: %s = select i1 %c, i8* %in0, i8* %in1
335 ; X32-NEXT: --> (%in0 umin %in1) U: full-set S: full-set
336 ; X32-NEXT: %p0 = ptrtoint i8* %s to i64
337 ; X32-NEXT: --> (zext i32 ((ptrtoint i8* %in0 to i32) umin (ptrtoint i8* %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296)
338 ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_umin
339 ;
340 %c = icmp ule i8* %in0, %in1
341 %s = select i1 %c, i8* %in0, i8* %in1
342 %p0 = ptrtoint i8* %s to i64
343 store i64 %p0, i64* %out0
344 ret void
345 }
346 ; ptrtoint of SMin
347 define void @ptrtoint_of_smin(i8* %in0, i8* %in1, i64* %out0) {
348 ; X64-LABEL: 'ptrtoint_of_smin'
349 ; X64-NEXT: Classifying expressions for: @ptrtoint_of_smin
350 ; X64-NEXT: %s = select i1 %c, i8* %in0, i8* %in1
351 ; X64-NEXT: --> (%in0 smin %in1) U: full-set S: full-set
352 ; X64-NEXT: %p0 = ptrtoint i8* %s to i64
353 ; X64-NEXT: --> ((ptrtoint i8* %in0 to i64) smin (ptrtoint i8* %in1 to i64)) U: full-set S: full-set
354 ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_smin
355 ;
356 ; X32-LABEL: 'ptrtoint_of_smin'
357 ; X32-NEXT: Classifying expressions for: @ptrtoint_of_smin
358 ; X32-NEXT: %s = select i1 %c, i8* %in0, i8* %in1
359 ; X32-NEXT: --> (%in0 smin %in1) U: full-set S: full-set
360 ; X32-NEXT: %p0 = ptrtoint i8* %s to i64
361 ; X32-NEXT: --> (zext i32 ((ptrtoint i8* %in0 to i32) smin (ptrtoint i8* %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296)
362 ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_smin
363 ;
364 %c = icmp sle i8* %in0, %in1
365 %s = select i1 %c, i8* %in0, i8* %in1
366 %p0 = ptrtoint i8* %s to i64
367 store i64 %p0, i64* %out0
368 ret void
369 }
371 ; void pr46786_c26_char(char* start, char *end, char *other) {
372 ; for (char* cur = start; cur != end; ++cur)
373 ; other[cur - start] += *cur;
374 ; }
375 define void @pr46786_c26_char(i8* %arg, i8* %arg1, i8* %arg2) {
376 ; X64-LABEL: 'pr46786_c26_char'
377 ; X64-NEXT: Classifying expressions for: @pr46786_c26_char
378 ; X64-NEXT: %i4 = ptrtoint i8* %arg to i64
379 ; X64-NEXT: --> (ptrtoint i8* %arg to i64) U: full-set S: full-set
380 ; X64-NEXT: %i7 = phi i8* [ %arg, %bb3 ], [ %i14, %bb6 ]
381 ; X64-NEXT: --> {%arg,+,1}<nuw><%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64) + %arg) LoopDispositions: { %bb6: Computable }
382 ; X64-NEXT: %i8 = load i8, i8* %i7, align 1
383 ; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
384 ; X64-NEXT: %i9 = ptrtoint i8* %i7 to i64
385 ; X64-NEXT: --> {(ptrtoint i8* %arg to i64),+,1}<nuw><%bb6> U: full-set S: full-set Exits: (-1 + (ptrtoint i8* %arg1 to i64)) LoopDispositions: { %bb6: Computable }
386 ; X64-NEXT: %i10 = sub i64 %i9, %i4
387 ; X64-NEXT: --> {0,+,1}<nuw><%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64)) LoopDispositions: { %bb6: Computable }
388 ; X64-NEXT: %i11 = getelementptr inbounds i8, i8* %arg2, i64 %i10
389 ; X64-NEXT: --> {%arg2,+,1}<nw><%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64) + %arg2) LoopDispositions: { %bb6: Computable }
390 ; X64-NEXT: %i12 = load i8, i8* %i11, align 1
391 ; X64-NEXT: --> %i12 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
392 ; X64-NEXT: %i13 = add i8 %i12, %i8
393 ; X64-NEXT: --> (%i12 + %i8) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
394 ; X64-NEXT: %i14 = getelementptr inbounds i8, i8* %i7, i64 1
395 ; X64-NEXT: --> {(1 + %arg),+,1}<nuw><%bb6> U: full-set S: full-set Exits: ((-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64) + %arg) LoopDispositions: { %bb6: Computable }
396 ; X64-NEXT: Determining loop execution counts for: @pr46786_c26_char
397 ; X64-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64))
398 ; X64-NEXT: Loop %bb6: max backedge-taken count is -1
399 ; X64-NEXT: Loop %bb6: Predicated backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64))
400 ; X64-NEXT: Predicates:
401 ; X64: Loop %bb6: Trip multiple is 1
402 ;
403 ; X32-LABEL: 'pr46786_c26_char'
404 ; X32-NEXT: Classifying expressions for: @pr46786_c26_char
405 ; X32-NEXT: %i4 = ptrtoint i8* %arg to i64
406 ; X32-NEXT: --> (zext i32 (ptrtoint i8* %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296)
407 ; X32-NEXT: %i7 = phi i8* [ %arg, %bb3 ], [ %i14, %bb6 ]
408 ; X32-NEXT: --> {%arg,+,1}<nuw><%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32) + %arg) LoopDispositions: { %bb6: Computable }
409 ; X32-NEXT: %i8 = load i8, i8* %i7, align 1
410 ; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
411 ; X32-NEXT: %i9 = ptrtoint i8* %i7 to i64
412 ; X32-NEXT: --> {(zext i32 (ptrtoint i8* %arg to i32) to i64),+,1}<nuw><%bb6> U: [0,8589934591) S: [0,8589934591) Exits: ((zext i32 (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32)) to i64) + (zext i32 (ptrtoint i8* %arg to i32) to i64)) LoopDispositions: { %bb6: Computable }
413 ; X32-NEXT: %i10 = sub i64 %i9, %i4
414 ; X32-NEXT: --> {0,+,1}<nuw><%bb6> U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32)) to i64) LoopDispositions: { %bb6: Computable }
415 ; X32-NEXT: %i11 = getelementptr inbounds i8, i8* %arg2, i64 %i10
416 ; X32-NEXT: --> {%arg2,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32) + %arg2) LoopDispositions: { %bb6: Computable }
417 ; X32-NEXT: %i12 = load i8, i8* %i11, align 1
418 ; X32-NEXT: --> %i12 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
419 ; X32-NEXT: %i13 = add i8 %i12, %i8
420 ; X32-NEXT: --> (%i12 + %i8) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
421 ; X32-NEXT: %i14 = getelementptr inbounds i8, i8* %i7, i64 1
422 ; X32-NEXT: --> {(1 + %arg),+,1}<nuw><%bb6> U: full-set S: full-set Exits: ((-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32) + %arg) LoopDispositions: { %bb6: Computable }
423 ; X32-NEXT: Determining loop execution counts for: @pr46786_c26_char
424 ; X32-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32))
425 ; X32-NEXT: Loop %bb6: max backedge-taken count is -1
426 ; X32-NEXT: Loop %bb6: Predicated backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32))
427 ; X32-NEXT: Predicates:
428 ; X32: Loop %bb6: Trip multiple is 1
429 ;
430 %i = icmp eq i8* %arg, %arg1
431 br i1 %i, label %bb5, label %bb3
433 bb3:
434 %i4 = ptrtoint i8* %arg to i64
435 br label %bb6
437 bb6:
438 %i7 = phi i8* [ %arg, %bb3 ], [ %i14, %bb6 ]
439 %i8 = load i8, i8* %i7
440 %i9 = ptrtoint i8* %i7 to i64
441 %i10 = sub i64 %i9, %i4
442 %i11 = getelementptr inbounds i8, i8* %arg2, i64 %i10
443 %i12 = load i8, i8* %i11
444 %i13 = add i8 %i12, %i8
445 store i8 %i13, i8* %i11
446 %i14 = getelementptr inbounds i8, i8* %i7, i64 1
447 %i15 = icmp eq i8* %i14, %arg1
448 br i1 %i15, label %bb5, label %bb6
450 bb5:
451 ret void
452 }
454 ; void pr46786_c26_int(int* start, int *end, int *other) {
455 ; for (int* cur = start; cur != end; ++cur)
456 ; other[cur - start] += *cur;
457 ; }
458 ;
459 ; FIXME: 4 * (%i10 EXACT/s 4) is just %i10
460 define void @pr46786_c26_int(i32* %arg, i32* %arg1, i32* %arg2) {
461 ; X64-LABEL: 'pr46786_c26_int'
462 ; X64-NEXT: Classifying expressions for: @pr46786_c26_int
463 ; X64-NEXT: %i4 = ptrtoint i32* %arg to i64
464 ; X64-NEXT: --> (ptrtoint i32* %arg to i64) U: full-set S: full-set
465 ; X64-NEXT: %i7 = phi i32* [ %arg, %bb3 ], [ %i15, %bb6 ]
466 ; X64-NEXT: --> {%arg,+,4}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
467 ; X64-NEXT: %i8 = load i32, i32* %i7, align 4
468 ; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
469 ; X64-NEXT: %i9 = ptrtoint i32* %i7 to i64
470 ; X64-NEXT: --> {(ptrtoint i32* %arg to i64),+,4}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4))<nuw> + (ptrtoint i32* %arg to i64)) LoopDispositions: { %bb6: Computable }
471 ; X64-NEXT: %i10 = sub i64 %i9, %i4
472 ; X64-NEXT: --> {0,+,4}<nuw><%bb6> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (4 * ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4))<nuw> LoopDispositions: { %bb6: Computable }
473 ; X64-NEXT: %i11 = ashr exact i64 %i10, 2
474 ; X64-NEXT: --> %i11 U: [-2305843009213693952,2305843009213693952) S: [-2305843009213693952,2305843009213693952) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
475 ; X64-NEXT: %i12 = getelementptr inbounds i32, i32* %arg2, i64 %i11
476 ; X64-NEXT: --> ((4 * %i11)<nsw> + %arg2) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
477 ; X64-NEXT: %i13 = load i32, i32* %i12, align 4
478 ; X64-NEXT: --> %i13 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
479 ; X64-NEXT: %i14 = add nsw i32 %i13, %i8
480 ; X64-NEXT: --> (%i13 + %i8) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
481 ; X64-NEXT: %i15 = getelementptr inbounds i32, i32* %i7, i64 1
482 ; X64-NEXT: --> {(4 + %arg),+,4}<nuw><%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
483 ; X64-NEXT: Determining loop execution counts for: @pr46786_c26_int
484 ; X64-NEXT: Loop %bb6: backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4)
485 ; X64-NEXT: Loop %bb6: max backedge-taken count is 4611686018427387903
486 ; X64-NEXT: Loop %bb6: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4)
487 ; X64-NEXT: Predicates:
488 ; X64: Loop %bb6: Trip multiple is 1
489 ;
490 ; X32-LABEL: 'pr46786_c26_int'
491 ; X32-NEXT: Classifying expressions for: @pr46786_c26_int
492 ; X32-NEXT: %i4 = ptrtoint i32* %arg to i64
493 ; X32-NEXT: --> (zext i32 (ptrtoint i32* %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296)
494 ; X32-NEXT: %i7 = phi i32* [ %arg, %bb3 ], [ %i15, %bb6 ]
495 ; X32-NEXT: --> {%arg,+,4}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
496 ; X32-NEXT: %i8 = load i32, i32* %i7, align 4
497 ; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
498 ; X32-NEXT: %i9 = ptrtoint i32* %i7 to i64
499 ; X32-NEXT: --> {(zext i32 (ptrtoint i32* %arg to i32) to i64),+,4}<nuw><%bb6> U: [0,8589934588) S: [0,8589934588) Exits: ((zext i32 (ptrtoint i32* %arg to i32) to i64) + (4 * ((zext i32 (-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) to i64) /u 4))<nuw><nsw>) LoopDispositions: { %bb6: Computable }
500 ; X32-NEXT: %i10 = sub i64 %i9, %i4
501 ; X32-NEXT: --> {0,+,4}<nuw><%bb6> U: [0,4294967293) S: [0,4294967293) Exits: (4 * ((zext i32 (-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) to i64) /u 4))<nuw><nsw> LoopDispositions: { %bb6: Computable }
502 ; X32-NEXT: %i11 = ashr exact i64 %i10, 2
503 ; X32-NEXT: --> %i11 U: [-2147483648,2147483648) S: [-2147483648,2147483648) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
504 ; X32-NEXT: %i12 = getelementptr inbounds i32, i32* %arg2, i64 %i11
505 ; X32-NEXT: --> ((4 * (trunc i64 %i11 to i32))<nsw> + %arg2) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
506 ; X32-NEXT: %i13 = load i32, i32* %i12, align 4
507 ; X32-NEXT: --> %i13 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
508 ; X32-NEXT: %i14 = add nsw i32 %i13, %i8
509 ; X32-NEXT: --> (%i13 + %i8) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
510 ; X32-NEXT: %i15 = getelementptr inbounds i32, i32* %i7, i64 1
511 ; X32-NEXT: --> {(4 + %arg),+,4}<nuw><%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
512 ; X32-NEXT: Determining loop execution counts for: @pr46786_c26_int
513 ; X32-NEXT: Loop %bb6: backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) /u 4)
514 ; X32-NEXT: Loop %bb6: max backedge-taken count is 1073741823
515 ; X32-NEXT: Loop %bb6: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) /u 4)
516 ; X32-NEXT: Predicates:
517 ; X32: Loop %bb6: Trip multiple is 1
518 ;
519 %i = icmp eq i32* %arg, %arg1
520 br i1 %i, label %bb5, label %bb3
522 bb3:
523 %i4 = ptrtoint i32* %arg to i64
524 br label %bb6
526 bb6:
527 %i7 = phi i32* [ %arg, %bb3 ], [ %i15, %bb6 ]
528 %i8 = load i32, i32* %i7
529 %i9 = ptrtoint i32* %i7 to i64
530 %i10 = sub i64 %i9, %i4
531 %i11 = ashr exact i64 %i10, 2
532 %i12 = getelementptr inbounds i32, i32* %arg2, i64 %i11
533 %i13 = load i32, i32* %i12
534 %i14 = add nsw i32 %i13, %i8
535 store i32 %i14, i32* %i12
536 %i15 = getelementptr inbounds i32, i32* %i7, i64 1
537 %i16 = icmp eq i32* %i15, %arg1
538 br i1 %i16, label %bb5, label %bb6
540 bb5:
541 ret void
542 }
544 ; During SCEV rewrites, we could end up calling `ScalarEvolution::getPtrToIntExpr()`
545 ; on an integer. Make sure we handle that case gracefully.
546 define void @ptrtoint_of_integer(i8* %arg, i64 %arg1, i1 %arg2) local_unnamed_addr {
547 ; X64-LABEL: 'ptrtoint_of_integer'
548 ; X64-NEXT: Classifying expressions for: @ptrtoint_of_integer
549 ; X64-NEXT: %i4 = ptrtoint i8* %arg to i64
550 ; X64-NEXT: --> (ptrtoint i8* %arg to i64) U: full-set S: full-set
551 ; X64-NEXT: %i6 = sub i64 %i4, %arg1
552 ; X64-NEXT: --> ((-1 * %arg1) + (ptrtoint i8* %arg to i64)) U: full-set S: full-set
553 ; X64-NEXT: %i9 = phi i64 [ 1, %bb7 ], [ %i11, %bb10 ]
554 ; X64-NEXT: --> {1,+,1}<nuw><%bb8> U: [1,0) S: [1,0) Exits: <<Unknown>> LoopDispositions: { %bb8: Computable }
555 ; X64-NEXT: %i11 = add nuw i64 %i9, 1
556 ; X64-NEXT: --> {2,+,1}<nw><%bb8> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb8: Computable }
557 ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_integer
558 ; X64-NEXT: Loop %bb8: <multiple exits> Unpredictable backedge-taken count.
559 ; X64-NEXT: exit count for bb8: ***COULDNOTCOMPUTE***
560 ; X64-NEXT: exit count for bb10: (-2 + (-1 * %arg1) + (ptrtoint i8* %arg to i64))
561 ; X64-NEXT: Loop %bb8: max backedge-taken count is -1
562 ; X64-NEXT: Loop %bb8: Unpredictable predicated backedge-taken count.
563 ;
564 ; X32-LABEL: 'ptrtoint_of_integer'
565 ; X32-NEXT: Classifying expressions for: @ptrtoint_of_integer
566 ; X32-NEXT: %i4 = ptrtoint i8* %arg to i64
567 ; X32-NEXT: --> (zext i32 (ptrtoint i8* %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296)
568 ; X32-NEXT: %i6 = sub i64 %i4, %arg1
569 ; X32-NEXT: --> ((zext i32 (ptrtoint i8* %arg to i32) to i64) + (-1 * %arg1)) U: full-set S: full-set
570 ; X32-NEXT: %i9 = phi i64 [ 1, %bb7 ], [ %i11, %bb10 ]
571 ; X32-NEXT: --> {1,+,1}<nuw><%bb8> U: [1,0) S: [1,0) Exits: <<Unknown>> LoopDispositions: { %bb8: Computable }
572 ; X32-NEXT: %i11 = add nuw i64 %i9, 1
573 ; X32-NEXT: --> {2,+,1}<nw><%bb8> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb8: Computable }
574 ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_integer
575 ; X32-NEXT: Loop %bb8: <multiple exits> Unpredictable backedge-taken count.
576 ; X32-NEXT: exit count for bb8: ***COULDNOTCOMPUTE***
577 ; X32-NEXT: exit count for bb10: (-2 + (zext i32 (ptrtoint i8* %arg to i32) to i64) + (-1 * %arg1))
578 ; X32-NEXT: Loop %bb8: max backedge-taken count is -1
579 ; X32-NEXT: Loop %bb8: Unpredictable predicated backedge-taken count.
580 ;
581 bb:
582 %i = icmp eq i8* %arg, null
583 br i1 %i, label %bb14, label %bb3
585 bb3: ; preds = %bb
586 %i4 = ptrtoint i8* %arg to i64
587 br label %bb5
589 bb5: ; preds = %bb3
590 %i6 = sub i64 %i4, %arg1
591 br label %bb7
593 bb7: ; preds = %bb5
594 br label %bb8
596 bb8: ; preds = %bb10, %bb7
597 %i9 = phi i64 [ 1, %bb7 ], [ %i11, %bb10 ]
598 br i1 %arg2, label %bb10, label %bb13
600 bb10: ; preds = %bb8
601 %i11 = add nuw i64 %i9, 1
602 %i12 = icmp eq i64 %i11, %i6
603 br i1 %i12, label %bb13, label %bb8
605 bb13: ; preds = %bb10, %bb8
606 ret void
608 bb14: ; preds = %bb
609 ret void
610 }