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" 3 4 define i32 @test1() { 5 ; CHECK: @test1 6 entry: 7 %a = alloca [2 x i32] 8 ; CHECK-NOT: alloca 9 10 %a0 = getelementptr [2 x i32]* %a, i64 0, i32 0 11 %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1 12 store i32 0, i32* %a0 13 store i32 1, i32* %a1 14 %v0 = load i32* %a0 15 %v1 = load i32* %a1 16 ; CHECK-NOT: store 17 ; CHECK-NOT: load 18 19 %cond = icmp sle i32 %v0, %v1 20 br i1 %cond, label %then, label %exit 21 22 then: 23 br label %exit 24 25 exit: 26 %phi = phi i32* [ %a1, %then ], [ %a0, %entry ] 27 ; CHECK: phi i32 [ 1, %{{.*}} ], [ 0, %{{.*}} ] 28 29 %result = load i32* %phi 30 ret i32 %result 31 } 32 33 define i32 @test2() { 34 ; CHECK: @test2 35 entry: 36 %a = alloca [2 x i32] 37 ; CHECK-NOT: alloca 38 39 %a0 = getelementptr [2 x i32]* %a, i64 0, i32 0 40 %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1 41 store i32 0, i32* %a0 42 store i32 1, i32* %a1 43 %v0 = load i32* %a0 44 %v1 = load i32* %a1 45 ; CHECK-NOT: store 46 ; CHECK-NOT: load 47 48 %cond = icmp sle i32 %v0, %v1 49 %select = select i1 %cond, i32* %a1, i32* %a0 50 ; CHECK: select i1 %{{.*}}, i32 1, i32 0 51 52 %result = load i32* %select 53 ret i32 %result 54 } 55 56 define i32 @test3(i32 %x) { 57 ; CHECK: @test3 58 entry: 59 %a = alloca [2 x i32] 60 ; CHECK-NOT: alloca 61 62 ; Note that we build redundant GEPs here to ensure that having different GEPs 63 ; into the same alloca partation continues to work with PHI speculation. This 64 ; was the underlying cause of PR13926. 65 %a0 = getelementptr [2 x i32]* %a, i64 0, i32 0 66 %a0b = getelementptr [2 x i32]* %a, i64 0, i32 0 67 %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1 68 %a1b = getelementptr [2 x i32]* %a, i64 0, i32 1 69 store i32 0, i32* %a0 70 store i32 1, i32* %a1 71 ; CHECK-NOT: store 72 73 switch i32 %x, label %bb0 [ i32 1, label %bb1 74 i32 2, label %bb2 75 i32 3, label %bb3 76 i32 4, label %bb4 77 i32 5, label %bb5 78 i32 6, label %bb6 79 i32 7, label %bb7 ] 80 81 bb0: 82 br label %exit 83 bb1: 84 br label %exit 85 bb2: 86 br label %exit 87 bb3: 88 br label %exit 89 bb4: 90 br label %exit 91 bb5: 92 br label %exit 93 bb6: 94 br label %exit 95 bb7: 96 br label %exit 97 98 exit: 99 %phi = phi i32* [ %a1, %bb0 ], [ %a0, %bb1 ], [ %a0, %bb2 ], [ %a1, %bb3 ], 100 [ %a1b, %bb4 ], [ %a0b, %bb5 ], [ %a0b, %bb6 ], [ %a1b, %bb7 ] 101 ; CHECK: phi i32 [ 1, %{{.*}} ], [ 0, %{{.*}} ], [ 0, %{{.*}} ], [ 1, %{{.*}} ], [ 1, %{{.*}} ], [ 0, %{{.*}} ], [ 0, %{{.*}} ], [ 1, %{{.*}} ] 102 103 %result = load i32* %phi 104 ret i32 %result 105 } 106 107 define i32 @test4() { 108 ; CHECK: @test4 109 entry: 110 %a = alloca [2 x i32] 111 ; CHECK-NOT: alloca 112 113 %a0 = getelementptr [2 x i32]* %a, i64 0, i32 0 114 %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1 115 store i32 0, i32* %a0 116 store i32 1, i32* %a1 117 %v0 = load i32* %a0 118 %v1 = load i32* %a1 119 ; CHECK-NOT: store 120 ; CHECK-NOT: load 121 122 %cond = icmp sle i32 %v0, %v1 123 %select = select i1 %cond, i32* %a0, i32* %a0 124 ; CHECK-NOT: select 125 126 %result = load i32* %select 127 ret i32 %result 128 ; CHECK: ret i32 0 129 } 130 131 define i32 @test5(i32* %b) { 132 ; CHECK: @test5 133 entry: 134 %a = alloca [2 x i32] 135 ; CHECK-NOT: alloca 136 137 %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1 138 store i32 1, i32* %a1 139 ; CHECK-NOT: store 140 141 %select = select i1 true, i32* %a1, i32* %b 142 ; CHECK-NOT: select 143 144 %result = load i32* %select 145 ; CHECK-NOT: load 146 147 ret i32 %result 148 ; CHECK: ret i32 1 149 } 150 151 declare void @f(i32*, i32*) 152 153 define i32 @test6(i32* %b) { 154 ; CHECK: @test6 155 entry: 156 %a = alloca [2 x i32] 157 %c = alloca i32 158 ; CHECK-NOT: alloca 159 160 %a1 = getelementptr [2 x i32]* %a, i64 0, i32 1 161 store i32 1, i32* %a1 162 163 %select = select i1 true, i32* %a1, i32* %b 164 %select2 = select i1 false, i32* %a1, i32* %b 165 %select3 = select i1 false, i32* %c, i32* %b 166 ; CHECK: %[[select2:.*]] = select i1 false, i32* undef, i32* %b 167 ; CHECK: %[[select3:.*]] = select i1 false, i32* undef, i32* %b 168 169 ; Note, this would potentially escape the alloca pointer except for the 170 ; constant folding of the select. 171 call void @f(i32* %select2, i32* %select3) 172 ; CHECK: call void @f(i32* %[[select2]], i32* %[[select3]]) 173 174 175 %result = load i32* %select 176 ; CHECK-NOT: load 177 178 %dead = load i32* %c 179 180 ret i32 %result 181 ; CHECK: ret i32 1 182 } 183 184 define i32 @test7() { 185 ; CHECK: @test7 186 ; CHECK-NOT: alloca 187 188 entry: 189 %X = alloca i32 190 br i1 undef, label %good, label %bad 191 192 good: 193 %Y1 = getelementptr i32* %X, i64 0 194 store i32 0, i32* %Y1 195 br label %exit 196 197 bad: 198 %Y2 = getelementptr i32* %X, i64 1 199 store i32 0, i32* %Y2 200 br label %exit 201 202 exit: 203 %P = phi i32* [ %Y1, %good ], [ %Y2, %bad ] 204 ; CHECK: %[[phi:.*]] = phi i32 [ 0, %good ], 205 %Z2 = load i32* %P 206 ret i32 %Z2 207 ; CHECK: ret i32 %[[phi]] 208 } 209 210 define i32 @test8(i32 %b, i32* %ptr) { 211 ; Ensure that we rewrite allocas to the used type when that use is hidden by 212 ; a PHI that can be speculated. 213 ; CHECK: @test8 214 ; CHECK-NOT: alloca 215 ; CHECK-NOT: load 216 ; CHECK: %[[value:.*]] = load i32* %ptr 217 ; CHECK-NOT: load 218 ; CHECK: %[[result:.*]] = phi i32 [ undef, %else ], [ %[[value]], %then ] 219 ; CHECK-NEXT: ret i32 %[[result]] 220 221 entry: 222 %f = alloca float 223 %test = icmp ne i32 %b, 0 224 br i1 %test, label %then, label %else 225 226 then: 227 br label %exit 228 229 else: 230 %bitcast = bitcast float* %f to i32* 231 br label %exit 232 233 exit: 234 %phi = phi i32* [ %bitcast, %else ], [ %ptr, %then ] 235 %loaded = load i32* %phi, align 4 236 ret i32 %loaded 237 } 238 239 define i32 @test9(i32 %b, i32* %ptr) { 240 ; Same as @test8 but for a select rather than a PHI node. 241 ; CHECK: @test9 242 ; CHECK-NOT: alloca 243 ; CHECK-NOT: load 244 ; CHECK: %[[value:.*]] = load i32* %ptr 245 ; CHECK-NOT: load 246 ; CHECK: %[[result:.*]] = select i1 %{{.*}}, i32 undef, i32 %[[value]] 247 ; CHECK-NEXT: ret i32 %[[result]] 248 249 entry: 250 %f = alloca float 251 store i32 0, i32* %ptr 252 %test = icmp ne i32 %b, 0 253 %bitcast = bitcast float* %f to i32* 254 %select = select i1 %test, i32* %bitcast, i32* %ptr 255 %loaded = load i32* %select, align 4 256 ret i32 %loaded 257 } 258 259 define float @test10(i32 %b, float* %ptr) { 260 ; Don't try to promote allocas which are not elligible for it even after 261 ; rewriting due to the necessity of inserting bitcasts when speculating a PHI 262 ; node. 263 ; CHECK: @test10 264 ; CHECK: %[[alloca:.*]] = alloca 265 ; CHECK: %[[argvalue:.*]] = load float* %ptr 266 ; CHECK: %[[cast:.*]] = bitcast double* %[[alloca]] to float* 267 ; CHECK: %[[allocavalue:.*]] = load float* %[[cast]] 268 ; CHECK: %[[result:.*]] = phi float [ %[[allocavalue]], %else ], [ %[[argvalue]], %then ] 269 ; CHECK-NEXT: ret float %[[result]] 270 271 entry: 272 %f = alloca double 273 store double 0.0, double* %f 274 %test = icmp ne i32 %b, 0 275 br i1 %test, label %then, label %else 276 277 then: 278 br label %exit 279 280 else: 281 %bitcast = bitcast double* %f to float* 282 br label %exit 283 284 exit: 285 %phi = phi float* [ %bitcast, %else ], [ %ptr, %then ] 286 %loaded = load float* %phi, align 4 287 ret float %loaded 288 } 289 290 define float @test11(i32 %b, float* %ptr) { 291 ; Same as @test10 but for a select rather than a PHI node. 292 ; CHECK: @test11 293 ; CHECK: %[[alloca:.*]] = alloca 294 ; CHECK: %[[cast:.*]] = bitcast double* %[[alloca]] to float* 295 ; CHECK: %[[allocavalue:.*]] = load float* %[[cast]] 296 ; CHECK: %[[argvalue:.*]] = load float* %ptr 297 ; CHECK: %[[result:.*]] = select i1 %{{.*}}, float %[[allocavalue]], float %[[argvalue]] 298 ; CHECK-NEXT: ret float %[[result]] 299 300 entry: 301 %f = alloca double 302 store double 0.0, double* %f 303 store float 0.0, float* %ptr 304 %test = icmp ne i32 %b, 0 305 %bitcast = bitcast double* %f to float* 306 %select = select i1 %test, float* %bitcast, float* %ptr 307 %loaded = load float* %select, align 4 308 ret float %loaded 309 } 310 311 define i32 @test12(i32 %x, i32* %p) { 312 ; Ensure we don't crash or fail to nuke dead selects of allocas if no load is 313 ; never found. 314 ; CHECK: @test12 315 ; CHECK-NOT: alloca 316 ; CHECK-NOT: select 317 ; CHECK: ret i32 %x 318 319 entry: 320 %a = alloca i32 321 store i32 %x, i32* %a 322 %dead = select i1 undef, i32* %a, i32* %p 323 %load = load i32* %a 324 ret i32 %load 325 } 326 327 define i32 @test13(i32 %x, i32* %p) { 328 ; Ensure we don't crash or fail to nuke dead phis of allocas if no load is ever 329 ; found. 330 ; CHECK: @test13 331 ; CHECK-NOT: alloca 332 ; CHECK-NOT: phi 333 ; CHECK: ret i32 %x 334 335 entry: 336 %a = alloca i32 337 store i32 %x, i32* %a 338 br label %loop 339 340 loop: 341 %phi = phi i32* [ %p, %entry ], [ %a, %loop ] 342 br i1 undef, label %loop, label %exit 343 344 exit: 345 %load = load i32* %a 346 ret i32 %load 347 } 348 349 define i32 @PR13905() { 350 ; Check a pattern where we have a chain of dead phi nodes to ensure they are 351 ; deleted and promotion can proceed. 352 ; CHECK: @PR13905 353 ; CHECK-NOT: alloca i32 354 ; CHECK: ret i32 undef 355 356 entry: 357 %h = alloca i32 358 store i32 0, i32* %h 359 br i1 undef, label %loop1, label %exit 360 361 loop1: 362 %phi1 = phi i32* [ null, %entry ], [ %h, %loop1 ], [ %h, %loop2 ] 363 br i1 undef, label %loop1, label %loop2 364 365 loop2: 366 br i1 undef, label %loop1, label %exit 367 368 exit: 369 %phi2 = phi i32* [ %phi1, %loop2 ], [ null, %entry ] 370 ret i32 undef 371 } 372 373 define i32 @PR13906() { 374 ; Another pattern which can lead to crashes due to failing to clear out dead 375 ; PHI nodes or select nodes. This triggers subtly differently from the above 376 ; cases because the PHI node is (recursively) alive, but the select is dead. 377 ; CHECK: @PR13906 378 ; CHECK-NOT: alloca 379 380 entry: 381 %c = alloca i32 382 store i32 0, i32* %c 383 br label %for.cond 384 385 for.cond: 386 %d.0 = phi i32* [ undef, %entry ], [ %c, %if.then ], [ %d.0, %for.cond ] 387 br i1 undef, label %if.then, label %for.cond 388 389 if.then: 390 %tmpcast.d.0 = select i1 undef, i32* %c, i32* %d.0 391 br label %for.cond 392 } 393 394 define i64 @PR14132(i1 %flag) { 395 ; CHECK: @PR14132 396 ; Here we form a PHI-node by promoting the pointer alloca first, and then in 397 ; order to promote the other two allocas, we speculate the load of the 398 ; now-phi-node-pointer. In doing so we end up loading a 64-bit value from an i8 399 ; alloca. While this is a bit dubious, we were asserting on trying to 400 ; rewrite it. The trick is that the code using the value may carefully take 401 ; steps to only use the not-undef bits, and so we need to at least loosely 402 ; support this.. 403 entry: 404 %a = alloca i64 405 %b = alloca i8 406 %ptr = alloca i64* 407 ; CHECK-NOT: alloca 408 409 %ptr.cast = bitcast i64** %ptr to i8** 410 store i64 0, i64* %a 411 store i8 1, i8* %b 412 store i64* %a, i64** %ptr 413 br i1 %flag, label %if.then, label %if.end 414 415 if.then: 416 store i8* %b, i8** %ptr.cast 417 br label %if.end 418 ; CHECK-NOT: store 419 ; CHECK: %[[ext:.*]] = zext i8 1 to i64 420 421 if.end: 422 %tmp = load i64** %ptr 423 %result = load i64* %tmp 424 ; CHECK-NOT: load 425 ; CHECK: %[[result:.*]] = phi i64 [ %[[ext]], %if.then ], [ 0, %entry ] 426 427 ret i64 %result 428 ; CHECK-NEXT: ret i64 %[[result]] 429 } 430
