1 ; RUN: opt < %s -sroa -S | FileCheck %s
2 target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
10 %a0 = getelementptr [2 x i32]* %a, i64 0, i32 0
11 %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1
19 %cond = icmp sle i32 %v0, %v1
20 br i1 %cond, label %then, label %exit
26 %phi = phi i32* [ %a1, %then ], [ %a0, %entry ]
27 ; CHECK: phi i32 [ 1, %{{.*}} ], [ 0, %{{.*}} ]
29 %result = load i32* %phi
39 %a0 = getelementptr [2 x i32]* %a, i64 0, i32 0
40 %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1
48 %cond = icmp sle i32 %v0, %v1
49 %select = select i1 %cond, i32* %a1, i32* %a0
50 ; CHECK: select i1 %{{.*}}, i32 1, i32 0
52 %result = load i32* %select
56 define i32 @test3(i32 %x) {
62 %a0 = getelementptr [2 x i32]* %a, i64 0, i32 0
63 %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1
68 switch i32 %x, label %bb0 [ i32 1, label %bb1
82 %phi = phi i32* [ %a1, %bb0 ], [ %a0, %bb1 ], [ %a0, %bb2 ], [ %a1, %bb3 ]
83 ; CHECK: phi i32 [ 1, %{{.*}} ], [ 0, %{{.*}} ], [ 0, %{{.*}} ], [ 1, %{{.*}} ]
85 %result = load i32* %phi
95 %a0 = getelementptr [2 x i32]* %a, i64 0, i32 0
96 %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1
104 %cond = icmp sle i32 %v0, %v1
105 %select = select i1 %cond, i32* %a0, i32* %a0
108 %result = load i32* %select
113 define i32 @test5(i32* %b) {
116 %a = alloca [2 x i32]
119 %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1
120 store i32 1, i32* %a1
123 %select = select i1 true, i32* %a1, i32* %b
126 %result = load i32* %select
133 declare void @f(i32*)
135 define i32 @test6(i32* %b) {
138 %a = alloca [2 x i32]
139 ; The alloca remains because it is used in a dead select.
142 %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1
143 store i32 1, i32* %a1
145 %select = select i1 true, i32* %a1, i32* %b
146 %select2 = select i1 false, i32* %a1, i32* %b
147 ; CHECK-NOT: select i1 true
148 ; We don't aggressively DCE this select.
149 ; CHECK: select i1 false
151 ; Note, this would potentially escape the alloca pointer except for the
152 ; constant folding of the select.
153 call void @f(i32* %select2)
155 %result = load i32* %select
162 define i32 @test7() {
168 br i1 undef, label %good, label %bad
171 %Y1 = getelementptr i32* %X, i64 0
172 store i32 0, i32* %Y1
176 %Y2 = getelementptr i32* %X, i64 1
177 store i32 0, i32* %Y2
181 %P = phi i32* [ %Y1, %good ], [ %Y2, %bad ]
182 ; CHECK: %[[phi:.*]] = phi i32 [ 0, %good ],
185 ; CHECK: ret i32 %[[phi]]
188 define i32 @test8(i32 %b, i32* %ptr) {
189 ; Ensure that we rewrite allocas to the used type when that use is hidden by
190 ; a PHI that can be speculated.
194 ; CHECK: %[[value:.*]] = load i32* %ptr
196 ; CHECK: %[[result:.*]] = phi i32 [ undef, %else ], [ %[[value]], %then ]
197 ; CHECK-NEXT: ret i32 %[[result]]
201 %test = icmp ne i32 %b, 0
202 br i1 %test, label %then, label %else
208 %bitcast = bitcast float* %f to i32*
212 %phi = phi i32* [ %bitcast, %else ], [ %ptr, %then ]
213 %loaded = load i32* %phi, align 4
217 define i32 @test9(i32 %b, i32* %ptr) {
218 ; Same as @test8 but for a select rather than a PHI node.
222 ; CHECK: %[[value:.*]] = load i32* %ptr
224 ; CHECK: %[[result:.*]] = select i1 %{{.*}}, i32 undef, i32 %[[value]]
225 ; CHECK-NEXT: ret i32 %[[result]]
229 store i32 0, i32* %ptr
230 %test = icmp ne i32 %b, 0
231 %bitcast = bitcast float* %f to i32*
232 %select = select i1 %test, i32* %bitcast, i32* %ptr
233 %loaded = load i32* %select, align 4
237 define i32 @test10(i32 %b, i32* %ptr) {
238 ; Don't try to promote allocas which are not elligible for it even after
239 ; rewriting due to the necessity of inserting bitcasts when speculating a PHI
242 ; CHECK: %[[alloca:.*]] = alloca
243 ; CHECK: %[[argvalue:.*]] = load i32* %ptr
244 ; CHECK: %[[cast:.*]] = bitcast double* %[[alloca]] to i32*
245 ; CHECK: %[[allocavalue:.*]] = load i32* %[[cast]]
246 ; CHECK: %[[result:.*]] = phi i32 [ %[[allocavalue]], %else ], [ %[[argvalue]], %then ]
247 ; CHECK-NEXT: ret i32 %[[result]]
251 store double 0.0, double* %f
252 %test = icmp ne i32 %b, 0
253 br i1 %test, label %then, label %else
259 %bitcast = bitcast double* %f to i32*
263 %phi = phi i32* [ %bitcast, %else ], [ %ptr, %then ]
264 %loaded = load i32* %phi, align 4
268 define i32 @test11(i32 %b, i32* %ptr) {
269 ; Same as @test10 but for a select rather than a PHI node.
271 ; CHECK: %[[alloca:.*]] = alloca
272 ; CHECK: %[[cast:.*]] = bitcast double* %[[alloca]] to i32*
273 ; CHECK: %[[allocavalue:.*]] = load i32* %[[cast]]
274 ; CHECK: %[[argvalue:.*]] = load i32* %ptr
275 ; CHECK: %[[result:.*]] = select i1 %{{.*}}, i32 %[[allocavalue]], i32 %[[argvalue]]
276 ; CHECK-NEXT: ret i32 %[[result]]
280 store double 0.0, double* %f
281 store i32 0, i32* %ptr
282 %test = icmp ne i32 %b, 0
283 %bitcast = bitcast double* %f to i32*
284 %select = select i1 %test, i32* %bitcast, i32* %ptr
285 %loaded = load i32* %select, align 4
289 define i32 @test12(i32 %x, i32* %p) {
290 ; Ensure we don't crash or fail to nuke dead selects of allocas if no load is
299 store i32 %x, i32* %a
300 %dead = select i1 undef, i32* %a, i32* %p
305 define i32 @test13(i32 %x, i32* %p) {
306 ; Ensure we don't crash or fail to nuke dead phis of allocas if no load is ever
315 store i32 %x, i32* %a
319 %phi = phi i32* [ %p, %entry ], [ %a, %loop ]
320 br i1 undef, label %loop, label %exit