1 ; RUN: llc -march=x86 -enable-block-placement < %s | FileCheck %s
3 declare void @error(i32 %i, i32 %a, i32 %b)
5 define i32 @test_ifchains(i32 %i, i32* %a, i32 %b) {
6 ; Test a chain of ifs, where the block guarded by the if is error handling code
7 ; that is not expected to run.
8 ; CHECK: test_ifchains:
22 %gep1 = getelementptr i32* %a, i32 1
23 %val1 = load i32* %gep1
24 %cond1 = icmp ugt i32 %val1, 1
25 br i1 %cond1, label %then1, label %else1, !prof !0
28 call void @error(i32 %i, i32 1, i32 %b)
32 %gep2 = getelementptr i32* %a, i32 2
33 %val2 = load i32* %gep2
34 %cond2 = icmp ugt i32 %val2, 2
35 br i1 %cond2, label %then2, label %else2, !prof !0
38 call void @error(i32 %i, i32 1, i32 %b)
42 %gep3 = getelementptr i32* %a, i32 3
43 %val3 = load i32* %gep3
44 %cond3 = icmp ugt i32 %val3, 3
45 br i1 %cond3, label %then3, label %else3, !prof !0
48 call void @error(i32 %i, i32 1, i32 %b)
52 %gep4 = getelementptr i32* %a, i32 4
53 %val4 = load i32* %gep4
54 %cond4 = icmp ugt i32 %val4, 4
55 br i1 %cond4, label %then4, label %else4, !prof !0
58 call void @error(i32 %i, i32 1, i32 %b)
62 %gep5 = getelementptr i32* %a, i32 3
63 %val5 = load i32* %gep5
64 %cond5 = icmp ugt i32 %val5, 3
65 br i1 %cond5, label %then5, label %exit, !prof !0
68 call void @error(i32 %i, i32 1, i32 %b)
75 define i32 @test_loop_cold_blocks(i32 %i, i32* %a) {
76 ; Check that we sink cold loop blocks after the hot loop body.
77 ; CHECK: test_loop_cold_blocks:
90 %iv = phi i32 [ 0, %entry ], [ %next, %body3 ]
91 %base = phi i32 [ 0, %entry ], [ %sum, %body3 ]
92 %unlikelycond1 = icmp slt i32 %base, 42
93 br i1 %unlikelycond1, label %unlikely1, label %body2, !prof !0
96 call void @error(i32 %i, i32 1, i32 %base)
100 %unlikelycond2 = icmp sgt i32 %base, 21
101 br i1 %unlikelycond2, label %unlikely2, label %body3, !prof !0
104 call void @error(i32 %i, i32 2, i32 %base)
108 %arrayidx = getelementptr inbounds i32* %a, i32 %iv
109 %0 = load i32* %arrayidx
110 %sum = add nsw i32 %0, %base
111 %next = add i32 %iv, 1
112 %exitcond = icmp eq i32 %next, %i
113 br i1 %exitcond, label %exit, label %body1
119 !0 = metadata !{metadata !"branch_weights", i32 4, i32 64}
121 define i32 @test_loop_early_exits(i32 %i, i32* %a) {
122 ; Check that we sink early exit blocks out of loop bodies.
123 ; CHECK: test_loop_early_exits:
138 %iv = phi i32 [ 0, %entry ], [ %next, %body4 ]
139 %base = phi i32 [ 0, %entry ], [ %sum, %body4 ]
140 %bailcond1 = icmp eq i32 %base, 42
141 br i1 %bailcond1, label %bail1, label %body2
147 %bailcond2 = icmp eq i32 %base, 43
148 br i1 %bailcond2, label %bail2, label %body3
154 %bailcond3 = icmp eq i32 %base, 44
155 br i1 %bailcond3, label %bail3, label %body4
161 %arrayidx = getelementptr inbounds i32* %a, i32 %iv
162 %0 = load i32* %arrayidx
163 %sum = add nsw i32 %0, %base
164 %next = add i32 %iv, 1
165 %exitcond = icmp eq i32 %next, %i
166 br i1 %exitcond, label %exit, label %body1
172 define i32 @test_loop_align(i32 %i, i32* %a) {
173 ; Check that we provide basic loop body alignment with the block placement
175 ; CHECK: test_loop_align:
177 ; CHECK: .align [[ALIGN:[0-9]+]],
185 %iv = phi i32 [ 0, %entry ], [ %next, %body ]
186 %base = phi i32 [ 0, %entry ], [ %sum, %body ]
187 %arrayidx = getelementptr inbounds i32* %a, i32 %iv
188 %0 = load i32* %arrayidx
189 %sum = add nsw i32 %0, %base
190 %next = add i32 %iv, 1
191 %exitcond = icmp eq i32 %next, %i
192 br i1 %exitcond, label %exit, label %body
198 define i32 @test_nested_loop_align(i32 %i, i32* %a, i32* %b) {
199 ; Check that we provide nested loop body alignment.
200 ; CHECK: test_nested_loop_align:
202 ; CHECK: .align [[ALIGN]],
203 ; CHECK-NEXT: %loop.body.1
204 ; CHECK: .align [[ALIGN]],
205 ; CHECK-NEXT: %inner.loop.body
210 br label %loop.body.1
213 %iv = phi i32 [ 0, %entry ], [ %next, %loop.body.2 ]
214 %arrayidx = getelementptr inbounds i32* %a, i32 %iv
215 %bidx = load i32* %arrayidx
216 br label %inner.loop.body
219 %inner.iv = phi i32 [ 0, %loop.body.1 ], [ %inner.next, %inner.loop.body ]
220 %base = phi i32 [ 0, %loop.body.1 ], [ %sum, %inner.loop.body ]
221 %scaled_idx = mul i32 %bidx, %iv
222 %inner.arrayidx = getelementptr inbounds i32* %b, i32 %scaled_idx
223 %0 = load i32* %inner.arrayidx
224 %sum = add nsw i32 %0, %base
225 %inner.next = add i32 %iv, 1
226 %inner.exitcond = icmp eq i32 %inner.next, %i
227 br i1 %inner.exitcond, label %loop.body.2, label %inner.loop.body
230 %next = add i32 %iv, 1
231 %exitcond = icmp eq i32 %next, %i
232 br i1 %exitcond, label %exit, label %loop.body.1
238 define void @unnatural_cfg1() {
239 ; Test that we can handle a loop with an inner unnatural loop at the end of
240 ; a function. This is a gross CFG reduced out of the single source GCC.
241 ; CHECK: unnatural_cfg1
248 br label %loop.header
254 br i1 undef, label %loop.body3, label %loop.body2
257 %ptr = load i32** undef, align 4
261 %myptr = phi i32* [ %ptr2, %loop.body5 ], [ %ptr, %loop.body2 ], [ undef, %loop.body1 ]
262 %bcmyptr = bitcast i32* %myptr to i32*
263 %val = load i32* %bcmyptr, align 4
264 %comp = icmp eq i32 %val, 48
265 br i1 %comp, label %loop.body4, label %loop.body5
268 br i1 undef, label %loop.header, label %loop.body5
271 %ptr2 = load i32** undef, align 4
275 define void @unnatural_cfg2() {
276 ; Test that we can handle a loop with a nested natural loop *and* an unnatural
277 ; loop. This was reduced from a crash on block placement when run over
279 ; CHECK: unnatural_cfg2
281 ; CHECK: %loop.header
285 ; CHECK: %loop.inner1.begin
286 ; The end block is folded with %loop.body3...
287 ; CHECK-NOT: %loop.inner1.end
289 ; CHECK: %loop.inner2.begin
290 ; The loop.inner2.end block is folded
294 br label %loop.header
297 %comp0 = icmp eq i32* undef, null
298 br i1 %comp0, label %bail, label %loop.body1
301 %val0 = load i32** undef, align 4
302 br i1 undef, label %loop.body2, label %loop.inner1.begin
305 br i1 undef, label %loop.body4, label %loop.body3
308 %ptr1 = getelementptr inbounds i32* %val0, i32 0
309 %castptr1 = bitcast i32* %ptr1 to i32**
310 %val1 = load i32** %castptr1, align 4
311 br label %loop.inner1.begin
314 %valphi = phi i32* [ %val2, %loop.inner1.end ], [ %val1, %loop.body3 ], [ %val0, %loop.body1 ]
315 %castval = bitcast i32* %valphi to i32*
316 %comp1 = icmp eq i32 undef, 48
317 br i1 %comp1, label %loop.inner1.end, label %loop.body4
320 %ptr2 = getelementptr inbounds i32* %valphi, i32 0
321 %castptr2 = bitcast i32* %ptr2 to i32**
322 %val2 = load i32** %castptr2, align 4
323 br label %loop.inner1.begin
329 %comp2 = icmp ult i32 undef, 3
330 br i1 %comp2, label %loop.inner2.begin, label %loop.end
333 br i1 false, label %loop.end, label %loop.inner2.end
336 %comp3 = icmp eq i32 undef, 1769472
337 br i1 %comp3, label %loop.end, label %loop.inner2.begin
340 br label %loop.header
346 define i32 @problematic_switch() {
347 ; This function's CFG caused overlow in the machine branch probability
348 ; calculation, triggering asserts. Make sure we don't crash on it.
349 ; CHECK: problematic_switch
352 switch i32 undef, label %exit [
353 i32 879, label %bogus
393 %merge = phi i32 [ 3, %step ], [ 6, %entry ]