Lines Matching full:phi
26 %phi = phi i32* [ %a1, %then ], [ %a0, %entry ]
27 ; CHECK: phi i32 [ 1, %{{.*}} ], [ 0, %{{.*}} ]
29 %result = load i32* %phi
63 ; into the same alloca partation continues to work with PHI speculation. This
99 %phi = phi i32* [ %a1, %bb0 ], [ %a0, %bb1 ], [ %a0, %bb2 ], [ %a1, %bb3 ],
101 ; CHECK: phi i32 [ 1, %{{.*}} ], [ 0, %{{.*}} ], [ 0, %{{.*}} ], [ 1, %{{.*}} ], [ 1, %{{.*}} ], [ 0, %{{.*}} ], [ 0, %{{.*}} ], [ 1, %{{.*}} ]
103 %result = load i32* %phi
203 %P = phi i32* [ %Y1, %good ], [ %Y2, %bad ]
204 ; CHECK: %[[phi:.*]] = phi i32 [ 0, %good ],
207 ; CHECK: ret i32 %[[phi]]
212 ; a PHI that can be speculated.
218 ; CHECK: %[[result:.*]] = phi i32 [ undef, %else ], [ %[[value]], %then ]
234 %phi = phi i32* [ %bitcast, %else ], [ %ptr, %then ]
235 %loaded = load i32* %phi, align 4
240 ; Same as @test8 but for a select rather than a PHI node.
261 ; rewriting due to the necessity of inserting bitcasts when speculating a PHI
268 ; CHECK: %[[result:.*]] = phi float [ %[[allocavalue]], %else ], [ %[[argvalue]], %then ]
285 %phi = phi float* [ %bitcast, %else ], [ %ptr, %then ]
286 %loaded = load float* %phi, align 4
291 ; Same as @test10 but for a select rather than a PHI node.
332 ; CHECK-NOT: phi
341 %phi = phi i32* [ %p, %entry ], [ %a, %loop ]
357 ; CHECK: phi
358 ; CHECK: phi
377 %f.phi = phi i32* [ %f, %then ], [ %f.select, %else ]
378 %g.phi = phi i32* [ %g, %then ], [ %ptr, %else ]
379 %f.loaded = load i32* %f.phi
380 %g.select = select i1 %b1, i32* %g, i32* %g.phi
387 ; Check a pattern where we have a chain of dead phi nodes to ensure they are
399 %phi1 = phi i32* [ null, %entry ], [ %h, %loop1 ], [ %h, %loop2 ]
406 %phi2 = phi i32* [ %phi1, %loop2 ], [ null, %entry ]
412 ; PHI nodes or select nodes. This triggers subtly differently from the above
413 ; cases because the PHI node is (recursively) alive, but the select is dead.
423 %d.0 = phi i32* [ undef, %entry ], [ %c, %if.then ], [ %d.0, %for.cond ]
433 ; Here we form a PHI-node by promoting the pointer alloca first, and then in
435 ; now-phi-node-pointer. In doing so we end up loading a 64-bit value from an i8
462 ; CHECK: %[[result:.*]] = phi i64 [ %[[ext]], %if.then ], [ 0, %entry ]
470 ; Check that even when we try to speculate the same phi twice (in two slices)
497 %a.phi.f = phi float* [ %a.f, %then ], [ %a.raw.4.f, %else ]
498 %f = load float* %a.phi.f
500 ; CHECK: %[[phi:.*]] = phi float [ %[[lo_cast]], %then ], [ %[[hi_cast]], %else ]
502 ; CHECK: ret float %[[phi]]
