test/CodeGen/WebAssembly/cfg-stackify.ll

   1 ; RUN: llc < %s -asm-verbose=false -disable-block-placement -verify-machineinstrs | FileCheck %s
   2 ; RUN: llc < %s -asm-verbose=false -verify-machineinstrs | FileCheck -check-prefix=OPT %s
   3
   4 ; Test the CFG stackifier pass.
   5
   6 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
   7 target triple = "wasm32-unknown-unknown"
   8
   9 declare void @something()
  10
  11 ; Test that loops are made contiguous, even in the presence of split backedges.
  12
  13 ; CHECK-LABEL: test0:
  14 ; CHECK: loop
  15 ; CHECK-NOT: br
  16 ; CHECK: i32.add
  17 ; CHECK-NEXT: i32.ge_s
  18 ; CHECK-NEXT: br_if
  19 ; CHECK-NOT: br
  20 ; CHECK: call
  21 ; CHECK: br 0{{$}}
  22 ; CHECK: return{{$}}
  23 ; OPT-LABEL: test0:
  24 ; OPT: loop
  25 ; OPT-NOT: br
  26 ; OPT: i32.add
  27 ; OPT-NEXT: i32.ge_s
  28 ; OPT-NEXT: br_if
  29 ; OPT-NOT: br
  30 ; OPT: call
  31 ; OPT: br 0{{$}}
  32 ; OPT: return{{$}}
  33 define void @test0(i32 %n) {
  34 entry:
  35   br label %header
  36
  37 header:
  38   %i = phi i32 [ 0, %entry ], [ %i.next, %back ]
  39   %i.next = add i32 %i, 1
  40
  41   %c = icmp slt i32 %i.next, %n
  42   br i1 %c, label %back, label %exit
  43
  44 exit:
  45   ret void
  46
  47 back:
  48   call void @something()
  49   br label %header
  50 }
  51
  52 ; Same as test0, but the branch condition is reversed.
  53
  54 ; CHECK-LABEL: test1:
  55 ; CHECK: loop
  56 ; CHECK-NOT: br
  57 ; CHECK: i32.add
  58 ; CHECK-NEXT: i32.ge_s
  59 ; CHECK-NEXT: br_if
  60 ; CHECK-NOT: br
  61 ; CHECK: call
  62 ; CHECK: br 0{{$}}
  63 ; CHECK: return{{$}}
  64 ; OPT-LABEL: test1:
  65 ; OPT: loop
  66 ; OPT-NOT: br
  67 ; OPT: i32.add
  68 ; OPT-NEXT: i32.ge_s
  69 ; OPT-NEXT: br_if
  70 ; OPT-NOT: br
  71 ; OPT: call
  72 ; OPT: br 0{{$}}
  73 ; OPT: return{{$}}
  74 define void @test1(i32 %n) {
  75 entry:
  76   br label %header
  77
  78 header:
  79   %i = phi i32 [ 0, %entry ], [ %i.next, %back ]
  80   %i.next = add i32 %i, 1
  81
  82   %c = icmp sge i32 %i.next, %n
  83   br i1 %c, label %exit, label %back
  84
  85 exit:
  86   ret void
  87
  88 back:
  89   call void @something()
  90   br label %header
  91 }
  92
  93 ; Test that a simple loop is handled as expected.
  94
  95 ; CHECK-LABEL: test2:
  96 ; CHECK-NOT: local
  97 ; CHECK: block{{$}}
  98 ; CHECK: br_if {{[^,]*}}, 0{{$}}
  99 ; CHECK: .LBB2_1:
 100 ; CHECK: br_if ${{[0-9]+}}, 0{{$}}
 101 ; CHECK: .LBB2_2:
 102 ; CHECK: return{{$}}
 103 ; OPT-LABEL: test2:
 104 ; OPT-NOT: local
 105 ; OPT: block{{$}}
 106 ; OPT: br_if {{[^,]*}}, 0{{$}}
 107 ; OPT: .LBB2_1:
 108 ; OPT: br_if ${{[0-9]+}}, 0{{$}}
 109 ; OPT: .LBB2_2:
 110 ; OPT: return{{$}}
 111 define void @test2(double* nocapture %p, i32 %n) {
 112 entry:
 113   %cmp.4 = icmp sgt i32 %n, 0
 114   br i1 %cmp.4, label %for.body.preheader, label %for.end
 115
 116 for.body.preheader:
 117   br label %for.body
 118
 119 for.body:
 120   %i.05 = phi i32 [ %inc, %for.body ], [ 0, %for.body.preheader ]
 121   %arrayidx = getelementptr inbounds double, double* %p, i32 %i.05
 122   %0 = load double, double* %arrayidx, align 8
 123   %mul = fmul double %0, 3.200000e+00
 124   store double %mul, double* %arrayidx, align 8
 125   %inc = add nuw nsw i32 %i.05, 1
 126   %exitcond = icmp eq i32 %inc, %n
 127   br i1 %exitcond, label %for.end.loopexit, label %for.body
 128
 129 for.end.loopexit:
 130   br label %for.end
 131
 132 for.end:
 133   ret void
 134 }
 135
 136 ; CHECK-LABEL: doublediamond:
 137 ; CHECK: block{{$}}
 138 ; CHECK-NEXT: block{{$}}
 139 ; CHECK: br_if ${{[^,]*}}, 0{{$}}
 140 ; CHECK: br 1{{$}}
 141 ; CHECK: .LBB3_2:
 142 ; CHECK-NEXT: end_block{{$}}
 143 ; CHECK: block{{$}}
 144 ; CHECK: br_if ${{[^,]*}}, 0{{$}}
 145 ; CHECK: br 1{{$}}
 146 ; CHECK: .LBB3_4:
 147 ; CHECK-NEXT: end_block{{$}}
 148 ; CHECK: .LBB3_5:
 149 ; CHECK-NEXT: end_block{{$}}
 150 ; CHECK: return ${{[0-9]+}}{{$}}
 151 ; OPT-LABEL: doublediamond:
 152 ; OPT: block{{$}}
 153 ; OPT-NEXT: block{{$}}
 154 ; OPT: br_if ${{[^,]*}}, 0{{$}}
 155 ; OPT: block{{$}}
 156 ; OPT: br_if ${{[^,]*}}, 0{{$}}
 157 ; OPT: br 1{{$}}
 158 ; OPT: .LBB3_4:
 159 ; OPT: .LBB3_5:
 160 ; OPT: return ${{[0-9]+}}{{$}}
 161 define i32 @doublediamond(i32 %a, i32 %b, i32* %p) {
 162 entry:
 163   %c = icmp eq i32 %a, 0
 164   %d = icmp eq i32 %b, 0
 165   store volatile i32 0, i32* %p
 166   br i1 %c, label %true, label %false
 167 true:
 168   store volatile i32 1, i32* %p
 169   br label %exit
 170 false:
 171   store volatile i32 2, i32* %p
 172   br i1 %d, label %ft, label %ff
 173 ft:
 174   store volatile i32 3, i32* %p
 175   br label %exit
 176 ff:
 177   store volatile i32 4, i32* %p
 178   br label %exit
 179 exit:
 180   store volatile i32 5, i32* %p
 181   ret i32 0
 182 }
 183
 184 ; CHECK-LABEL: triangle:
 185 ; CHECK: block{{$}}
 186 ; CHECK: br_if $1, 0{{$}}
 187 ; CHECK: .LBB4_2:
 188 ; CHECK: return ${{[0-9]+}}{{$}}
 189 ; OPT-LABEL: triangle:
 190 ; OPT: block{{$}}
 191 ; OPT: br_if $1, 0{{$}}
 192 ; OPT: .LBB4_2:
 193 ; OPT: return ${{[0-9]+}}{{$}}
 194 define i32 @triangle(i32* %p, i32 %a) {
 195 entry:
 196   %c = icmp eq i32 %a, 0
 197   store volatile i32 0, i32* %p
 198   br i1 %c, label %true, label %exit
 199 true:
 200   store volatile i32 1, i32* %p
 201   br label %exit
 202 exit:
 203   store volatile i32 2, i32* %p
 204   ret i32 0
 205 }
 206
 207 ; CHECK-LABEL: diamond:
 208 ; CHECK: block{{$}}
 209 ; CHECK: block{{$}}
 210 ; CHECK: br_if $1, 0{{$}}
 211 ; CHECK: br 1{{$}}
 212 ; CHECK: .LBB5_2:
 213 ; CHECK: .LBB5_3:
 214 ; CHECK: return ${{[0-9]+}}{{$}}
 215 ; OPT-LABEL: diamond:
 216 ; OPT: block{{$}}
 217 ; OPT: block{{$}}
 218 ; OPT: br_if {{[^,]*}}, 0{{$}}
 219 ; OPT: br 1{{$}}
 220 ; OPT: .LBB5_2:
 221 ; OPT: .LBB5_3:
 222 ; OPT: return ${{[0-9]+}}{{$}}
 223 define i32 @diamond(i32* %p, i32 %a) {
 224 entry:
 225   %c = icmp eq i32 %a, 0
 226   store volatile i32 0, i32* %p
 227   br i1 %c, label %true, label %false
 228 true:
 229   store volatile i32 1, i32* %p
 230   br label %exit
 231 false:
 232   store volatile i32 2, i32* %p
 233   br label %exit
 234 exit:
 235   store volatile i32 3, i32* %p
 236   ret i32 0
 237 }
 238
 239 ; CHECK-LABEL: single_block:
 240 ; CHECK-NOT: br
 241 ; CHECK: return $pop{{[0-9]+}}{{$}}
 242 ; OPT-LABEL: single_block:
 243 ; OPT-NOT: br
 244 ; OPT: return $pop{{[0-9]+}}{{$}}
 245 define i32 @single_block(i32* %p) {
 246 entry:
 247   store volatile i32 0, i32* %p
 248   ret i32 0
 249 }
 250
 251 ; CHECK-LABEL: minimal_loop:
 252 ; CHECK-NOT: br
 253 ; CHECK: .LBB7_1:
 254 ; CHECK: i32.store $discard=, 0($0), $pop{{[0-9]+}}{{$}}
 255 ; CHECK: br 0{{$}}
 256 ; CHECK: .LBB7_2:
 257 ; OPT-LABEL: minimal_loop:
 258 ; OPT-NOT: br
 259 ; OPT: .LBB7_1:
 260 ; OPT: i32.store $discard=, 0($0), $pop{{[0-9]+}}{{$}}
 261 ; OPT: br 0{{$}}
 262 ; OPT: .LBB7_2:
 263 define i32 @minimal_loop(i32* %p) {
 264 entry:
 265   store volatile i32 0, i32* %p
 266   br label %loop
 267 loop:
 268   store volatile i32 1, i32* %p
 269   br label %loop
 270 }
 271
 272 ; CHECK-LABEL: simple_loop:
 273 ; CHECK-NOT: br
 274 ; CHECK: .LBB8_1:
 275 ; CHECK: loop{{$}}
 276 ; CHECK: br_if $pop{{[0-9]+}}, 0{{$}}
 277 ; CHECK-NEXT: end_loop{{$}}
 278 ; CHECK: return ${{[0-9]+}}{{$}}
 279 ; OPT-LABEL: simple_loop:
 280 ; OPT-NOT: br
 281 ; OPT: .LBB8_1:
 282 ; OPT: loop{{$}}
 283 ; OPT: br_if {{[^,]*}}, 0{{$}}
 284 ; OPT-NEXT: end_loop{{$}}
 285 ; OPT: return ${{[0-9]+}}{{$}}
 286 define i32 @simple_loop(i32* %p, i32 %a) {
 287 entry:
 288   %c = icmp eq i32 %a, 0
 289   store volatile i32 0, i32* %p
 290   br label %loop
 291 loop:
 292   store volatile i32 1, i32* %p
 293   br i1 %c, label %loop, label %exit
 294 exit:
 295   store volatile i32 2, i32* %p
 296   ret i32 0
 297 }
 298
 299 ; CHECK-LABEL: doubletriangle:
 300 ; CHECK: block{{$}}
 301 ; CHECK: br_if $0, 0{{$}}
 302 ; CHECK: block{{$}}
 303 ; CHECK: br_if $1, 0{{$}}
 304 ; CHECK: .LBB9_3:
 305 ; CHECK: .LBB9_4:
 306 ; CHECK: return ${{[0-9]+}}{{$}}
 307 ; OPT-LABEL: doubletriangle:
 308 ; OPT: block{{$}}
 309 ; OPT: br_if $0, 0{{$}}
 310 ; OPT: block{{$}}
 311 ; OPT: br_if $1, 0{{$}}
 312 ; OPT: .LBB9_3:
 313 ; OPT: .LBB9_4:
 314 ; OPT: return ${{[0-9]+}}{{$}}
 315 define i32 @doubletriangle(i32 %a, i32 %b, i32* %p) {
 316 entry:
 317   %c = icmp eq i32 %a, 0
 318   %d = icmp eq i32 %b, 0
 319   store volatile i32 0, i32* %p
 320   br i1 %c, label %true, label %exit
 321 true:
 322   store volatile i32 2, i32* %p
 323   br i1 %d, label %tt, label %tf
 324 tt:
 325   store volatile i32 3, i32* %p
 326   br label %tf
 327 tf:
 328   store volatile i32 4, i32* %p
 329   br label %exit
 330 exit:
 331   store volatile i32 5, i32* %p
 332   ret i32 0
 333 }
 334
 335 ; CHECK-LABEL: ifelse_earlyexits:
 336 ; CHECK: block{{$}}
 337 ; CHECK: block{{$}}
 338 ; CHECK: br_if $0, 0{{$}}
 339 ; CHECK: br 1{{$}}
 340 ; CHECK: .LBB10_2:
 341 ; CHECK: br_if $1, 0{{$}}
 342 ; CHECK: .LBB10_4:
 343 ; CHECK: return ${{[0-9]+}}{{$}}
 344 ; OPT-LABEL: ifelse_earlyexits:
 345 ; OPT: block{{$}}
 346 ; OPT: block{{$}}
 347 ; OPT: br_if {{[^,]*}}, 0{{$}}
 348 ; OPT: br_if $1, 1{{$}}
 349 ; OPT: br 1{{$}}
 350 ; OPT: .LBB10_3:
 351 ; OPT: .LBB10_4:
 352 ; OPT: return ${{[0-9]+}}{{$}}
 353 define i32 @ifelse_earlyexits(i32 %a, i32 %b, i32* %p) {
 354 entry:
 355   %c = icmp eq i32 %a, 0
 356   %d = icmp eq i32 %b, 0
 357   store volatile i32 0, i32* %p
 358   br i1 %c, label %true, label %false
 359 true:
 360   store volatile i32 1, i32* %p
 361   br label %exit
 362 false:
 363   store volatile i32 2, i32* %p
 364   br i1 %d, label %ft, label %exit
 365 ft:
 366   store volatile i32 3, i32* %p
 367   br label %exit
 368 exit:
 369   store volatile i32 4, i32* %p
 370   ret i32 0
 371 }
 372
 373 ; CHECK-LABEL: doublediamond_in_a_loop:
 374 ; CHECK: .LBB11_1:
 375 ; CHECK: loop{{$}}
 376 ; CHECK: block{{$}}
 377 ; CHECK: block{{$}}
 378 ; CHECK: br_if           $0, 0{{$}}
 379 ; CHECK: br              1{{$}}
 380 ; CHECK: .LBB11_3:
 381 ; CHECK: block{{$}}
 382 ; CHECK: br_if           $1, 0{{$}}
 383 ; CHECK: br              1{{$}}
 384 ; CHECK: .LBB11_5:
 385 ; CHECK: .LBB11_6:
 386 ; CHECK: br              0{{$}}
 387 ; CHECK: .LBB11_7:
 388 ; CHECK-NEXT: end_loop{{$}}
 389 ; OPT-LABEL: doublediamond_in_a_loop:
 390 ; OPT: .LBB11_1:
 391 ; OPT: loop{{$}}
 392 ; OPT: block{{$}}
 393 ; OPT: block{{$}}
 394 ; OPT: br_if           {{[^,]*}}, 0{{$}}
 395 ; OPT: block{{$}}
 396 ; OPT: br_if           {{[^,]*}}, 0{{$}}
 397 ; OPT: br              2{{$}}
 398 ; OPT: .LBB11_4:
 399 ; OPT-NEXT: end_block{{$}}
 400 ; OPT: br              1{{$}}
 401 ; OPT: .LBB11_5:
 402 ; OPT-NEXT: end_block{{$}}
 403 ; OPT: .LBB11_6:
 404 ; OPT-NEXT: end_block{{$}}
 405 ; OPT: br              0{{$}}
 406 ; OPT: .LBB11_7:
 407 ; OPT-NEXT: end_loop{{$}}
 408 define i32 @doublediamond_in_a_loop(i32 %a, i32 %b, i32* %p) {
 409 entry:
 410   br label %header
 411 header:
 412   %c = icmp eq i32 %a, 0
 413   %d = icmp eq i32 %b, 0
 414   store volatile i32 0, i32* %p
 415   br i1 %c, label %true, label %false
 416 true:
 417   store volatile i32 1, i32* %p
 418   br label %exit
 419 false:
 420   store volatile i32 2, i32* %p
 421   br i1 %d, label %ft, label %ff
 422 ft:
 423   store volatile i32 3, i32* %p
 424   br label %exit
 425 ff:
 426   store volatile i32 4, i32* %p
 427   br label %exit
 428 exit:
 429   store volatile i32 5, i32* %p
 430   br label %header
 431 }
 432
 433 ; Test that nested loops are handled.
 434
 435 ; CHECK-LABEL: test3:
 436 ; CHECK: loop
 437 ; CHECK-NEXT: br_if
 438 ; CHECK-NEXT: .LBB{{[0-9]+}}_{{[0-9]+}}:
 439 ; CHECK-NEXT: loop
 440 ; OPT-LABEL: test3:
 441 ; OPT: loop
 442 ; OPT-NEXT: br_if
 443 ; OPT-NEXT: .LBB{{[0-9]+}}_{{[0-9]+}}:
 444 ; OPT-NEXT: loop
 445 declare void @bar()
 446 define void @test3(i32 %w)  {
 447 entry:
 448   br i1 undef, label %outer.ph, label %exit
 449
 450 outer.ph:
 451   br label %outer
 452
 453 outer:
 454   %tobool = icmp eq i32 undef, 0
 455   br i1 %tobool, label %inner, label %unreachable
 456
 457 unreachable:
 458   unreachable
 459
 460 inner:
 461   %c = icmp eq i32 undef, %w
 462   br i1 %c, label %if.end, label %inner
 463
 464 exit:
 465   ret void
 466
 467 if.end:
 468   call void @bar()
 469   br label %outer
 470 }
 471
 472 ; Test switch lowering and block placement.
 473
 474 ; CHECK-LABEL: test4:
 475 ; CHECK-NEXT: .param       i32{{$}}
 476 ; CHECK:      block{{$}}
 477 ; CHECK-NEXT: block{{$}}
 478 ; CHECK-NEXT: block{{$}}
 479 ; CHECK:      br_if       $pop{{[0-9]*}}, 0{{$}}
 480 ; CHECK-NEXT: block{{$}}
 481 ; CHECK:      br_if       $pop{{[0-9]*}}, 0{{$}}
 482 ; CHECK:      br_if       $pop{{[0-9]*}}, 2{{$}}
 483 ; CHECK-NEXT: .LBB13_3:
 484 ; CHECK-NEXT: end_block{{$}}
 485 ; CHECK-NEXT: return{{$}}
 486 ; CHECK-NEXT: .LBB13_4:
 487 ; CHECK:      br_if       $pop{{[0-9]*}}, 1{{$}}
 488 ; CHECK:      br_if       $pop{{[0-9]*}}, 0{{$}}
 489 ; CHECK-NEXT: return{{$}}
 490 ; CHECK-NEXT: .LBB13_7:
 491 ; CHECK-NEXT: end_block{{$}}
 492 ; CHECK-NEXT: return{{$}}
 493 ; CHECK-NEXT: .LBB13_8:
 494 ; CHECK-NEXT: end_block{{$}}
 495 ; CHECK-NEXT: return{{$}}
 496 ; OPT-LABEL: test4:
 497 ; OPT-NEXT: .param       i32{{$}}
 498 ; OPT:      block{{$}}
 499 ; OPT-NEXT: block{{$}}
 500 ; OPT-NEXT: block{{$}}
 501 ; OPT:      br_if       $pop{{[0-9]*}}, 0{{$}}
 502 ; OPT-NEXT: block{{$}}
 503 ; OPT:      br_if       $pop{{[0-9]*}}, 0{{$}}
 504 ; OPT:      br_if       $pop{{[0-9]*}}, 2{{$}}
 505 ; OPT-NEXT: .LBB13_3:
 506 ; OPT-NEXT: end_block{{$}}
 507 ; OPT-NEXT: return{{$}}
 508 ; OPT-NEXT: .LBB13_4:
 509 ; OPT:      br_if       $pop{{[0-9]*}}, 1{{$}}
 510 ; OPT:      br_if       $pop{{[0-9]*}}, 0{{$}}
 511 ; OPT-NEXT: return{{$}}
 512 ; OPT-NEXT: .LBB13_7:
 513 ; OPT-NEXT: end_block{{$}}
 514 ; OPT-NEXT: return{{$}}
 515 ; OPT-NEXT: .LBB13_8:
 516 ; OPT-NEXT: end_block{{$}}
 517 ; OPT-NEXT: return{{$}}
 518 define void @test4(i32 %t) {
 519 entry:
 520   switch i32 %t, label %default [
 521     i32 0, label %bb2
 522     i32 2, label %bb2
 523     i32 4, label %bb1
 524     i32 622, label %bb0
 525   ]
 526
 527 bb0:
 528   ret void
 529
 530 bb1:
 531   ret void
 532
 533 bb2:
 534   ret void
 535
 536 default:
 537   ret void
 538 }
 539
 540 ; Test a case where the BLOCK needs to be placed before the LOOP in the
 541 ; same basic block.
 542
 543 ; CHECK-LABEL: test5:
 544 ; CHECK:       .LBB14_1:
 545 ; CHECK-NEXT:  block{{$}}
 546 ; CHECK-NEXT:  loop{{$}}
 547 ; CHECK:       br_if {{[^,]*}}, 2{{$}}
 548 ; CHECK:       br_if {{[^,]*}}, 0{{$}}
 549 ; CHECK-NEXT:  end_loop{{$}}
 550 ; CHECK:       return{{$}}
 551 ; CHECK-NEXT:  .LBB14_4:
 552 ; CHECK:       return{{$}}
 553 ; OPT-LABEL: test5:
 554 ; OPT:       .LBB14_1:
 555 ; OPT-NEXT:  block{{$}}
 556 ; OPT-NEXT:  loop{{$}}
 557 ; OPT:       br_if {{[^,]*}}, 2{{$}}
 558 ; OPT:       br_if {{[^,]*}}, 0{{$}}
 559 ; OPT-NEXT:  end_loop{{$}}
 560 ; OPT:       return{{$}}
 561 ; OPT-NEXT:  .LBB14_4:
 562 ; OPT:       return{{$}}
 563 define void @test5(i1 %p, i1 %q) {
 564 entry:
 565   br label %header
 566
 567 header:
 568   store volatile i32 0, i32* null
 569   br i1 %p, label %more, label %alt
 570
 571 more:
 572   store volatile i32 1, i32* null
 573   br i1 %q, label %header, label %return
 574
 575 alt:
 576   store volatile i32 2, i32* null
 577   ret void
 578
 579 return:
 580   store volatile i32 3, i32* null
 581   ret void
 582 }
 583
 584 ; Test an interesting case of a loop with multiple exits, which
 585 ; aren't to layout successors of the loop, and one of which is to a successors
 586 ; which has another predecessor.
 587
 588 ; CHECK-LABEL: test6:
 589 ; CHECK:       .LBB15_1:
 590 ; CHECK-NEXT:  block{{$}}
 591 ; CHECK-NEXT:  block{{$}}
 592 ; CHECK-NEXT:  loop{{$}}
 593 ; CHECK-NOT:   block
 594 ; CHECK:       br_if {{[^,]*}}, 3{{$}}
 595 ; CHECK-NOT:   block
 596 ; CHECK:       br_if {{[^,]*}}, 2{{$}}
 597 ; CHECK-NOT:   block
 598 ; CHECK:       br_if {{[^,]*}}, 0{{$}}
 599 ; CHECK-NEXT:  end_loop{{$}}
 600 ; CHECK-NOT:   block
 601 ; CHECK:       return{{$}}
 602 ; CHECK-NEXT:  .LBB15_5:
 603 ; CHECK-NEXT:  end_block{{$}}
 604 ; CHECK-NOT:   block
 605 ; CHECK:       .LBB15_6:
 606 ; CHECK-NEXT:  end_block{{$}}
 607 ; CHECK-NOT:   block
 608 ; CHECK:       return{{$}}
 609 ; OPT-LABEL: test6:
 610 ; OPT:       .LBB15_1:
 611 ; OPT-NEXT:  block{{$}}
 612 ; OPT-NEXT:  block{{$}}
 613 ; OPT-NEXT:  loop{{$}}
 614 ; OPT-NOT:   block
 615 ; OPT:       br_if {{[^,]*}}, 3{{$}}
 616 ; OPT-NOT:   block
 617 ; OPT:       br_if {{[^,]*}}, 2{{$}}
 618 ; OPT-NOT:   block
 619 ; OPT:       br_if {{[^,]*}}, 0{{$}}
 620 ; OPT-NEXT:  end_loop{{$}}
 621 ; OPT-NOT:   block
 622 ; OPT:       return{{$}}
 623 ; OPT-NEXT:  .LBB15_5:
 624 ; OPT-NEXT:  end_block{{$}}
 625 ; OPT-NOT:   block
 626 ; OPT:       .LBB15_6:
 627 ; OPT-NEXT:  end_block{{$}}
 628 ; OPT-NOT:   block
 629 ; OPT:       return{{$}}
 630 define void @test6(i1 %p, i1 %q) {
 631 entry:
 632   br label %header
 633
 634 header:
 635   store volatile i32 0, i32* null
 636   br i1 %p, label %more, label %second
 637
 638 more:
 639   store volatile i32 1, i32* null
 640   br i1 %q, label %evenmore, label %first
 641
 642 evenmore:
 643   store volatile i32 1, i32* null
 644   br i1 %q, label %header, label %return
 645
 646 return:
 647   store volatile i32 2, i32* null
 648   ret void
 649
 650 first:
 651   store volatile i32 3, i32* null
 652   br label %second
 653
 654 second:
 655   store volatile i32 4, i32* null
 656   ret void
 657 }
 658
 659 ; Test a case where there are multiple backedges and multiple loop exits
 660 ; that end in unreachable.
 661
 662 ; CHECK-LABEL: test7:
 663 ; CHECK:       .LBB16_1:
 664 ; CHECK-NEXT:  loop{{$}}
 665 ; CHECK-NOT:   block
 666 ; CHECK:       block{{$}}
 667 ; CHECK:       br_if {{[^,]*}}, 0{{$}}
 668 ; CHECK-NOT:   block
 669 ; CHECK:       br_if {{[^,]*}}, 1{{$}}
 670 ; CHECK-NOT:   block
 671 ; CHECK:       unreachable
 672 ; CHECK-NEXT:  .LBB16_4:
 673 ; CHECK-NEXT:  end_block{{$}}
 674 ; CHECK-NOT:   block
 675 ; CHECK:       br_if {{[^,]*}}, 0{{$}}
 676 ; CHECK-NEXT:  end_loop{{$}}
 677 ; CHECK-NOT:   block
 678 ; CHECK:       unreachable
 679 ; OPT-LABEL: test7:
 680 ; OPT:       .LBB16_1:
 681 ; OPT-NEXT:  loop{{$}}
 682 ; OPT-NOT:   block
 683 ; OPT:       block{{$}}
 684 ; OPT-NOT:   block
 685 ; OPT:       br_if {{[^,]*}}, 0{{$}}
 686 ; OPT-NOT:   block
 687 ; OPT:       br_if {{[^,]*}}, 1{{$}}
 688 ; OPT-NOT:   block
 689 ; OPT:       unreachable
 690 ; OPT-NEXT:  .LBB16_4:
 691 ; OPT-NEXT:  end_block{{$}}
 692 ; OPT-NOT:   block
 693 ; OPT:       br_if {{[^,]*}}, 0{{$}}
 694 ; OPT-NEXT:  end_loop{{$}}
 695 ; OPT-NOT:   block
 696 ; OPT:       unreachable
 697 define void @test7(i1 %tobool2, i1 %tobool9) {
 698 entry:
 699   store volatile i32 0, i32* null
 700   br label %loop
 701
 702 loop:
 703   store volatile i32 1, i32* null
 704   br i1 %tobool2, label %l1, label %l0
 705
 706 l0:
 707   store volatile i32 2, i32* null
 708   br i1 %tobool9, label %loop, label %u0
 709
 710 l1:
 711   store volatile i32 3, i32* null
 712   br i1 %tobool9, label %loop, label %u1
 713
 714 u0:
 715   store volatile i32 4, i32* null
 716   unreachable
 717
 718 u1:
 719   store volatile i32 5, i32* null
 720   unreachable
 721 }
 722
 723 ; Test an interesting case using nested loops and switches.
 724
 725 ; CHECK-LABEL: test8:
 726 ; CHECK:       .LBB17_1:
 727 ; CHECK-NEXT:  loop{{$}}
 728 ; CHECK-NEXT:  block{{$}}
 729 ; CHECK-NOT:   block
 730 ; CHECK:       br_if    {{[^,]*}}, 0{{$}}
 731 ; CHECK-NOT:   block
 732 ; CHECK:       br_if    {{[^,]*}}, 1{{$}}
 733 ; CHECK-NEXT:  .LBB17_3:
 734 ; CHECK-NEXT:  end_block{{$}}
 735 ; CHECK-NEXT:  loop{{$}}
 736 ; CHECK-NEXT:  br_if    {{[^,]*}}, 0{{$}}
 737 ; CHECK-NEXT:  br       2{{$}}
 738 ; CHECK-NEXT:  .LBB17_4:
 739 ; OPT-LABEL: test8:
 740 ; OPT:       .LBB17_1:
 741 ; OPT-NEXT:  loop{{$}}
 742 ; OPT-NEXT:  block{{$}}
 743 ; OPT-NOT:   block
 744 ; OPT:       br_if    {{[^,]*}}, 0{{$}}
 745 ; OPT-NOT:   block
 746 ; OPT:       br_if    {{[^,]*}}, 1{{$}}
 747 ; OPT-NEXT:  .LBB17_3:
 748 ; OPT-NEXT:  end_block{{$}}
 749 ; OPT-NEXT:  loop{{$}}
 750 ; OPT-NEXT:  br_if    {{[^,]*}}, 0{{$}}
 751 ; OPT-NEXT:  br       2{{$}}
 752 ; OPT-NEXT:  .LBB17_4:
 753 define i32 @test8() {
 754 bb:
 755   br label %bb1
 756
 757 bb1:
 758   br i1 undef, label %bb2, label %bb3
 759
 760 bb2:
 761   switch i8 undef, label %bb1 [
 762     i8 44, label %bb2
 763   ]
 764
 765 bb3:
 766   switch i8 undef, label %bb1 [
 767     i8 44, label %bb2
 768   ]
 769 }
 770
 771 ; Test an interesting case using nested loops that share a bottom block.
 772
 773 ; CHECK-LABEL: test9:
 774 ; CHECK:       .LBB18_1:
 775 ; CHECK-NEXT:  loop{{$}}
 776 ; CHECK-NOT:   block
 777 ; CHECK:       br_if     {{[^,]*}}, 1{{$}}
 778 ; CHECK-NEXT:  .LBB18_2:
 779 ; CHECK-NEXT:  loop{{$}}
 780 ; CHECK-NOT:   block
 781 ; CHECK:       block{{$}}
 782 ; CHECK-NOT:   block
 783 ; CHECK:       br_if     {{[^,]*}}, 0{{$}}
 784 ; CHECK-NOT:   block
 785 ; CHECK:       br_if     {{[^,]*}}, 1{{$}}
 786 ; CHECK-NEXT:  br        3{{$}}
 787 ; CHECK-NEXT:  .LBB18_4:
 788 ; CHECK-NEXT:  end_block{{$}}
 789 ; CHECK-NOT:   block
 790 ; CHECK:       br_if     {{[^,]*}}, 0{{$}}
 791 ; CHECK-NEXT:  br        2{{$}}
 792 ; CHECK-NEXT:  .LBB18_5:
 793 ; CHECK-NOT:   block
 794 ; CHECK:       return{{$}}
 795 ; OPT-LABEL: test9:
 796 ; OPT:       .LBB18_1:
 797 ; OPT-NEXT:  loop{{$}}
 798 ; OPT-NOT:   block
 799 ; OPT:       br_if     {{[^,]*}}, 1{{$}}
 800 ; OPT-NEXT:  .LBB18_2:
 801 ; OPT-NEXT:  loop{{$}}
 802 ; OPT-NOT:   block
 803 ; OPT:       block{{$}}
 804 ; OPT-NOT:   block
 805 ; OPT:       br_if     {{[^,]*}}, 0{{$}}
 806 ; OPT-NOT:   block
 807 ; OPT:       br_if     {{[^,]*}}, 1{{$}}
 808 ; OPT-NEXT:  br        3{{$}}
 809 ; OPT-NEXT:  .LBB18_4:
 810 ; OPT-NEXT:  end_block{{$}}
 811 ; OPT-NOT:   block
 812 ; OPT:       br_if     {{[^,]*}}, 0{{$}}
 813 ; OPT-NEXT:  br        2{{$}}
 814 ; OPT-NEXT:  .LBB18_5:
 815 ; OPT-NOT:   block
 816 ; OPT:       return{{$}}
 817 declare i1 @a()
 818 define void @test9() {
 819 entry:
 820   store volatile i32 0, i32* null
 821   br label %header
 822
 823 header:
 824   store volatile i32 1, i32* null
 825   %call4 = call i1 @a()
 826   br i1 %call4, label %header2, label %end
 827
 828 header2:
 829   store volatile i32 2, i32* null
 830   %call = call i1 @a()
 831   br i1 %call, label %if.then, label %if.else
 832
 833 if.then:
 834   store volatile i32 3, i32* null
 835   %call3 = call i1 @a()
 836   br i1 %call3, label %header2, label %header
 837
 838 if.else:
 839   store volatile i32 4, i32* null
 840   %call2 = call i1 @a()
 841   br i1 %call2, label %header2, label %header
 842
 843 end:
 844   store volatile i32 5, i32* null
 845   ret void
 846 }
 847
 848 ; Test an interesting case involving nested loops sharing a loop bottom,
 849 ; and loop exits to a block with unreachable.
 850
 851 ; CHECK-LABEL: test10:
 852 ; CHECK:       .LBB19_1:
 853 ; CHECK-NEXT:  loop{{$}}
 854 ; CHECK-NOT:   block
 855 ; CHECK:       br_if    {{[^,]*}}, 0{{$}}
 856 ; CHECK-NEXT:  .LBB19_2:
 857 ; CHECK-NEXT:  block{{$}}
 858 ; CHECK-NEXT:  loop{{$}}
 859 ; CHECK-NOT:   block
 860 ; CHECK:       .LBB19_3:
 861 ; CHECK-NEXT:  loop{{$}}
 862 ; CHECK-NOT:   block
 863 ; CHECK:       br_if    {{[^,]*}}, 5{{$}}
 864 ; CHECK-NOT:   block
 865 ; CHECK:       tableswitch  {{[^,]*}}, 0, 0, 1, 5, 2, 4{{$}}
 866 ; CHECK-NEXT:  .LBB19_5:
 867 ; CHECK-NEXT:  end_loop{{$}}
 868 ; CHECK-NEXT:  end_loop{{$}}
 869 ; CHECK-NEXT:  return{{$}}
 870 ; CHECK-NEXT:  .LBB19_6:
 871 ; CHECK-NEXT:  end_block{{$}}
 872 ; CHECK-NOT:   block
 873 ; CHECK:       br       0{{$}}
 874 ; CHECK-NEXT:  .LBB19_7:
 875 ; OPT-LABEL: test10:
 876 ; OPT:       .LBB19_1:
 877 ; OPT-NEXT:  loop{{$}}
 878 ; OPT-NOT:   block
 879 ; OPT:       br_if    {{[^,]*}}, 0{{$}}
 880 ; OPT-NEXT:  .LBB19_2:
 881 ; OPT-NEXT:  block{{$}}
 882 ; OPT-NEXT:  loop{{$}}
 883 ; OPT-NOT:   block
 884 ; OPT:       .LBB19_3:
 885 ; OPT-NEXT:  loop{{$}}
 886 ; OPT-NOT:   block
 887 ; OPT:       br_if    {{[^,]*}}, 5{{$}}
 888 ; OPT-NOT:   block
 889 ; OPT:       tableswitch  {{[^,]*}}, 0, 0, 1, 5, 2, 4{{$}}
 890 ; OPT-NEXT:  .LBB19_5:
 891 ; OPT-NEXT:  end_loop{{$}}
 892 ; OPT-NEXT:  end_loop{{$}}
 893 ; OPT-NEXT:  return{{$}}
 894 ; OPT-NEXT:  .LBB19_6:
 895 ; OPT-NEXT:  end_block{{$}}
 896 ; OPT-NOT:   block
 897 ; OPT:       br       0{{$}}
 898 ; OPT-NEXT:  .LBB19_7:
 899 define void @test10() {
 900 bb0:
 901   br label %bb1
 902
 903 bb1:
 904   %tmp = phi i32 [ 2, %bb0 ], [ 3, %bb3 ]
 905   %tmp3 = phi i32 [ undef, %bb0 ], [ %tmp11, %bb3 ]
 906   %tmp4 = icmp eq i32 %tmp3, 0
 907   br i1 %tmp4, label %bb4, label %bb2
 908
 909 bb2:
 910   br label %bb3
 911
 912 bb3:
 913   %tmp11 = phi i32 [ 1, %bb5 ], [ 0, %bb2 ]
 914   br label %bb1
 915
 916 bb4:
 917   %tmp6 = phi i32 [ %tmp9, %bb5 ], [ 4, %bb1 ]
 918   %tmp7 = phi i32 [ %tmp6, %bb5 ], [ %tmp, %bb1 ]
 919   br label %bb5
 920
 921 bb5:
 922   %tmp9 = phi i32 [ %tmp6, %bb5 ], [ %tmp7, %bb4 ]
 923   switch i32 %tmp9, label %bb2 [
 924     i32 0, label %bb5
 925     i32 1, label %bb6
 926     i32 3, label %bb4
 927     i32 4, label %bb3
 928   ]
 929
 930 bb6:
 931   ret void
 932 }
 933
 934 ; Test a CFG DAG with interesting merging.
 935
 936 ; CHECK-LABEL: test11:
 937 ; CHECK:       block{{$}}
 938 ; CHECK-NEXT:  block{{$}}
 939 ; CHECK-NEXT:  block{{$}}
 940 ; CHECK-NEXT:  block{{$}}
 941 ; CHECK-NEXT:  br_if        {{[^,]*}}, 0{{$}}
 942 ; CHECK-NEXT:  block{{$}}
 943 ; CHECK-NOT:   block
 944 ; CHECK:       br_if        {{[^,]*}}, 0{{$}}
 945 ; CHECK-NOT:   block
 946 ; CHECK:       br_if        {{[^,]*}}, 2{{$}}
 947 ; CHECK-NEXT:  .LBB20_3:
 948 ; CHECK-NEXT:  end_block{{$}}
 949 ; CHECK-NOT:   block
 950 ; CHECK:       return{{$}}
 951 ; CHECK-NEXT:  .LBB20_4:
 952 ; CHECK-NEXT:  end_block{{$}}
 953 ; CHECK-NOT:   block
 954 ; CHECK:       br_if        {{[^,]*}}, 2{{$}}
 955 ; CHECK-NOT:   block
 956 ; CHECK:       br_if        {{[^,]*}}, 1{{$}}
 957 ; CHECK-NEXT:  .LBB20_6:
 958 ; CHECK-NEXT:  end_block{{$}}
 959 ; CHECK-NOT:   block
 960 ; CHECK:       return{{$}}
 961 ; CHECK-NEXT:  .LBB20_7:
 962 ; CHECK-NEXT:  end_block{{$}}
 963 ; CHECK-NOT:   block
 964 ; CHECK:       return{{$}}
 965 ; CHECK-NEXT:  .LBB20_8:
 966 ; CHECK-NEXT:  end_block{{$}}
 967 ; CHECK-NOT:   block
 968 ; CHECK:       return{{$}}
 969 ; OPT-LABEL: test11:
 970 ; OPT:       block{{$}}
 971 ; OPT-NEXT:  block{{$}}
 972 ; OPT-NEXT:  br_if        $0, 0{{$}}
 973 ; OPT-NEXT:  block{{$}}
 974 ; OPT-NOT:   block
 975 ; OPT:       br_if        $0, 0{{$}}
 976 ; OPT-NOT:   block
 977 ; OPT:       br_if        $0, 2{{$}}
 978 ; OPT-NEXT:  .LBB20_3:
 979 ; OPT-NEXT:  end_block{{$}}
 980 ; OPT-NOT:   block
 981 ; OPT:       return{{$}}
 982 ; OPT-NEXT:  .LBB20_4:
 983 ; OPT-NEXT:  end_block{{$}}
 984 ; OPT-NOT:   block
 985 ; OPT:       block{{$}}
 986 ; OPT-NOT:   block
 987 ; OPT:       br_if        $pop9, 0{{$}}
 988 ; OPT-NOT:   block
 989 ; OPT:       return{{$}}
 990 ; OPT-NEXT:  .LBB20_6:
 991 ; OPT-NEXT:  end_block{{$}}
 992 ; OPT-NOT:   block
 993 ; OPT:       br_if        $0, 0{{$}}
 994 ; OPT-NOT:   block
 995 ; OPT:       return{{$}}
 996 ; OPT-NEXT:  .LBB20_8:
 997 ; OPT-NEXT:  end_block{{$}}
 998 ; OPT-NOT:   block
 999 ; OPT:       return{{$}}
1000 define void @test11() {
1001 bb0:
1002   store volatile i32 0, i32* null
1003   br i1 undef, label %bb1, label %bb4
1004 bb1:
1005   store volatile i32 1, i32* null
1006   br i1 undef, label %bb3, label %bb2
1007 bb2:
1008   store volatile i32 2, i32* null
1009   br i1 undef, label %bb3, label %bb7
1010 bb3:
1011   store volatile i32 3, i32* null
1012   ret void
1013 bb4:
1014   store volatile i32 4, i32* null
1015   br i1 undef, label %bb8, label %bb5
1016 bb5:
1017   store volatile i32 5, i32* null
1018   br i1 undef, label %bb6, label %bb7
1019 bb6:
1020   store volatile i32 6, i32* null
1021   ret void
1022 bb7:
1023   store volatile i32 7, i32* null
1024   ret void
1025 bb8:
1026   store volatile i32 8, i32* null
1027   ret void
1028 }
1029
1030 ; CHECK-LABEL: test12:
1031 ; CHECK:       .LBB21_1:
1032 ; CHECK-NEXT:  loop{{$}}
1033 ; CHECK-NOT:   block
1034 ; CHECK:       block{{$}}
1035 ; CHECK-NEXT:  block{{$}}
1036 ; CHECK-NEXT:  block{{$}}
1037 ; CHECK:       br_if       {{[^,]*}}, 0{{$}}
1038 ; CHECK-NOT:   block
1039 ; CHECK:       br_if       {{[^,]*}}, 2{{$}}
1040 ; CHECK-NOT:   block
1041 ; CHECK:       br_if       {{[^,]*}}, 2{{$}}
1042 ; CHECK-NEXT:  br          1{{$}}
1043 ; CHECK-NEXT:  .LBB21_4:
1044 ; CHECK-NEXT:  end_block{{$}}
1045 ; CHECK-NOT:   block
1046 ; CHECK:       br_if       {{[^,]*}}, 1{{$}}
1047 ; CHECK-NOT:   block
1048 ; CHECK:       br_if       {{[^,]*}}, 1{{$}}
1049 ; CHECK-NEXT:  .LBB21_6:
1050 ; CHECK-NEXT:  end_block{{$}}
1051 ; CHECK-NEXT:  return{{$}}
1052 ; CHECK-NEXT:  .LBB21_7:
1053 ; CHECK-NEXT:  end_block{{$}}
1054 ; CHECK-NOT:   block
1055 ; CHECK:       br          0{{$}}
1056 ; CHECK-NEXT:  .LBB21_8:
1057 ; OPT-LABEL: test12:
1058 ; OPT:       .LBB21_1:
1059 ; OPT-NEXT:  loop{{$}}
1060 ; OPT-NOT:   block
1061 ; OPT:       block{{$}}
1062 ; OPT-NEXT:  block{{$}}
1063 ; OPT-NEXT:  block{{$}}
1064 ; OPT:       br_if       {{[^,]*}}, 0{{$}}
1065 ; OPT-NOT:   block
1066 ; OPT:       br_if       {{[^,]*}}, 2{{$}}
1067 ; OPT-NOT:   block
1068 ; OPT:       br_if       {{[^,]*}}, 2{{$}}
1069 ; OPT-NEXT:  br          1{{$}}
1070 ; OPT-NEXT:  .LBB21_4:
1071 ; OPT-NEXT:  end_block{{$}}
1072 ; OPT-NOT:   block
1073 ; OPT:       br_if       {{[^,]*}}, 1{{$}}
1074 ; OPT-NOT:   block
1075 ; OPT:       br_if       {{[^,]*}}, 1{{$}}
1076 ; OPT-NEXT:  .LBB21_6:
1077 ; OPT-NEXT:  end_block{{$}}
1078 ; OPT-NEXT:  return{{$}}
1079 ; OPT-NEXT:  .LBB21_7:
1080 ; OPT-NEXT:  end_block{{$}}
1081 ; OPT-NOT:   block
1082 ; OPT:       br          0{{$}}
1083 ; OPT-NEXT:  .LBB21_8:
1084 define void @test12(i8* %arg) {
1085 bb:
1086   br label %bb1
1087
1088 bb1:
1089   %tmp = phi i32 [ 0, %bb ], [ %tmp5, %bb4 ]
1090   %tmp2 = getelementptr i8, i8* %arg, i32 %tmp
1091   %tmp3 = load i8, i8* %tmp2
1092   switch i8 %tmp3, label %bb7 [
1093     i8 42, label %bb4
1094     i8 76, label %bb4
1095     i8 108, label %bb4
1096     i8 104, label %bb4
1097   ]
1098
1099 bb4:
1100   %tmp5 = add i32 %tmp, 1
1101   br label %bb1
1102
1103 bb7:
1104   ret void
1105 }
1106
1107 ; A block can be "branched to" from another even if it is also reachable via
1108 ; fallthrough from the other. This would normally be optimized away, so use
1109 ; optnone to disable optimizations to test this case.
1110
1111 ; CHECK-LABEL: test13:
1112 ; CHECK-NEXT:  local i32{{$}}
1113 ; CHECK:       block{{$}}
1114 ; CHECK:       br_if $pop4, 0{{$}}
1115 ; CHECK-NEXT:  return{{$}}
1116 ; CHECK-NEXT:  .LBB22_2:
1117 ; CHECK-NEXT:  end_block{{$}}
1118 ; CHECK:       block{{$}}
1119 ; CHECK-NEXT:  br_if $0, 0{{$}}
1120 ; CHECK:       .LBB22_4:
1121 ; CHECK-NEXT:  end_block{{$}}
1122 ; CHECK:       block{{$}}
1123 ; CHECK:       br_if $pop6, 0{{$}}
1124 ; CHECK-NEXT:  end_block{{$}}
1125 ; CHECK-NEXT:  unreachable{{$}}
1126 ; OPT-LABEL: test13:
1127 ; OPT-NEXT:  local i32{{$}}
1128 ; OPT:       block{{$}}
1129 ; OPT:       br_if $pop4, 0{{$}}
1130 ; OPT-NEXT:  return{{$}}
1131 ; OPT-NEXT:  .LBB22_2:
1132 ; OPT-NEXT:  end_block{{$}}
1133 ; OPT:       block{{$}}
1134 ; OPT-NEXT:  br_if $0, 0{{$}}
1135 ; OPT:       .LBB22_4:
1136 ; OPT-NEXT:  end_block{{$}}
1137 ; OPT:       block{{$}}
1138 ; OPT:       br_if $pop6, 0{{$}}
1139 ; OPT-NEXT:  end_block{{$}}
1140 ; OPT-NEXT:  unreachable{{$}}
1141 define void @test13() noinline optnone {
1142 bb:
1143   br i1 undef, label %bb5, label %bb2
1144 bb1:
1145   unreachable
1146 bb2:
1147   br i1 undef, label %bb3, label %bb4
1148 bb3:
1149   br label %bb4
1150 bb4:
1151   %tmp = phi i1 [ false, %bb2 ], [ false, %bb3 ]
1152   br i1 %tmp, label %bb1, label %bb1
1153 bb5:
1154   ret void
1155 }
1156
1157 ; Test a case with a single-block loop that has another loop
1158 ; as a successor. The end_loop for the first loop should go
1159 ; before the loop for the second.
1160
1161 ; CHECK-LABEL: test14:
1162 ; CHECK-NEXT:     local       i32{{$}}
1163 ; CHECK-NEXT:     i32.const   $0=, 0{{$}}
1164 ; CHECK-NEXT: .LBB23_1:{{$}}
1165 ; CHECK-NEXT:     loop{{$}}
1166 ; CHECK-NEXT:     br_if       $0, 0{{$}}
1167 ; CHECK-NEXT: .LBB23_2:{{$}}
1168 ; CHECK-NEXT:     end_loop{{$}}
1169 ; CHECK-NEXT:     loop{{$}}
1170 ; CHECK-NEXT:     br_if       $0, 0{{$}}
1171 ; CHECK-NEXT:     end_loop{{$}}
1172 ; CHECK-NEXT:     return{{$}}
1173 define void @test14() {
1174 bb:
1175   br label %bb1
1176
1177 bb1:
1178   %tmp = bitcast i1 undef to i1
1179   br i1 %tmp, label %bb3, label %bb1
1180
1181 bb3:
1182   br label %bb4
1183
1184 bb4:
1185   br i1 undef, label %bb7, label %bb48
1186
1187 bb7:
1188   br i1 undef, label %bb12, label %bb12
1189
1190 bb12:
1191   br i1 undef, label %bb17, label %bb17
1192
1193 bb17:
1194   br i1 undef, label %bb22, label %bb22
1195
1196 bb22:
1197   br i1 undef, label %bb27, label %bb27
1198
1199 bb27:
1200   br i1 undef, label %bb30, label %bb30
1201
1202 bb30:
1203   br i1 undef, label %bb35, label %bb35
1204
1205 bb35:
1206   br i1 undef, label %bb38, label %bb38
1207
1208 bb38:
1209   br i1 undef, label %bb48, label %bb48
1210
1211 bb48:
1212   %tmp49 = bitcast i1 undef to i1
1213   br i1 %tmp49, label %bb3, label %bb50
1214
1215 bb50:
1216   ret void
1217 }