test/Transforms/SpeculateAroundPHIs/basic-x86.ll

   1 ; Test the basic functionality of speculating around PHI nodes based on reduced
   2 ; cost of the constant operands to the PHI nodes using the x86 cost model.
   3 ;
   4 ; REQUIRES: x86-registered-target
   5 ; RUN: opt -S -passes=spec-phis < %s | FileCheck %s
   6
   7 target triple = "x86_64-unknown-unknown"
   8
   9 define i32 @test_basic(i1 %flag, i32 %arg) {
  10 ; CHECK-LABEL: define i32 @test_basic(
  11 entry:
  12   br i1 %flag, label %a, label %b
  13 ; CHECK:         br i1 %flag, label %a, label %b
  14
  15 a:
  16   br label %exit
  17 ; CHECK:       a:
  18 ; CHECK-NEXT:    %[[SUM_A:.*]] = add i32 %arg, 7
  19 ; CHECK-NEXT:    br label %exit
  20
  21 b:
  22   br label %exit
  23 ; CHECK:       b:
  24 ; CHECK-NEXT:    %[[SUM_B:.*]] = add i32 %arg, 11
  25 ; CHECK-NEXT:    br label %exit
  26
  27 exit:
  28   %p = phi i32 [ 7, %a ], [ 11, %b ]
  29   %sum = add i32 %arg, %p
  30   ret i32 %sum
  31 ; CHECK:       exit:
  32 ; CHECK-NEXT:    %[[PHI:.*]] = phi i32 [ %[[SUM_A]], %a ], [ %[[SUM_B]], %b ]
  33 ; CHECK-NEXT:    ret i32 %[[PHI]]
  34 }
  35
  36 ; Check that we handle commuted operands and get the constant onto the RHS.
  37 define i32 @test_commuted(i1 %flag, i32 %arg) {
  38 ; CHECK-LABEL: define i32 @test_commuted(
  39 entry:
  40   br i1 %flag, label %a, label %b
  41 ; CHECK:         br i1 %flag, label %a, label %b
  42
  43 a:
  44   br label %exit
  45 ; CHECK:       a:
  46 ; CHECK-NEXT:    %[[SUM_A:.*]] = add i32 %arg, 7
  47 ; CHECK-NEXT:    br label %exit
  48
  49 b:
  50   br label %exit
  51 ; CHECK:       b:
  52 ; CHECK-NEXT:    %[[SUM_B:.*]] = add i32 %arg, 11
  53 ; CHECK-NEXT:    br label %exit
  54
  55 exit:
  56   %p = phi i32 [ 7, %a ], [ 11, %b ]
  57   %sum = add i32 %p, %arg
  58   ret i32 %sum
  59 ; CHECK:       exit:
  60 ; CHECK-NEXT:    %[[PHI:.*]] = phi i32 [ %[[SUM_A]], %a ], [ %[[SUM_B]], %b ]
  61 ; CHECK-NEXT:    ret i32 %[[PHI]]
  62 }
  63
  64 define i32 @test_split_crit_edge(i1 %flag, i32 %arg) {
  65 ; CHECK-LABEL: define i32 @test_split_crit_edge(
  66 entry:
  67   br i1 %flag, label %exit, label %a
  68 ; CHECK:       entry:
  69 ; CHECK-NEXT:    br i1 %flag, label %[[ENTRY_SPLIT:.*]], label %a
  70 ;
  71 ; CHECK:       [[ENTRY_SPLIT]]:
  72 ; CHECK-NEXT:    %[[SUM_ENTRY_SPLIT:.*]] = add i32 %arg, 7
  73 ; CHECK-NEXT:    br label %exit
  74
  75 a:
  76   br label %exit
  77 ; CHECK:       a:
  78 ; CHECK-NEXT:    %[[SUM_A:.*]] = add i32 %arg, 11
  79 ; CHECK-NEXT:    br label %exit
  80
  81 exit:
  82   %p = phi i32 [ 7, %entry ], [ 11, %a ]
  83   %sum = add i32 %arg, %p
  84   ret i32 %sum
  85 ; CHECK:       exit:
  86 ; CHECK-NEXT:    %[[PHI:.*]] = phi i32 [ %[[SUM_ENTRY_SPLIT]], %[[ENTRY_SPLIT]] ], [ %[[SUM_A]], %a ]
  87 ; CHECK-NEXT:    ret i32 %[[PHI]]
  88 }
  89
  90 define i32 @test_no_spec_dominating_inst(i1 %flag, i32* %ptr) {
  91 ; CHECK-LABEL: define i32 @test_no_spec_dominating_inst(
  92 entry:
  93   %load = load i32, i32* %ptr
  94   br i1 %flag, label %a, label %b
  95 ; CHECK:         %[[LOAD:.*]] = load i32, i32* %ptr
  96 ; CHECK-NEXT:    br i1 %flag, label %a, label %b
  97
  98 a:
  99   br label %exit
 100 ; CHECK:       a:
 101 ; CHECK-NEXT:    %[[SUM_A:.*]] = add i32 %[[LOAD]], 7
 102 ; CHECK-NEXT:    br label %exit
 103
 104 b:
 105   br label %exit
 106 ; CHECK:       b:
 107 ; CHECK-NEXT:    %[[SUM_B:.*]] = add i32 %[[LOAD]], 11
 108 ; CHECK-NEXT:    br label %exit
 109
 110 exit:
 111   %p = phi i32 [ 7, %a ], [ 11, %b ]
 112   %sum = add i32 %load, %p
 113   ret i32 %sum
 114 ; CHECK:       exit:
 115 ; CHECK-NEXT:    %[[PHI:.*]] = phi i32 [ %[[SUM_A]], %a ], [ %[[SUM_B]], %b ]
 116 ; CHECK-NEXT:    ret i32 %[[PHI]]
 117 }
 118
 119 ; We have special logic handling PHI nodes, make sure it doesn't get confused
 120 ; by a dominating PHI.
 121 define i32 @test_no_spec_dominating_phi(i1 %flag1, i1 %flag2, i32 %x, i32 %y) {
 122 ; CHECK-LABEL: define i32 @test_no_spec_dominating_phi(
 123 entry:
 124   br i1 %flag1, label %x.block, label %y.block
 125 ; CHECK:       entry:
 126 ; CHECK-NEXT:    br i1 %flag1, label %x.block, label %y.block
 127
 128 x.block:
 129   br label %merge
 130 ; CHECK:       x.block:
 131 ; CHECK-NEXT:    br label %merge
 132
 133 y.block:
 134   br label %merge
 135 ; CHECK:       y.block:
 136 ; CHECK-NEXT:    br label %merge
 137
 138 merge:
 139   %xy.phi = phi i32 [ %x, %x.block ], [ %y, %y.block ]
 140   br i1 %flag2, label %a, label %b
 141 ; CHECK:       merge:
 142 ; CHECK-NEXT:    %[[XY_PHI:.*]] = phi i32 [ %x, %x.block ], [ %y, %y.block ]
 143 ; CHECK-NEXT:    br i1 %flag2, label %a, label %b
 144
 145 a:
 146   br label %exit
 147 ; CHECK:       a:
 148 ; CHECK-NEXT:    %[[SUM_A:.*]] = add i32 %[[XY_PHI]], 7
 149 ; CHECK-NEXT:    br label %exit
 150
 151 b:
 152   br label %exit
 153 ; CHECK:       b:
 154 ; CHECK-NEXT:    %[[SUM_B:.*]] = add i32 %[[XY_PHI]], 11
 155 ; CHECK-NEXT:    br label %exit
 156
 157 exit:
 158   %p = phi i32 [ 7, %a ], [ 11, %b ]
 159   %sum = add i32 %xy.phi, %p
 160   ret i32 %sum
 161 ; CHECK:       exit:
 162 ; CHECK-NEXT:    %[[SUM_PHI:.*]] = phi i32 [ %[[SUM_A]], %a ], [ %[[SUM_B]], %b ]
 163 ; CHECK-NEXT:    ret i32 %[[SUM_PHI]]
 164 }
 165
 166 ; Ensure that we will speculate some number of "free" instructions on the given
 167 ; architecture even though they are unrelated to the PHI itself.
 168 define i32 @test_speculate_free_insts(i1 %flag, i64 %arg) {
 169 ; CHECK-LABEL: define i32 @test_speculate_free_insts(
 170 entry:
 171   br i1 %flag, label %a, label %b
 172 ; CHECK:         br i1 %flag, label %a, label %b
 173
 174 a:
 175   br label %exit
 176 ; CHECK:       a:
 177 ; CHECK-NEXT:    %[[T1_A:.*]] = trunc i64 %arg to i48
 178 ; CHECK-NEXT:    %[[T2_A:.*]] = trunc i48 %[[T1_A]] to i32
 179 ; CHECK-NEXT:    %[[SUM_A:.*]] = add i32 %[[T2_A]], 7
 180 ; CHECK-NEXT:    br label %exit
 181
 182 b:
 183   br label %exit
 184 ; CHECK:       b:
 185 ; CHECK-NEXT:    %[[T1_B:.*]] = trunc i64 %arg to i48
 186 ; CHECK-NEXT:    %[[T2_B:.*]] = trunc i48 %[[T1_B]] to i32
 187 ; CHECK-NEXT:    %[[SUM_B:.*]] = add i32 %[[T2_B]], 11
 188 ; CHECK-NEXT:    br label %exit
 189
 190 exit:
 191   %p = phi i32 [ 7, %a ], [ 11, %b ]
 192   %t1 = trunc i64 %arg to i48
 193   %t2 = trunc i48 %t1 to i32
 194   %sum = add i32 %t2, %p
 195   ret i32 %sum
 196 ; CHECK:       exit:
 197 ; CHECK-NEXT:    %[[PHI:.*]] = phi i32 [ %[[SUM_A]], %a ], [ %[[SUM_B]], %b ]
 198 ; CHECK-NEXT:    ret i32 %[[PHI]]
 199 }
 200
 201 define i32 @test_speculate_free_phis(i1 %flag, i32 %arg1, i32 %arg2) {
 202 ; CHECK-LABEL: define i32 @test_speculate_free_phis(
 203 entry:
 204   br i1 %flag, label %a, label %b
 205 ; CHECK:         br i1 %flag, label %a, label %b
 206
 207 a:
 208   br label %exit
 209 ; CHECK:       a:
 210 ; CHECK-NEXT:    %[[SUM_A:.*]] = add i32 %arg1, 7
 211 ; CHECK-NEXT:    br label %exit
 212
 213 b:
 214   br label %exit
 215 ; CHECK:       b:
 216 ; CHECK-NEXT:    %[[SUM_B:.*]] = add i32 %arg2, 11
 217 ; CHECK-NEXT:    br label %exit
 218
 219 exit:
 220   %p1 = phi i32 [ 7, %a ], [ 11, %b ]
 221   %p2 = phi i32 [ %arg1, %a ], [ %arg2, %b ]
 222   %sum = add i32 %p2, %p1
 223   ret i32 %sum
 224 ; CHECK:       exit:
 225 ; CHECK-NEXT:    %[[PHI:.*]] = phi i32 [ %[[SUM_A]], %a ], [ %[[SUM_B]], %b ]
 226 ; We don't DCE the now unused PHI node...
 227 ; CHECK-NEXT:    %{{.*}} = phi i32 [ %arg1, %a ], [ %arg2, %b ]
 228 ; CHECK-NEXT:    ret i32 %[[PHI]]
 229 }
 230
 231 ; We shouldn't speculate multiple uses even if each individually looks
 232 ; profitable because of the total cost.
 233 define i32 @test_no_spec_multi_uses(i1 %flag, i32 %arg1, i32 %arg2, i32 %arg3) {
 234 ; CHECK-LABEL: define i32 @test_no_spec_multi_uses(
 235 entry:
 236   br i1 %flag, label %a, label %b
 237 ; CHECK:         br i1 %flag, label %a, label %b
 238
 239 a:
 240   br label %exit
 241 ; CHECK:       a:
 242 ; CHECK-NEXT:    br label %exit
 243
 244 b:
 245   br label %exit
 246 ; CHECK:       b:
 247 ; CHECK-NEXT:    br label %exit
 248
 249 exit:
 250   %p = phi i32 [ 7, %a ], [ 11, %b ]
 251   %add1 = add i32 %arg1, %p
 252   %add2 = add i32 %arg2, %p
 253   %add3 = add i32 %arg3, %p
 254   %sum1 = add i32 %add1, %add2
 255   %sum2 = add i32 %sum1, %add3
 256   ret i32 %sum2
 257 ; CHECK:       exit:
 258 ; CHECK-NEXT:    %[[PHI:.*]] = phi i32 [ 7, %a ], [ 11, %b ]
 259 ; CHECK-NEXT:    %[[ADD1:.*]] = add i32 %arg1, %[[PHI]]
 260 ; CHECK-NEXT:    %[[ADD2:.*]] = add i32 %arg2, %[[PHI]]
 261 ; CHECK-NEXT:    %[[ADD3:.*]] = add i32 %arg3, %[[PHI]]
 262 ; CHECK-NEXT:    %[[SUM1:.*]] = add i32 %[[ADD1]], %[[ADD2]]
 263 ; CHECK-NEXT:    %[[SUM2:.*]] = add i32 %[[SUM1]], %[[ADD3]]
 264 ; CHECK-NEXT:    ret i32 %[[SUM2]]
 265 }
 266
 267 define i32 @test_multi_phis1(i1 %flag, i32 %arg) {
 268 ; CHECK-LABEL: define i32 @test_multi_phis1(
 269 entry:
 270   br i1 %flag, label %a, label %b
 271 ; CHECK:         br i1 %flag, label %a, label %b
 272
 273 a:
 274   br label %exit
 275 ; CHECK:       a:
 276 ; CHECK-NEXT:    %[[SUM_A1:.*]] = add i32 %arg, 1
 277 ; CHECK-NEXT:    %[[SUM_A2:.*]] = add i32 %[[SUM_A1]], 3
 278 ; CHECK-NEXT:    %[[SUM_A3:.*]] = add i32 %[[SUM_A2]], 5
 279 ; CHECK-NEXT:    br label %exit
 280
 281 b:
 282   br label %exit
 283 ; CHECK:       b:
 284 ; CHECK-NEXT:    %[[SUM_B1:.*]] = add i32 %arg, 2
 285 ; CHECK-NEXT:    %[[SUM_B2:.*]] = add i32 %[[SUM_B1]], 4
 286 ; CHECK-NEXT:    %[[SUM_B3:.*]] = add i32 %[[SUM_B2]], 6
 287 ; CHECK-NEXT:    br label %exit
 288
 289 exit:
 290   %p1 = phi i32 [ 1, %a ], [ 2, %b ]
 291   %p2 = phi i32 [ 3, %a ], [ 4, %b ]
 292   %p3 = phi i32 [ 5, %a ], [ 6, %b ]
 293   %sum1 = add i32 %arg, %p1
 294   %sum2 = add i32 %sum1, %p2
 295   %sum3 = add i32 %sum2, %p3
 296   ret i32 %sum3
 297 ; CHECK:       exit:
 298 ; CHECK-NEXT:    %[[PHI:.*]] = phi i32 [ %[[SUM_A3]], %a ], [ %[[SUM_B3]], %b ]
 299 ; CHECK-NEXT:    ret i32 %[[PHI]]
 300 }
 301
 302 ; Check that the order of the PHIs doesn't impact the behavior.
 303 define i32 @test_multi_phis2(i1 %flag, i32 %arg) {
 304 ; CHECK-LABEL: define i32 @test_multi_phis2(
 305 entry:
 306   br i1 %flag, label %a, label %b
 307 ; CHECK:         br i1 %flag, label %a, label %b
 308
 309 a:
 310   br label %exit
 311 ; CHECK:       a:
 312 ; CHECK-NEXT:    %[[SUM_A1:.*]] = add i32 %arg, 1
 313 ; CHECK-NEXT:    %[[SUM_A2:.*]] = add i32 %[[SUM_A1]], 3
 314 ; CHECK-NEXT:    %[[SUM_A3:.*]] = add i32 %[[SUM_A2]], 5
 315 ; CHECK-NEXT:    br label %exit
 316
 317 b:
 318   br label %exit
 319 ; CHECK:       b:
 320 ; CHECK-NEXT:    %[[SUM_B1:.*]] = add i32 %arg, 2
 321 ; CHECK-NEXT:    %[[SUM_B2:.*]] = add i32 %[[SUM_B1]], 4
 322 ; CHECK-NEXT:    %[[SUM_B3:.*]] = add i32 %[[SUM_B2]], 6
 323 ; CHECK-NEXT:    br label %exit
 324
 325 exit:
 326   %p3 = phi i32 [ 5, %a ], [ 6, %b ]
 327   %p2 = phi i32 [ 3, %a ], [ 4, %b ]
 328   %p1 = phi i32 [ 1, %a ], [ 2, %b ]
 329   %sum1 = add i32 %arg, %p1
 330   %sum2 = add i32 %sum1, %p2
 331   %sum3 = add i32 %sum2, %p3
 332   ret i32 %sum3
 333 ; CHECK:       exit:
 334 ; CHECK-NEXT:    %[[PHI:.*]] = phi i32 [ %[[SUM_A3]], %a ], [ %[[SUM_B3]], %b ]
 335 ; CHECK-NEXT:    ret i32 %[[PHI]]
 336 }
 337
 338 define i32 @test_no_spec_indirectbr(i1 %flag, i32 %arg) {
 339 ; CHECK-LABEL: define i32 @test_no_spec_indirectbr(
 340 entry:
 341   br i1 %flag, label %a, label %b
 342 ; CHECK:       entry:
 343 ; CHECK-NEXT:    br i1 %flag, label %a, label %b
 344
 345 a:
 346   indirectbr i8* undef, [label %exit]
 347 ; CHECK:       a:
 348 ; CHECK-NEXT:    indirectbr i8* undef, [label %exit]
 349
 350 b:
 351   indirectbr i8* undef, [label %exit]
 352 ; CHECK:       b:
 353 ; CHECK-NEXT:    indirectbr i8* undef, [label %exit]
 354
 355 exit:
 356   %p = phi i32 [ 7, %a ], [ 11, %b ]
 357   %sum = add i32 %arg, %p
 358   ret i32 %sum
 359 ; CHECK:       exit:
 360 ; CHECK-NEXT:    %[[PHI:.*]] = phi i32 [ 7, %a ], [ 11, %b ]
 361 ; CHECK-NEXT:    %[[SUM:.*]] = add i32 %arg, %[[PHI]]
 362 ; CHECK-NEXT:    ret i32 %[[SUM]]
 363 }
 364
 365 declare void @g()
 366
 367 declare i32 @__gxx_personality_v0(...)
 368
 369 ; FIXME: We should be able to handle this case -- only the exceptional edge is
 370 ; impossible to split.
 371 define i32 @test_no_spec_invoke_continue(i1 %flag, i32 %arg) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 372 ; CHECK-LABEL: define i32 @test_no_spec_invoke_continue(
 373 entry:
 374   br i1 %flag, label %a, label %b
 375 ; CHECK:       entry:
 376 ; CHECK-NEXT:    br i1 %flag, label %a, label %b
 377
 378 a:
 379   invoke void @g()
 380           to label %exit unwind label %lpad
 381 ; CHECK:       a:
 382 ; CHECK-NEXT:    invoke void @g()
 383 ; CHECK-NEXT:            to label %exit unwind label %lpad
 384
 385 b:
 386   invoke void @g()
 387           to label %exit unwind label %lpad
 388 ; CHECK:       b:
 389 ; CHECK-NEXT:    invoke void @g()
 390 ; CHECK-NEXT:            to label %exit unwind label %lpad
 391
 392 exit:
 393   %p = phi i32 [ 7, %a ], [ 11, %b ]
 394   %sum = add i32 %arg, %p
 395   ret i32 %sum
 396 ; CHECK:       exit:
 397 ; CHECK-NEXT:    %[[PHI:.*]] = phi i32 [ 7, %a ], [ 11, %b ]
 398 ; CHECK-NEXT:    %[[SUM:.*]] = add i32 %arg, %[[PHI]]
 399 ; CHECK-NEXT:    ret i32 %[[SUM]]
 400
 401 lpad:
 402   %lp = landingpad { i8*, i32 }
 403           cleanup
 404   resume { i8*, i32 } undef
 405 }
 406
 407 define i32 @test_no_spec_landingpad(i32 %arg, i32* %ptr) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 408 ; CHECK-LABEL: define i32 @test_no_spec_landingpad(
 409 entry:
 410   invoke void @g()
 411           to label %invoke.cont unwind label %lpad
 412 ; CHECK:       entry:
 413 ; CHECK-NEXT:    invoke void @g()
 414 ; CHECK-NEXT:            to label %invoke.cont unwind label %lpad
 415
 416 invoke.cont:
 417   invoke void @g()
 418           to label %exit unwind label %lpad
 419 ; CHECK:       invoke.cont:
 420 ; CHECK-NEXT:    invoke void @g()
 421 ; CHECK-NEXT:            to label %exit unwind label %lpad
 422
 423 lpad:
 424   %p = phi i32 [ 7, %entry ], [ 11, %invoke.cont ]
 425   %lp = landingpad { i8*, i32 }
 426           cleanup
 427   %sum = add i32 %arg, %p
 428   store i32 %sum, i32* %ptr
 429   resume { i8*, i32 } undef
 430 ; CHECK:       lpad:
 431 ; CHECK-NEXT:    %[[PHI:.*]] = phi i32 [ 7, %entry ], [ 11, %invoke.cont ]
 432
 433 exit:
 434   ret i32 0
 435 }
 436
 437 declare i32 @__CxxFrameHandler3(...)
 438
 439 define i32 @test_no_spec_cleanuppad(i32 %arg, i32* %ptr) personality i32 (...)* @__CxxFrameHandler3 {
 440 ; CHECK-LABEL: define i32 @test_no_spec_cleanuppad(
 441 entry:
 442   invoke void @g()
 443           to label %invoke.cont unwind label %lpad
 444 ; CHECK:       entry:
 445 ; CHECK-NEXT:    invoke void @g()
 446 ; CHECK-NEXT:            to label %invoke.cont unwind label %lpad
 447
 448 invoke.cont:
 449   invoke void @g()
 450           to label %exit unwind label %lpad
 451 ; CHECK:       invoke.cont:
 452 ; CHECK-NEXT:    invoke void @g()
 453 ; CHECK-NEXT:            to label %exit unwind label %lpad
 454
 455 lpad:
 456   %p = phi i32 [ 7, %entry ], [ 11, %invoke.cont ]
 457   %cp = cleanuppad within none []
 458   %sum = add i32 %arg, %p
 459   store i32 %sum, i32* %ptr
 460   cleanupret from %cp unwind to caller
 461 ; CHECK:       lpad:
 462 ; CHECK-NEXT:    %[[PHI:.*]] = phi i32 [ 7, %entry ], [ 11, %invoke.cont ]
 463
 464 exit:
 465   ret i32 0
 466 }
 467
 468 ; Check that we don't fall over when confronted with seemingly reasonable code
 469 ; for us to handle but in an unreachable region and with non-PHI use-def
 470 ; cycles.
 471 define i32 @test_unreachable_non_phi_cycles(i1 %flag, i32 %arg) {
 472 ; CHECK-LABEL: define i32 @test_unreachable_non_phi_cycles(
 473 entry:
 474   ret i32 42
 475 ; CHECK:       entry:
 476 ; CHECK-NEXT:    ret i32 42
 477
 478 a:
 479   br label %exit
 480 ; CHECK:       a:
 481 ; CHECK-NEXT:    br label %exit
 482
 483 b:
 484   br label %exit
 485 ; CHECK:       b:
 486 ; CHECK-NEXT:    br label %exit
 487
 488 exit:
 489   %p = phi i32 [ 7, %a ], [ 11, %b ]
 490   %zext = zext i32 %sum to i64
 491   %trunc = trunc i64 %zext to i32
 492   %sum = add i32 %trunc, %p
 493   br i1 %flag, label %a, label %b
 494 ; CHECK:       exit:
 495 ; CHECK-NEXT:    %[[PHI:.*]] = phi i32 [ 7, %a ], [ 11, %b ]
 496 ; CHECK-NEXT:    %[[ZEXT:.*]] = zext i32 %[[SUM:.*]] to i64
 497 ; CHECK-NEXT:    %[[TRUNC:.*]] = trunc i64 %[[ZEXT]] to i32
 498 ; CHECK-NEXT:    %[[SUM]] = add i32 %[[TRUNC]], %[[PHI]]
 499 ; CHECK-NEXT:    br i1 %flag, label %a, label %b
 500 }
 501
 502 ; Check that we don't speculate in the face of an expensive immediate. There
 503 ; are two reasons this should never speculate. First, even a local analysis
 504 ; should fail because it makes some paths (%a) potentially more expensive due
 505 ; to multiple uses of the immediate. Additionally, when we go to speculate the
 506 ; instructions, their cost will also be too high.
 507 ; FIXME: The goal is really to test the first property, but there doesn't
 508 ; happen to be any way to use free-to-speculate instructions here so that it
 509 ; would be the only interesting property.
 510 define i64 @test_expensive_imm(i32 %flag, i64 %arg) {
 511 ; CHECK-LABEL: define i64 @test_expensive_imm(
 512 entry:
 513   switch i32 %flag, label %a [
 514     i32 1, label %b
 515     i32 2, label %c
 516     i32 3, label %d
 517   ]
 518 ; CHECK:         switch i32 %flag, label %a [
 519 ; CHECK-NEXT:      i32 1, label %b
 520 ; CHECK-NEXT:      i32 2, label %c
 521 ; CHECK-NEXT:      i32 3, label %d
 522 ; CHECK-NEXT:    ]
 523
 524 a:
 525   br label %exit
 526 ; CHECK:       a:
 527 ; CHECK-NEXT:    br label %exit
 528
 529 b:
 530   br label %exit
 531 ; CHECK:       b:
 532 ; CHECK-NEXT:    br label %exit
 533
 534 c:
 535   br label %exit
 536 ; CHECK:       c:
 537 ; CHECK-NEXT:    br label %exit
 538
 539 d:
 540   br label %exit
 541 ; CHECK:       d:
 542 ; CHECK-NEXT:    br label %exit
 543
 544 exit:
 545   %p = phi i64 [ 4294967296, %a ], [ 1, %b ], [ 1, %c ], [ 1, %d ]
 546   %sum1 = add i64 %arg, %p
 547   %sum2 = add i64 %sum1, %p
 548   ret i64 %sum2
 549 ; CHECK:       exit:
 550 ; CHECK-NEXT:    %[[PHI:.*]] = phi i64 [ {{[0-9]+}}, %a ], [ 1, %b ], [ 1, %c ], [ 1, %d ]
 551 ; CHECK-NEXT:    %[[SUM1:.*]] = add i64 %arg, %[[PHI]]
 552 ; CHECK-NEXT:    %[[SUM2:.*]] = add i64 %[[SUM1]], %[[PHI]]
 553 ; CHECK-NEXT:    ret i64 %[[SUM2]]
 554 }
 555
 556 define i32 @test_no_spec_non_postdominating_uses(i1 %flag1, i1 %flag2, i32 %arg) {
 557 ; CHECK-LABEL: define i32 @test_no_spec_non_postdominating_uses(
 558 entry:
 559   br i1 %flag1, label %a, label %b
 560 ; CHECK:         br i1 %flag1, label %a, label %b
 561
 562 a:
 563   br label %merge
 564 ; CHECK:       a:
 565 ; CHECK-NEXT:    %[[SUM_A:.*]] = add i32 %arg, 7
 566 ; CHECK-NEXT:    br label %merge
 567
 568 b:
 569   br label %merge
 570 ; CHECK:       b:
 571 ; CHECK-NEXT:    %[[SUM_B:.*]] = add i32 %arg, 11
 572 ; CHECK-NEXT:    br label %merge
 573
 574 merge:
 575   %p1 = phi i32 [ 7, %a ], [ 11, %b ]
 576   %p2 = phi i32 [ 13, %a ], [ 42, %b ]
 577   %sum1 = add i32 %arg, %p1
 578   br i1 %flag2, label %exit1, label %exit2
 579 ; CHECK:       merge:
 580 ; CHECK-NEXT:    %[[PHI1:.*]] = phi i32 [ %[[SUM_A]], %a ], [ %[[SUM_B]], %b ]
 581 ; CHECK-NEXT:    %[[PHI2:.*]] = phi i32 [ 13, %a ], [ 42, %b ]
 582 ; CHECK-NEXT:    br i1 %flag2, label %exit1, label %exit2
 583
 584 exit1:
 585   ret i32 %sum1
 586 ; CHECK:       exit1:
 587 ; CHECK-NEXT:    ret i32 %[[PHI1]]
 588
 589 exit2:
 590   %sum2 = add i32 %arg, %p2
 591   ret i32 %sum2
 592 ; CHECK:       exit2:
 593 ; CHECK-NEXT:    %[[SUM2:.*]] = add i32 %arg, %[[PHI2]]
 594 ; CHECK-NEXT:    ret i32 %[[SUM2]]
 595 }