llvm/test/Transforms/SROA/phi-and-select.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -sroa -S | FileCheck %s
   3 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"
   4
   5 define i32 @test1() {
   6 ; CHECK-LABEL: @test1(
   7 ; CHECK-NEXT:  entry:
   8 ; CHECK-NEXT:    [[COND:%.*]] = icmp sle i32 0, 1
   9 ; CHECK-NEXT:    br i1 [[COND]], label [[THEN:%.*]], label [[EXIT:%.*]]
  10 ; CHECK:       then:
  11 ; CHECK-NEXT:    br label [[EXIT]]
  12 ; CHECK:       exit:
  13 ; CHECK-NEXT:    [[PHI_SROA_SPECULATED:%.*]] = phi i32 [ 1, [[THEN]] ], [ 0, [[ENTRY:%.*]] ]
  14 ; CHECK-NEXT:    ret i32 [[PHI_SROA_SPECULATED]]
  15 ;
  16 entry:
  17   %a = alloca [2 x i32]
  18
  19   %a0 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 0
  20   %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
  21   store i32 0, i32* %a0
  22   store i32 1, i32* %a1
  23   %v0 = load i32, i32* %a0
  24   %v1 = load i32, i32* %a1
  25
  26   %cond = icmp sle i32 %v0, %v1
  27   br i1 %cond, label %then, label %exit
  28
  29 then:
  30   br label %exit
  31
  32 exit:
  33   %phi = phi i32* [ %a1, %then ], [ %a0, %entry ]
  34
  35   %result = load i32, i32* %phi
  36   ret i32 %result
  37 }
  38
  39 define i32 @test2() {
  40 ; CHECK-LABEL: @test2(
  41 ; CHECK-NEXT:  entry:
  42 ; CHECK-NEXT:    [[COND:%.*]] = icmp sle i32 0, 1
  43 ; CHECK-NEXT:    [[RESULT_SROA_SPECULATED:%.*]] = select i1 [[COND]], i32 1, i32 0
  44 ; CHECK-NEXT:    ret i32 [[RESULT_SROA_SPECULATED]]
  45 ;
  46 entry:
  47   %a = alloca [2 x i32]
  48
  49   %a0 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 0
  50   %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
  51   store i32 0, i32* %a0
  52   store i32 1, i32* %a1
  53   %v0 = load i32, i32* %a0
  54   %v1 = load i32, i32* %a1
  55
  56   %cond = icmp sle i32 %v0, %v1
  57   %select = select i1 %cond, i32* %a1, i32* %a0
  58
  59   %result = load i32, i32* %select
  60   ret i32 %result
  61 }
  62
  63 define float @test2_bitcast() {
  64 ; CHECK-LABEL: @test2_bitcast(
  65 ; CHECK-NEXT:  entry:
  66 ; CHECK-NEXT:    [[COND:%.*]] = icmp sle i32 0, 1
  67 ; CHECK-NEXT:    [[TMP0:%.*]] = bitcast i32 1 to float
  68 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32 0 to float
  69 ; CHECK-NEXT:    [[RESULT_SROA_SPECULATED:%.*]] = select i1 [[COND]], float [[TMP0]], float [[TMP1]]
  70 ; CHECK-NEXT:    ret float [[RESULT_SROA_SPECULATED]]
  71 ;
  72 entry:
  73   %a = alloca [2 x i32]
  74   %a0 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 0
  75   %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
  76   store i32 0, i32* %a0
  77   store i32 1, i32* %a1
  78   %v0 = load i32, i32* %a0
  79   %v1 = load i32, i32* %a1
  80   %cond = icmp sle i32 %v0, %v1
  81   %select = select i1 %cond, i32* %a1, i32* %a0
  82   %select.bc = bitcast i32* %select to float*
  83   %result = load float, float* %select.bc
  84   ret float %result
  85 }
  86
  87 define i32 @test2_addrspacecast() {
  88 ; CHECK-LABEL: @test2_addrspacecast(
  89 ; CHECK-NEXT:  entry:
  90 ; CHECK-NEXT:    [[A_SROA_0:%.*]] = alloca i32, align 4
  91 ; CHECK-NEXT:    [[A_SROA_3:%.*]] = alloca i32, align 4
  92 ; CHECK-NEXT:    store i32 0, i32* [[A_SROA_0]], align 4
  93 ; CHECK-NEXT:    store i32 1, i32* [[A_SROA_3]], align 4
  94 ; CHECK-NEXT:    [[A_SROA_0_0_A_SROA_0_0_V0:%.*]] = load i32, i32* [[A_SROA_0]], align 4
  95 ; CHECK-NEXT:    [[A_SROA_3_0_A_SROA_3_4_V1:%.*]] = load i32, i32* [[A_SROA_3]], align 4
  96 ; CHECK-NEXT:    [[COND:%.*]] = icmp sle i32 [[A_SROA_0_0_A_SROA_0_0_V0]], [[A_SROA_3_0_A_SROA_3_4_V1]]
  97 ; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[COND]], i32* [[A_SROA_3]], i32* [[A_SROA_0]]
  98 ; CHECK-NEXT:    [[SELECT_ASC:%.*]] = addrspacecast i32* [[SELECT]] to i32 addrspace(1)*
  99 ; CHECK-NEXT:    [[RESULT:%.*]] = load i32, i32 addrspace(1)* [[SELECT_ASC]], align 4
 100 ; CHECK-NEXT:    ret i32 [[RESULT]]
 101 ;
 102 entry:
 103   %a = alloca [2 x i32]
 104   %a0 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 0
 105   %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
 106   store i32 0, i32* %a0
 107   store i32 1, i32* %a1
 108   %v0 = load i32, i32* %a0
 109   %v1 = load i32, i32* %a1
 110   %cond = icmp sle i32 %v0, %v1
 111   %select = select i1 %cond, i32* %a1, i32* %a0
 112   %select.asc = addrspacecast i32* %select to i32 addrspace(1)*
 113   %result = load i32, i32 addrspace(1)* %select.asc
 114   ret i32 %result
 115 }
 116
 117 define i32 @test3(i32 %x) {
 118 ; CHECK-LABEL: @test3(
 119 ; CHECK-NEXT:  entry:
 120 ; CHECK-NEXT:    switch i32 [[X:%.*]], label [[BB0:%.*]] [
 121 ; CHECK-NEXT:    i32 1, label [[BB1:%.*]]
 122 ; CHECK-NEXT:    i32 2, label [[BB2:%.*]]
 123 ; CHECK-NEXT:    i32 3, label [[BB3:%.*]]
 124 ; CHECK-NEXT:    i32 4, label [[BB4:%.*]]
 125 ; CHECK-NEXT:    i32 5, label [[BB5:%.*]]
 126 ; CHECK-NEXT:    i32 6, label [[BB6:%.*]]
 127 ; CHECK-NEXT:    i32 7, label [[BB7:%.*]]
 128 ; CHECK-NEXT:    ]
 129 ; CHECK:       bb0:
 130 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 131 ; CHECK:       bb1:
 132 ; CHECK-NEXT:    br label [[EXIT]]
 133 ; CHECK:       bb2:
 134 ; CHECK-NEXT:    br label [[EXIT]]
 135 ; CHECK:       bb3:
 136 ; CHECK-NEXT:    br label [[EXIT]]
 137 ; CHECK:       bb4:
 138 ; CHECK-NEXT:    br label [[EXIT]]
 139 ; CHECK:       bb5:
 140 ; CHECK-NEXT:    br label [[EXIT]]
 141 ; CHECK:       bb6:
 142 ; CHECK-NEXT:    br label [[EXIT]]
 143 ; CHECK:       bb7:
 144 ; CHECK-NEXT:    br label [[EXIT]]
 145 ; CHECK:       exit:
 146 ; CHECK-NEXT:    [[PHI_SROA_SPECULATED:%.*]] = phi i32 [ 1, [[BB0]] ], [ 0, [[BB1]] ], [ 0, [[BB2]] ], [ 1, [[BB3]] ], [ 1, [[BB4]] ], [ 0, [[BB5]] ], [ 0, [[BB6]] ], [ 1, [[BB7]] ]
 147 ; CHECK-NEXT:    ret i32 [[PHI_SROA_SPECULATED]]
 148 ;
 149 entry:
 150   %a = alloca [2 x i32]
 151
 152   ; Note that we build redundant GEPs here to ensure that having different GEPs
 153   ; into the same alloca partation continues to work with PHI speculation. This
 154   ; was the underlying cause of PR13926.
 155   %a0 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 0
 156   %a0b = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 0
 157   %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
 158   %a1b = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
 159   store i32 0, i32* %a0
 160   store i32 1, i32* %a1
 161
 162   switch i32 %x, label %bb0 [ i32 1, label %bb1
 163   i32 2, label %bb2
 164   i32 3, label %bb3
 165   i32 4, label %bb4
 166   i32 5, label %bb5
 167   i32 6, label %bb6
 168   i32 7, label %bb7 ]
 169
 170 bb0:
 171   br label %exit
 172 bb1:
 173   br label %exit
 174 bb2:
 175   br label %exit
 176 bb3:
 177   br label %exit
 178 bb4:
 179   br label %exit
 180 bb5:
 181   br label %exit
 182 bb6:
 183   br label %exit
 184 bb7:
 185   br label %exit
 186
 187 exit:
 188   %phi = phi i32* [ %a1, %bb0 ], [ %a0, %bb1 ], [ %a0, %bb2 ], [ %a1, %bb3 ],
 189   [ %a1b, %bb4 ], [ %a0b, %bb5 ], [ %a0b, %bb6 ], [ %a1b, %bb7 ]
 190
 191   %result = load i32, i32* %phi
 192   ret i32 %result
 193 }
 194
 195 define i32 @test4() {
 196 ; CHECK-LABEL: @test4(
 197 ; CHECK-NEXT:  entry:
 198 ; CHECK-NEXT:    ret i32 0
 199 ;
 200 entry:
 201   %a = alloca [2 x i32]
 202
 203   %a0 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 0
 204   %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
 205   store i32 0, i32* %a0
 206   store i32 1, i32* %a1
 207   %v0 = load i32, i32* %a0
 208   %v1 = load i32, i32* %a1
 209
 210   %cond = icmp sle i32 %v0, %v1
 211   %select = select i1 %cond, i32* %a0, i32* %a0
 212
 213   %result = load i32, i32* %select
 214   ret i32 %result
 215 }
 216
 217 define i32 @test5(i32* %b) {
 218 ; CHECK-LABEL: @test5(
 219 ; CHECK-NEXT:  entry:
 220 ; CHECK-NEXT:    ret i32 1
 221 ;
 222 entry:
 223   %a = alloca [2 x i32]
 224
 225   %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
 226   store i32 1, i32* %a1
 227
 228   %select = select i1 true, i32* %a1, i32* %b
 229
 230   %result = load i32, i32* %select
 231
 232   ret i32 %result
 233 }
 234
 235 declare void @f(i32*, i32*)
 236
 237 define i32 @test6(i32* %b) {
 238 ; CHECK-LABEL: @test6(
 239 ; CHECK-NEXT:  entry:
 240 ; CHECK-NEXT:    [[SELECT2:%.*]] = select i1 false, i32* undef, i32* [[B:%.*]]
 241 ; CHECK-NEXT:    [[SELECT3:%.*]] = select i1 false, i32* undef, i32* [[B]]
 242 ; CHECK-NEXT:    call void @f(i32* [[SELECT2]], i32* [[SELECT3]])
 243 ; CHECK-NEXT:    ret i32 1
 244 ;
 245 entry:
 246   %a = alloca [2 x i32]
 247   %c = alloca i32
 248
 249   %a1 = getelementptr [2 x i32], [2 x i32]* %a, i64 0, i32 1
 250   store i32 1, i32* %a1
 251
 252   %select = select i1 true, i32* %a1, i32* %b
 253   %select2 = select i1 false, i32* %a1, i32* %b
 254   %select3 = select i1 false, i32* %c, i32* %b
 255
 256   ; Note, this would potentially escape the alloca pointer except for the
 257   ; constant folding of the select.
 258   call void @f(i32* %select2, i32* %select3)
 259
 260
 261   %result = load i32, i32* %select
 262
 263   %dead = load i32, i32* %c
 264
 265   ret i32 %result
 266 }
 267
 268 define i32 @test7() {
 269 ; CHECK-LABEL: @test7(
 270 ; CHECK-NEXT:  entry:
 271 ; CHECK-NEXT:    br i1 undef, label [[GOOD:%.*]], label [[BAD:%.*]]
 272 ; CHECK:       good:
 273 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 274 ; CHECK:       bad:
 275 ; CHECK-NEXT:    [[P_SROA_SPECULATE_LOAD_BAD:%.*]] = load i32, i32* undef, align 4
 276 ; CHECK-NEXT:    br label [[EXIT]]
 277 ; CHECK:       exit:
 278 ; CHECK-NEXT:    [[P_SROA_SPECULATED:%.*]] = phi i32 [ 0, [[GOOD]] ], [ [[P_SROA_SPECULATE_LOAD_BAD]], [[BAD]] ]
 279 ; CHECK-NEXT:    ret i32 [[P_SROA_SPECULATED]]
 280 ;
 281
 282 entry:
 283   %X = alloca i32
 284   br i1 undef, label %good, label %bad
 285
 286 good:
 287   %Y1 = getelementptr i32, i32* %X, i64 0
 288   store i32 0, i32* %Y1
 289   br label %exit
 290
 291 bad:
 292   %Y2 = getelementptr i32, i32* %X, i64 1
 293   store i32 0, i32* %Y2
 294   br label %exit
 295
 296 exit:
 297   %P = phi i32* [ %Y1, %good ], [ %Y2, %bad ]
 298   %Z2 = load i32, i32* %P
 299   ret i32 %Z2
 300 }
 301
 302 define i32 @test8(i32 %b, i32* %ptr) {
 303 ; Ensure that we rewrite allocas to the used type when that use is hidden by
 304 ; a PHI that can be speculated.
 305 ; CHECK-LABEL: @test8(
 306 ; CHECK-NEXT:  entry:
 307 ; CHECK-NEXT:    [[TEST:%.*]] = icmp ne i32 [[B:%.*]], 0
 308 ; CHECK-NEXT:    br i1 [[TEST]], label [[THEN:%.*]], label [[ELSE:%.*]]
 309 ; CHECK:       then:
 310 ; CHECK-NEXT:    [[PHI_SROA_SPECULATE_LOAD_THEN:%.*]] = load i32, i32* [[PTR:%.*]], align 4
 311 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 312 ; CHECK:       else:
 313 ; CHECK-NEXT:    br label [[EXIT]]
 314 ; CHECK:       exit:
 315 ; CHECK-NEXT:    [[PHI_SROA_SPECULATED:%.*]] = phi i32 [ undef, [[ELSE]] ], [ [[PHI_SROA_SPECULATE_LOAD_THEN]], [[THEN]] ]
 316 ; CHECK-NEXT:    ret i32 [[PHI_SROA_SPECULATED]]
 317 ;
 318
 319 entry:
 320   %f = alloca float
 321   %test = icmp ne i32 %b, 0
 322   br i1 %test, label %then, label %else
 323
 324 then:
 325   br label %exit
 326
 327 else:
 328   %bitcast = bitcast float* %f to i32*
 329   br label %exit
 330
 331 exit:
 332   %phi = phi i32* [ %bitcast, %else ], [ %ptr, %then ]
 333   %loaded = load i32, i32* %phi, align 4
 334   ret i32 %loaded
 335 }
 336
 337 define i32 @test9(i32 %b, i32* %ptr) {
 338 ; Same as @test8 but for a select rather than a PHI node.
 339 ; CHECK-LABEL: @test9(
 340 ; CHECK-NEXT:  entry:
 341 ; CHECK-NEXT:    store i32 0, i32* [[PTR:%.*]], align 4
 342 ; CHECK-NEXT:    [[TEST:%.*]] = icmp ne i32 [[B:%.*]], 0
 343 ; CHECK-NEXT:    [[LOADED_SROA_SPECULATE_LOAD_FALSE:%.*]] = load i32, i32* [[PTR]], align 4
 344 ; CHECK-NEXT:    [[LOADED_SROA_SPECULATED:%.*]] = select i1 [[TEST]], i32 undef, i32 [[LOADED_SROA_SPECULATE_LOAD_FALSE]]
 345 ; CHECK-NEXT:    ret i32 [[LOADED_SROA_SPECULATED]]
 346 ;
 347
 348 entry:
 349   %f = alloca float
 350   store i32 0, i32* %ptr
 351   %test = icmp ne i32 %b, 0
 352   %bitcast = bitcast float* %f to i32*
 353   %select = select i1 %test, i32* %bitcast, i32* %ptr
 354   %loaded = load i32, i32* %select, align 4
 355   ret i32 %loaded
 356 }
 357
 358 define float @test10(i32 %b, float* %ptr) {
 359 ; Don't try to promote allocas which are not elligible for it even after
 360 ; rewriting due to the necessity of inserting bitcasts when speculating a PHI
 361 ; node.
 362 ; CHECK-LABEL: @test10(
 363 ; CHECK-NEXT:  entry:
 364 ; CHECK-NEXT:    [[F:%.*]] = alloca double, align 8
 365 ; CHECK-NEXT:    store double 0.000000e+00, double* [[F]], align 8
 366 ; CHECK-NEXT:    [[TEST:%.*]] = icmp ne i32 [[B:%.*]], 0
 367 ; CHECK-NEXT:    br i1 [[TEST]], label [[THEN:%.*]], label [[ELSE:%.*]]
 368 ; CHECK:       then:
 369 ; CHECK-NEXT:    [[PHI_SROA_SPECULATE_LOAD_THEN:%.*]] = load float, float* [[PTR:%.*]], align 4
 370 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 371 ; CHECK:       else:
 372 ; CHECK-NEXT:    [[F_0_F_0_BITCAST_SROA_CAST:%.*]] = bitcast double* [[F]] to float*
 373 ; CHECK-NEXT:    [[F_0_PHI_SROA_SPECULATE_LOAD_ELSE:%.*]] = load float, float* [[F_0_F_0_BITCAST_SROA_CAST]], align 8
 374 ; CHECK-NEXT:    br label [[EXIT]]
 375 ; CHECK:       exit:
 376 ; CHECK-NEXT:    [[PHI_SROA_SPECULATED:%.*]] = phi float [ [[F_0_PHI_SROA_SPECULATE_LOAD_ELSE]], [[ELSE]] ], [ [[PHI_SROA_SPECULATE_LOAD_THEN]], [[THEN]] ]
 377 ; CHECK-NEXT:    ret float [[PHI_SROA_SPECULATED]]
 378 ;
 379
 380 entry:
 381   %f = alloca double
 382   store double 0.0, double* %f
 383   %test = icmp ne i32 %b, 0
 384   br i1 %test, label %then, label %else
 385
 386 then:
 387   br label %exit
 388
 389 else:
 390   %bitcast = bitcast double* %f to float*
 391   br label %exit
 392
 393 exit:
 394   %phi = phi float* [ %bitcast, %else ], [ %ptr, %then ]
 395   %loaded = load float, float* %phi, align 4
 396   ret float %loaded
 397 }
 398
 399 define float @test11(i32 %b, float* %ptr) {
 400 ; Same as @test10 but for a select rather than a PHI node.
 401 ; CHECK-LABEL: @test11(
 402 ; CHECK-NEXT:  entry:
 403 ; CHECK-NEXT:    [[F:%.*]] = alloca double, align 8
 404 ; CHECK-NEXT:    store double 0.000000e+00, double* [[F]], align 8
 405 ; CHECK-NEXT:    store float 0.000000e+00, float* [[PTR:%.*]], align 4
 406 ; CHECK-NEXT:    [[TEST:%.*]] = icmp ne i32 [[B:%.*]], 0
 407 ; CHECK-NEXT:    [[F_0_F_0_BITCAST_SROA_CAST:%.*]] = bitcast double* [[F]] to float*
 408 ; CHECK-NEXT:    [[F_0_LOADED_SROA_SPECULATE_LOAD_TRUE:%.*]] = load float, float* [[F_0_F_0_BITCAST_SROA_CAST]], align 8
 409 ; CHECK-NEXT:    [[LOADED_SROA_SPECULATE_LOAD_FALSE:%.*]] = load float, float* [[PTR]], align 4
 410 ; CHECK-NEXT:    [[LOADED_SROA_SPECULATED:%.*]] = select i1 [[TEST]], float [[F_0_LOADED_SROA_SPECULATE_LOAD_TRUE]], float [[LOADED_SROA_SPECULATE_LOAD_FALSE]]
 411 ; CHECK-NEXT:    ret float [[LOADED_SROA_SPECULATED]]
 412 ;
 413
 414 entry:
 415   %f = alloca double
 416   store double 0.0, double* %f
 417   store float 0.0, float* %ptr
 418   %test = icmp ne i32 %b, 0
 419   %bitcast = bitcast double* %f to float*
 420   %select = select i1 %test, float* %bitcast, float* %ptr
 421   %loaded = load float, float* %select, align 4
 422   ret float %loaded
 423 }
 424
 425 define i32 @test12(i32 %x, i32* %p) {
 426 ; Ensure we don't crash or fail to nuke dead selects of allocas if no load is
 427 ; never found.
 428 ; CHECK-LABEL: @test12(
 429 ; CHECK-NEXT:  entry:
 430 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 431 ;
 432
 433 entry:
 434   %a = alloca i32
 435   store i32 %x, i32* %a
 436   %dead = select i1 undef, i32* %a, i32* %p
 437   %load = load i32, i32* %a
 438   ret i32 %load
 439 }
 440
 441 define i32 @test13(i32 %x, i32* %p) {
 442 ; Ensure we don't crash or fail to nuke dead phis of allocas if no load is ever
 443 ; found.
 444 ; CHECK-LABEL: @test13(
 445 ; CHECK-NEXT:  entry:
 446 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 447 ; CHECK:       loop:
 448 ; CHECK-NEXT:    br i1 undef, label [[LOOP]], label [[EXIT:%.*]]
 449 ; CHECK:       exit:
 450 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 451 ;
 452
 453 entry:
 454   %a = alloca i32
 455   store i32 %x, i32* %a
 456   br label %loop
 457
 458 loop:
 459   %phi = phi i32* [ %p, %entry ], [ %a, %loop ]
 460   br i1 undef, label %loop, label %exit
 461
 462 exit:
 463   %load = load i32, i32* %a
 464   ret i32 %load
 465 }
 466
 467 define i32 @test14(i1 %b1, i1 %b2, i32* %ptr) {
 468 ; Check for problems when there are both selects and phis and one is
 469 ; speculatable toward promotion but the other is not. That should block all of
 470 ; the speculation.
 471 ; CHECK-LABEL: @test14(
 472 ; CHECK-NEXT:  entry:
 473 ; CHECK-NEXT:    [[F:%.*]] = alloca i32, align 4
 474 ; CHECK-NEXT:    [[G:%.*]] = alloca i32, align 4
 475 ; CHECK-NEXT:    store i32 0, i32* [[F]], align 4
 476 ; CHECK-NEXT:    store i32 0, i32* [[G]], align 4
 477 ; CHECK-NEXT:    [[F_SELECT:%.*]] = select i1 [[B1:%.*]], i32* [[F]], i32* [[PTR:%.*]]
 478 ; CHECK-NEXT:    br i1 [[B2:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
 479 ; CHECK:       then:
 480 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 481 ; CHECK:       else:
 482 ; CHECK-NEXT:    br label [[EXIT]]
 483 ; CHECK:       exit:
 484 ; CHECK-NEXT:    [[F_PHI:%.*]] = phi i32* [ [[F]], [[THEN]] ], [ [[F_SELECT]], [[ELSE]] ]
 485 ; CHECK-NEXT:    [[G_PHI:%.*]] = phi i32* [ [[G]], [[THEN]] ], [ [[PTR]], [[ELSE]] ]
 486 ; CHECK-NEXT:    [[F_LOADED:%.*]] = load i32, i32* [[F_PHI]], align 4
 487 ; CHECK-NEXT:    [[G_SELECT:%.*]] = select i1 [[B1]], i32* [[G]], i32* [[G_PHI]]
 488 ; CHECK-NEXT:    [[G_LOADED:%.*]] = load i32, i32* [[G_SELECT]], align 4
 489 ; CHECK-NEXT:    [[RESULT:%.*]] = add i32 [[F_LOADED]], [[G_LOADED]]
 490 ; CHECK-NEXT:    ret i32 [[RESULT]]
 491 ;
 492
 493 entry:
 494   %f = alloca i32
 495   %g = alloca i32
 496   store i32 0, i32* %f
 497   store i32 0, i32* %g
 498   %f.select = select i1 %b1, i32* %f, i32* %ptr
 499   br i1 %b2, label %then, label %else
 500
 501 then:
 502   br label %exit
 503
 504 else:
 505   br label %exit
 506
 507 exit:
 508   %f.phi = phi i32* [ %f, %then ], [ %f.select, %else ]
 509   %g.phi = phi i32* [ %g, %then ], [ %ptr, %else ]
 510   %f.loaded = load i32, i32* %f.phi
 511   %g.select = select i1 %b1, i32* %g, i32* %g.phi
 512   %g.loaded = load i32, i32* %g.select
 513   %result = add i32 %f.loaded, %g.loaded
 514   ret i32 %result
 515 }
 516
 517 define i32 @PR13905() {
 518 ; Check a pattern where we have a chain of dead phi nodes to ensure they are
 519 ; deleted and promotion can proceed.
 520 ; CHECK-LABEL: @PR13905(
 521 ; CHECK-NEXT:  entry:
 522 ; CHECK-NEXT:    br i1 undef, label [[LOOP1:%.*]], label [[EXIT:%.*]]
 523 ; CHECK:       loop1:
 524 ; CHECK-NEXT:    br i1 undef, label [[LOOP1]], label [[LOOP2:%.*]]
 525 ; CHECK:       loop2:
 526 ; CHECK-NEXT:    br i1 undef, label [[LOOP1]], label [[EXIT]]
 527 ; CHECK:       exit:
 528 ; CHECK-NEXT:    [[PHI2:%.*]] = phi i32* [ undef, [[LOOP2]] ], [ null, [[ENTRY:%.*]] ]
 529 ; CHECK-NEXT:    ret i32 undef
 530 ;
 531
 532 entry:
 533   %h = alloca i32
 534   store i32 0, i32* %h
 535   br i1 undef, label %loop1, label %exit
 536
 537 loop1:
 538   %phi1 = phi i32* [ null, %entry ], [ %h, %loop1 ], [ %h, %loop2 ]
 539   br i1 undef, label %loop1, label %loop2
 540
 541 loop2:
 542   br i1 undef, label %loop1, label %exit
 543
 544 exit:
 545   %phi2 = phi i32* [ %phi1, %loop2 ], [ null, %entry ]
 546   ret i32 undef
 547 }
 548
 549 define i32 @PR13906() {
 550 ; Another pattern which can lead to crashes due to failing to clear out dead
 551 ; PHI nodes or select nodes. This triggers subtly differently from the above
 552 ; cases because the PHI node is (recursively) alive, but the select is dead.
 553 ; CHECK-LABEL: @PR13906(
 554 ; CHECK-NEXT:  entry:
 555 ; CHECK-NEXT:    br label [[FOR_COND:%.*]]
 556 ; CHECK:       for.cond:
 557 ; CHECK-NEXT:    br i1 undef, label [[IF_THEN:%.*]], label [[FOR_COND]]
 558 ; CHECK:       if.then:
 559 ; CHECK-NEXT:    br label [[FOR_COND]]
 560 ;
 561
 562 entry:
 563   %c = alloca i32
 564   store i32 0, i32* %c
 565   br label %for.cond
 566
 567 for.cond:
 568   %d.0 = phi i32* [ undef, %entry ], [ %c, %if.then ], [ %d.0, %for.cond ]
 569   br i1 undef, label %if.then, label %for.cond
 570
 571 if.then:
 572   %tmpcast.d.0 = select i1 undef, i32* %c, i32* %d.0
 573   br label %for.cond
 574 }
 575
 576 define i64 @PR14132(i1 %flag) {
 577 ; CHECK-LABEL: @PR14132(
 578 ; CHECK-NEXT:  entry:
 579 ; CHECK-NEXT:    br i1 [[FLAG:%.*]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 580 ; CHECK:       if.then:
 581 ; CHECK-NEXT:    [[B_0_LOAD_EXT:%.*]] = zext i8 1 to i64
 582 ; CHECK-NEXT:    br label [[IF_END]]
 583 ; CHECK:       if.end:
 584 ; CHECK-NEXT:    [[PTR_0_SROA_SPECULATED:%.*]] = phi i64 [ [[B_0_LOAD_EXT]], [[IF_THEN]] ], [ 0, [[ENTRY:%.*]] ]
 585 ; CHECK-NEXT:    ret i64 [[PTR_0_SROA_SPECULATED]]
 586 ;
 587 ; Here we form a PHI-node by promoting the pointer alloca first, and then in
 588 ; order to promote the other two allocas, we speculate the load of the
 589 ; now-phi-node-pointer. In doing so we end up loading a 64-bit value from an i8
 590 ; alloca. While this is a bit dubious, we were asserting on trying to
 591 ; rewrite it. The trick is that the code using the value may carefully take
 592 ; steps to only use the not-undef bits, and so we need to at least loosely
 593 ; support this..
 594 entry:
 595   %a = alloca i64, align 8
 596   %b = alloca i8, align 8
 597   %ptr = alloca i64*, align 8
 598
 599   %ptr.cast = bitcast i64** %ptr to i8**
 600   store i64 0, i64* %a, align 8
 601   store i8 1, i8* %b, align 8
 602   store i64* %a, i64** %ptr, align 8
 603   br i1 %flag, label %if.then, label %if.end
 604
 605 if.then:
 606   store i8* %b, i8** %ptr.cast, align 8
 607   br label %if.end
 608
 609 if.end:
 610   %tmp = load i64*, i64** %ptr, align 8
 611   %result = load i64, i64* %tmp, align 8
 612
 613   ret i64 %result
 614 }
 615
 616 define float @PR16687(i64 %x, i1 %flag) {
 617 ; CHECK-LABEL: @PR16687(
 618 ; CHECK-NEXT:  entry:
 619 ; CHECK-NEXT:    [[A_SROA_0_0_EXTRACT_TRUNC:%.*]] = trunc i64 [[X:%.*]] to i32
 620 ; CHECK-NEXT:    [[A_SROA_2_0_EXTRACT_SHIFT:%.*]] = lshr i64 [[X]], 32
 621 ; CHECK-NEXT:    [[A_SROA_2_0_EXTRACT_TRUNC:%.*]] = trunc i64 [[A_SROA_2_0_EXTRACT_SHIFT]] to i32
 622 ; CHECK-NEXT:    br i1 [[FLAG:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
 623 ; CHECK:       then:
 624 ; CHECK-NEXT:    [[TMP0:%.*]] = bitcast i32 [[A_SROA_0_0_EXTRACT_TRUNC]] to float
 625 ; CHECK-NEXT:    br label [[END:%.*]]
 626 ; CHECK:       else:
 627 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32 [[A_SROA_2_0_EXTRACT_TRUNC]] to float
 628 ; CHECK-NEXT:    br label [[END]]
 629 ; CHECK:       end:
 630 ; CHECK-NEXT:    [[A_PHI_F_SROA_SPECULATED:%.*]] = phi float [ [[TMP0]], [[THEN]] ], [ [[TMP1]], [[ELSE]] ]
 631 ; CHECK-NEXT:    ret float [[A_PHI_F_SROA_SPECULATED]]
 632 ;
 633 ; Check that even when we try to speculate the same phi twice (in two slices)
 634 ; on an otherwise promotable construct, we don't get ahead of ourselves and try
 635 ; to promote one of the slices prior to speculating it.
 636
 637 entry:
 638   %a = alloca i64, align 8
 639   store i64 %x, i64* %a
 640   br i1 %flag, label %then, label %else
 641
 642 then:
 643   %a.f = bitcast i64* %a to float*
 644   br label %end
 645
 646 else:
 647   %a.raw = bitcast i64* %a to i8*
 648   %a.raw.4 = getelementptr i8, i8* %a.raw, i64 4
 649   %a.raw.4.f = bitcast i8* %a.raw.4 to float*
 650   br label %end
 651
 652 end:
 653   %a.phi.f = phi float* [ %a.f, %then ], [ %a.raw.4.f, %else ]
 654   %f = load float, float* %a.phi.f
 655   ret float %f
 656 }
 657
 658 ; Verifies we fixed PR20425. We should be able to promote all alloca's to
 659 ; registers in this test.
 660 ;
 661 ; %0 = slice
 662 ; %1 = slice
 663 ; %2 = phi(%0, %1) // == slice
 664 define float @simplify_phi_nodes_that_equal_slice(i1 %cond, float* %temp) {
 665 ; CHECK-LABEL: @simplify_phi_nodes_that_equal_slice(
 666 ; CHECK-NEXT:  entry:
 667 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
 668 ; CHECK:       then:
 669 ; CHECK-NEXT:    br label [[MERGE:%.*]]
 670 ; CHECK:       else:
 671 ; CHECK-NEXT:    br label [[MERGE]]
 672 ; CHECK:       merge:
 673 ; CHECK-NEXT:    [[ARR_SROA_0_0:%.*]] = phi float [ 1.000000e+00, [[THEN]] ], [ 2.000000e+00, [[ELSE]] ]
 674 ; CHECK-NEXT:    store float 0.000000e+00, float* [[TEMP:%.*]], align 4
 675 ; CHECK-NEXT:    ret float [[ARR_SROA_0_0]]
 676 ;
 677 entry:
 678   %arr = alloca [4 x float], align 4
 679   br i1 %cond, label %then, label %else
 680
 681 then:
 682   %0 = getelementptr inbounds [4 x float], [4 x float]* %arr, i64 0, i64 3
 683   store float 1.000000e+00, float* %0, align 4
 684   br label %merge
 685
 686 else:
 687   %1 = getelementptr inbounds [4 x float], [4 x float]* %arr, i64 0, i64 3
 688   store float 2.000000e+00, float* %1, align 4
 689   br label %merge
 690
 691 merge:
 692   %2 = phi float* [ %0, %then ], [ %1, %else ]
 693   store float 0.000000e+00, float* %temp, align 4
 694   %3 = load float, float* %2, align 4
 695   ret float %3
 696 }
 697
 698 ; A slightly complicated example for PR20425.
 699 ;
 700 ; %0 = slice
 701 ; %1 = phi(%0) // == slice
 702 ; %2 = slice
 703 ; %3 = phi(%1, %2) // == slice
 704 define float @simplify_phi_nodes_that_equal_slice_2(i1 %cond, float* %temp) {
 705 ; CHECK-LABEL: @simplify_phi_nodes_that_equal_slice_2(
 706 ; CHECK-NEXT:  entry:
 707 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
 708 ; CHECK:       then:
 709 ; CHECK-NEXT:    br label [[THEN2:%.*]]
 710 ; CHECK:       then2:
 711 ; CHECK-NEXT:    br label [[MERGE:%.*]]
 712 ; CHECK:       else:
 713 ; CHECK-NEXT:    br label [[MERGE]]
 714 ; CHECK:       merge:
 715 ; CHECK-NEXT:    [[ARR_SROA_0_0:%.*]] = phi float [ 2.000000e+00, [[THEN2]] ], [ 3.000000e+00, [[ELSE]] ]
 716 ; CHECK-NEXT:    store float 0.000000e+00, float* [[TEMP:%.*]], align 4
 717 ; CHECK-NEXT:    ret float [[ARR_SROA_0_0]]
 718 ;
 719 entry:
 720   %arr = alloca [4 x float], align 4
 721   br i1 %cond, label %then, label %else
 722
 723 then:
 724   %0 = getelementptr inbounds [4 x float], [4 x float]* %arr, i64 0, i64 3
 725   store float 1.000000e+00, float* %0, align 4
 726   br label %then2
 727
 728 then2:
 729   %1 = phi float* [ %0, %then ]
 730   store float 2.000000e+00, float* %1, align 4
 731   br label %merge
 732
 733 else:
 734   %2 = getelementptr inbounds [4 x float], [4 x float]* %arr, i64 0, i64 3
 735   store float 3.000000e+00, float* %2, align 4
 736   br label %merge
 737
 738 merge:
 739   %3 = phi float* [ %1, %then2 ], [ %2, %else ]
 740   store float 0.000000e+00, float* %temp, align 4
 741   %4 = load float, float* %3, align 4
 742   ret float %4
 743 }
 744
 745 %struct.S = type { i32 }
 746
 747 ; Verifies we fixed PR20822. We have a foldable PHI feeding a speculatable PHI
 748 ; which requires the rewriting of the speculated PHI to handle insertion
 749 ; when the incoming pointer is itself from a PHI node. We would previously
 750 ; insert a bitcast instruction *before* a PHI, producing an invalid module;
 751 ; make sure we insert *after* the first non-PHI instruction.
 752 define void @PR20822() {
 753 ; CHECK-LABEL: @PR20822(
 754 ; CHECK-NEXT:  entry:
 755 ; CHECK-NEXT:    [[F_SROA_0:%.*]] = alloca i32, align 4
 756 ; CHECK-NEXT:    br i1 undef, label [[IF_END:%.*]], label [[FOR_COND:%.*]]
 757 ; CHECK:       for.cond:
 758 ; CHECK-NEXT:    br label [[IF_END]]
 759 ; CHECK:       if.end:
 760 ; CHECK-NEXT:    [[TMP0:%.*]] = phi i32 [ undef, [[ENTRY:%.*]] ], [ undef, [[FOR_COND]] ]
 761 ; CHECK-NEXT:    [[F_SROA_0_0_F2_SROA_CAST1:%.*]] = bitcast i32* [[F_SROA_0]] to %struct.S*
 762 ; CHECK-NEXT:    br i1 undef, label [[IF_THEN5:%.*]], label [[IF_THEN2:%.*]]
 763 ; CHECK:       if.then2:
 764 ; CHECK-NEXT:    br label [[IF_THEN5]]
 765 ; CHECK:       if.then5:
 766 ; CHECK-NEXT:    [[F1:%.*]] = phi %struct.S* [ undef, [[IF_THEN2]] ], [ [[F_SROA_0_0_F2_SROA_CAST1]], [[IF_END]] ]
 767 ; CHECK-NEXT:    [[DOTFCA_0_GEP:%.*]] = getelementptr inbounds [[STRUCT_S:%.*]], %struct.S* [[F1]], i32 0, i32 0
 768 ; CHECK-NEXT:    store i32 undef, i32* [[DOTFCA_0_GEP]], align 4
 769 ; CHECK-NEXT:    ret void
 770 ;
 771 entry:
 772   %f = alloca %struct.S, align 4
 773   br i1 undef, label %if.end, label %for.cond
 774
 775 for.cond:                                         ; preds = %for.cond, %entry
 776   br label %if.end
 777
 778 if.end:                                           ; preds = %for.cond, %entry
 779   %f2 = phi %struct.S* [ %f, %entry ], [ %f, %for.cond ]
 780   phi i32 [ undef, %entry ], [ undef, %for.cond ]
 781   br i1 undef, label %if.then5, label %if.then2
 782
 783 if.then2:                                         ; preds = %if.end
 784   br label %if.then5
 785
 786 if.then5:                                         ; preds = %if.then2, %if.end
 787   %f1 = phi %struct.S* [ undef, %if.then2 ], [ %f2, %if.end ]
 788   store %struct.S undef, %struct.S* %f1, align 4
 789   ret void
 790 }
 791
 792 define i32 @phi_align(i32* %z) {
 793 ; CHECK-LABEL: @phi_align(
 794 ; CHECK-NEXT:  entry:
 795 ; CHECK-NEXT:    [[A_SROA_0:%.*]] = alloca [7 x i8], align 1
 796 ; CHECK-NEXT:    [[A_SROA_0_3_A1_SROA_IDX:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_0]], i64 0, i64 3
 797 ; CHECK-NEXT:    [[A_SROA_0_3_A1_SROA_CAST:%.*]] = bitcast i8* [[A_SROA_0_3_A1_SROA_IDX]] to i32*
 798 ; CHECK-NEXT:    [[A_SROA_0_0_A0_SROA_CAST:%.*]] = bitcast [7 x i8]* [[A_SROA_0]] to i32*
 799 ; CHECK-NEXT:    store i32 0, i32* [[A_SROA_0_0_A0_SROA_CAST]], align 1
 800 ; CHECK-NEXT:    [[A_SROA_0_3_A1_SROA_IDX7:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_0]], i64 0, i64 3
 801 ; CHECK-NEXT:    [[A_SROA_0_3_A1_SROA_CAST8:%.*]] = bitcast i8* [[A_SROA_0_3_A1_SROA_IDX7]] to i32*
 802 ; CHECK-NEXT:    store i32 1, i32* [[A_SROA_0_3_A1_SROA_CAST8]], align 1
 803 ; CHECK-NEXT:    [[A_SROA_0_0_A0_SROA_CAST6:%.*]] = bitcast [7 x i8]* [[A_SROA_0]] to i32*
 804 ; CHECK-NEXT:    [[A_SROA_0_0_A_SROA_0_1_V0:%.*]] = load i32, i32* [[A_SROA_0_0_A0_SROA_CAST6]], align 1
 805 ; CHECK-NEXT:    [[A_SROA_0_3_A1_SROA_IDX9:%.*]] = getelementptr inbounds [7 x i8], [7 x i8]* [[A_SROA_0]], i64 0, i64 3
 806 ; CHECK-NEXT:    [[A_SROA_0_3_A1_SROA_CAST10:%.*]] = bitcast i8* [[A_SROA_0_3_A1_SROA_IDX9]] to i32*
 807 ; CHECK-NEXT:    [[A_SROA_0_3_A_SROA_0_4_V1:%.*]] = load i32, i32* [[A_SROA_0_3_A1_SROA_CAST10]], align 1
 808 ; CHECK-NEXT:    [[COND:%.*]] = icmp sle i32 [[A_SROA_0_0_A_SROA_0_1_V0]], [[A_SROA_0_3_A_SROA_0_4_V1]]
 809 ; CHECK-NEXT:    br i1 [[COND]], label [[THEN:%.*]], label [[EXIT:%.*]]
 810 ; CHECK:       then:
 811 ; CHECK-NEXT:    br label [[EXIT]]
 812 ; CHECK:       exit:
 813 ; CHECK-NEXT:    [[PHI:%.*]] = phi i32* [ [[A_SROA_0_3_A1_SROA_CAST]], [[THEN]] ], [ [[Z:%.*]], [[ENTRY:%.*]] ]
 814 ; CHECK-NEXT:    [[RESULT:%.*]] = load i32, i32* [[PHI]], align 1
 815 ; CHECK-NEXT:    ret i32 [[RESULT]]
 816 ;
 817 entry:
 818   %a = alloca [8 x i8], align 8
 819
 820   %a0x = getelementptr [8 x i8], [8 x i8]* %a, i64 0, i32 1
 821   %a0 = bitcast i8* %a0x to i32*
 822   %a1x = getelementptr [8 x i8], [8 x i8]* %a, i64 0, i32 4
 823   %a1 = bitcast i8* %a1x to i32*
 824   store i32 0, i32* %a0, align 1
 825   store i32 1, i32* %a1, align 4
 826   %v0 = load i32, i32* %a0, align 1
 827   %v1 = load i32, i32* %a1, align 4
 828   %cond = icmp sle i32 %v0, %v1
 829   br i1 %cond, label %then, label %exit
 830
 831 then:
 832   br label %exit
 833
 834 exit:
 835   %phi = phi i32* [ %a1, %then ], [ %z, %entry ]
 836   %result = load i32, i32* %phi, align 4
 837   ret i32 %result
 838 }
 839
 840 ; Don't speculate a load based on an earlier volatile operation.
 841 define i8 @volatile_select(i8* %p, i1 %b) {
 842 ; CHECK-LABEL: @volatile_select(
 843 ; CHECK-NEXT:    [[P2:%.*]] = alloca i8, align 1
 844 ; CHECK-NEXT:    store i8 0, i8* [[P2]], align 1
 845 ; CHECK-NEXT:    store volatile i8 0, i8* [[P:%.*]], align 1
 846 ; CHECK-NEXT:    [[PX:%.*]] = select i1 [[B:%.*]], i8* [[P]], i8* [[P2]]
 847 ; CHECK-NEXT:    [[V2:%.*]] = load i8, i8* [[PX]], align 1
 848 ; CHECK-NEXT:    ret i8 [[V2]]
 849 ;
 850   %p2 = alloca i8
 851   store i8 0, i8* %p2
 852   store volatile i8 0, i8* %p
 853   %px = select i1 %b, i8* %p, i8* %p2
 854   %v2 = load i8, i8* %px
 855   ret i8 %v2
 856 }