test/CodeGen/WinEH/wineh-multi-parent-cloning.ll

   1 ; RUN: opt -mtriple=x86_x64-pc-windows-msvc -S -winehprepare  < %s | FileCheck %s
   2
   3 declare i32 @__CxxFrameHandler3(...)
   4
   5 declare void @f()
   6 declare i32 @g()
   7 declare void @h(i32)
   8 declare i1 @b()
   9
  10 define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
  11 entry:
  12   invoke void @f()
  13     to label %invoke.cont unwind label %left
  14 invoke.cont:
  15   invoke void @f()
  16     to label %exit unwind label %right
  17 left:
  18   cleanuppad []
  19   br label %shared
  20 right:
  21   catchpad []
  22     to label %right.catch unwind label %right.end
  23 right.catch:
  24   br label %shared
  25 right.end:
  26   catchendpad unwind to caller
  27 shared:
  28   %x = call i32 @g()
  29   invoke void @f()
  30     to label %shared.cont unwind label %inner
  31 shared.cont:
  32   unreachable
  33 inner:
  34   %i = cleanuppad []
  35   call void @h(i32 %x)
  36   cleanupret %i unwind label %right.end
  37 exit:
  38   ret void
  39 }
  40 ; %inner is a cleanup which appears both as a child of
  41 ; %left and as a child of %right.  Since statically we
  42 ; need each funclet to have a single parent, we need to
  43 ; clone the entire %inner funclet so we can have one
  44 ; copy under each parent.  The cleanupret in %inner
  45 ; unwinds to the catchendpad for %right, so the copy
  46 ; of %inner under %right should include it; the copy
  47 ; of %inner under %left should instead have an
  48 ; `unreachable` inserted there, but the copy under
  49 ; %left still needs to be created because it's possible
  50 ; the dynamic path enters %left, then enters %inner,
  51 ; then calls @h, and that the call to @h doesn't return.
  52 ; CHECK-LABEL: define void @test1(
  53 ; CHECK:     left:
  54 ; CHECK:       cleanuppad
  55 ; CHECK:       %x.for.left = call i32 @g()
  56 ; CHECK:       invoke void @f()
  57 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
  58 ; CHECK:     right:
  59 ; CHECK:           to label %right.catch unwind label %right.end
  60 ; CHECK:     right.catch:
  61 ; CHECK:       %x = call i32 @g()
  62 ; CHECK:           to label %shared.cont unwind label %[[INNER_RIGHT:.+]]
  63 ; CHECK:     right.end:
  64 ; CHECK:       catchendpad unwind to caller
  65 ; CHECK:     shared.cont:
  66 ; CHECK:       unreachable
  67 ; CHECK:     [[SHARED_CONT_LEFT]]:
  68 ; CHECK:       unreachable
  69 ; CHECK:     [[INNER_RIGHT]]:
  70 ; CHECK:       [[I_R:\%.+]] = cleanuppad []
  71 ; CHECK:       call void @h(i32 %x)
  72 ; CHECK:       cleanupret [[I_R]] unwind label %right.end
  73 ; CHECK:     [[INNER_LEFT]]:
  74 ; CHECK:       [[I_L:\%.+]] = cleanuppad []
  75 ; CHECK:       call void @h(i32 %x.for.left)
  76 ; CHECK:       unreachable
  77
  78
  79 define void @test2() personality i32 (...)* @__CxxFrameHandler3 {
  80 entry:
  81   invoke void @f()
  82     to label %invoke.cont unwind label %left
  83 invoke.cont:
  84   invoke void @f()
  85     to label %exit unwind label %right
  86 left:
  87   cleanuppad []
  88   br label %shared
  89 right:
  90   catchpad []
  91     to label %right.catch unwind label %right.end
  92 right.catch:
  93   br label %shared
  94 right.end:
  95   catchendpad unwind to caller
  96 shared:
  97   %x = call i32 @g()
  98   invoke void @f()
  99     to label %shared.cont unwind label %inner
 100 shared.cont:
 101   unreachable
 102 inner:
 103   catchpad []
 104     to label %inner.catch unwind label %inner.end
 105 inner.catch:
 106   call void @h(i32 %x)
 107   unreachable
 108 inner.end:
 109   catchendpad unwind label %right.end
 110 exit:
 111   ret void
 112 }
 113 ; In this case left and right are both parents of inner.  This differs from
 114 ; @test1 in that inner is a catchpad rather than a cleanuppad, which makes
 115 ; inner.end a block that gets cloned so that left and right each contain a
 116 ; copy (catchendpad blocks are considered to be part of the parent funclet
 117 ; of the associated catchpad). The catchendpad in %inner.end unwinds to
 118 ; %right.end (which belongs to the entry funclet).
 119 ; CHECK-LABEL: define void @test2(
 120 ; CHECK:     left:
 121 ; CHECK:       cleanuppad
 122 ; CHECK:       %x.for.left = call i32 @g()
 123 ; CHECK:       invoke void @f()
 124 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
 125 ; CHECK:     right:
 126 ; CHECK:           to label %right.catch unwind label %[[RIGHT_END:.+]]
 127 ; CHECK:     right.catch:
 128 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
 129 ; CHECK:     [[RIGHT_END]]:
 130 ; CHECK:       catchendpad unwind to caller
 131 ; CHECK:     [[SHARED_CONT_RIGHT]]:
 132 ; CHECK:       unreachable
 133 ; CHECK:     [[SHARED_CONT_LEFT]]:
 134 ; CHECK:       unreachable
 135 ; CHECK:     [[INNER_RIGHT]]:
 136 ; CHECK:       catchpad []
 137 ; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
 138 ; CHECK:     [[INNER_LEFT]]:
 139 ; CHECK:       catchpad []
 140 ; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
 141 ; CHECK:     [[INNER_CATCH_RIGHT]]:
 142 ; CHECK:       call void @h(i32 %x)
 143 ; CHECK:       unreachable
 144 ; CHECK:     [[INNER_CATCH_LEFT]]:
 145 ; CHECK:       call void @h(i32 %x.for.left)
 146 ; CHECK:       unreachable
 147 ; CHECK:     [[INNER_END_LEFT]]:
 148 ; CHECK:       catchendpad unwind to caller
 149 ; CHECK:     [[INNER_END_RIGHT]]:
 150 ; CHECK:       catchendpad unwind label %[[RIGHT_END]]
 151
 152 define void @test3() personality i32 (...)* @__CxxFrameHandler3 {
 153 entry:
 154   invoke void @f()
 155     to label %exit unwind label %left
 156 left:
 157   %l = cleanuppad []
 158   br label %shared
 159 left.end:
 160   cleanupendpad %l unwind label %right
 161 right:
 162   catchpad []
 163     to label %right.catch unwind label %right.end
 164 right.catch:
 165   br label %shared
 166 right.end:
 167   catchendpad unwind to caller
 168 shared:
 169   %x = call i32 @g()
 170   invoke void @f()
 171     to label %shared.cont unwind label %inner
 172 shared.cont:
 173   unreachable
 174 inner:
 175   catchpad []
 176     to label %inner.catch unwind label %inner.end
 177 inner.catch:
 178   call void @h(i32 %x)
 179   unreachable
 180 inner.end:
 181   catchendpad unwind label %left.end
 182 exit:
 183   ret void
 184 }
 185 ; In this case, %left and %right are siblings with %entry as the parent of both,
 186 ; while %left and %right are both parents of %inner.  The catchendpad in
 187 ; %inner.end unwinds to %left.end.  When %inner is cloned a copy of %inner.end
 188 ; will be made for both %left and %right, but because %left.end is a cleanup pad
 189 ; and %right is a catch pad the unwind edge from the copy of %inner.end for
 190 ; %right must be removed.
 191 ; CHECK-LABEL: define void @test3(
 192 ; CHECK:     left:
 193 ; CHECK:       %l = cleanuppad []
 194 ; CHECK:       %x.for.left = call i32 @g()
 195 ; CHECK:       invoke void @f()
 196 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
 197 ; CHECK:     [[LEFT_END:left.end.*]]:
 198 ; CHECK:       cleanupendpad %l unwind label %right
 199 ; CHECK:     right:
 200 ; CHECK:           to label %right.catch unwind label %[[RIGHT_END:.+]]
 201 ; CHECK:     right.catch:
 202 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
 203 ; CHECK:     [[RIGHT_END]]:
 204 ; CHECK:       catchendpad unwind to caller
 205 ; CHECK:     [[SHARED_CONT_RIGHT]]:
 206 ; CHECK:       unreachable
 207 ; CHECK:     [[SHARED_CONT_LEFT]]:
 208 ; CHECK:       unreachable
 209 ; CHECK:     [[INNER_RIGHT]]:
 210 ; CHECK:       catchpad []
 211 ; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
 212 ; CHECK:     [[INNER_LEFT]]:
 213 ; CHECK:       catchpad []
 214 ; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
 215 ; CHECK:     [[INNER_CATCH_RIGHT]]:
 216 ; CHECK:       call void @h(i32 %x)
 217 ; CHECK:       unreachable
 218 ; CHECK:     [[INNER_CATCH_LEFT]]:
 219 ; CHECK:       call void @h(i32 %x.for.left)
 220 ; CHECK:       unreachable
 221 ; CHECK:     [[INNER_END_LEFT]]:
 222 ; CHECK:       catchendpad unwind label %[[LEFT_END]]
 223 ; CHECK:     [[INNER_END_RIGHT]]:
 224 ; CHECK:       catchendpad unwind to caller
 225
 226
 227 define void @test4() personality i32 (...)* @__CxxFrameHandler3 {
 228 entry:
 229   invoke void @f()
 230     to label %exit unwind label %left
 231 left:
 232   catchpad []
 233     to label %left.catch unwind label %left.end
 234 left.catch:
 235   br label %shared
 236 left.end:
 237   catchendpad unwind label %right
 238 right:
 239   catchpad []
 240     to label %right.catch unwind label %right.end
 241 right.catch:
 242   br label %shared
 243 right.end:
 244   catchendpad unwind to caller
 245 shared:
 246   %x = call i32 @g()
 247   invoke void @f()
 248     to label %shared.cont unwind label %inner
 249 shared.cont:
 250   unreachable
 251 inner:
 252   catchpad []
 253     to label %inner.catch unwind label %inner.end
 254 inner.catch:
 255   call void @h(i32 %x)
 256   unreachable
 257 inner.end:
 258   catchendpad unwind label %left.end
 259 exit:
 260   ret void
 261 }
 262 ; This is a variation of @test3 in which both %left and %right are catch pads.
 263 ; In this case, %left and %right are siblings with %entry as the parent of both,
 264 ; while %left and %right are both parents of %inner.  The catchendpad in
 265 ; %inner.end unwinds to %left.end.  When %inner is cloned a copy of %inner.end
 266 ; will be made for both %left and %right, but because the catchpad in %right
 267 ; does not unwind to %left.end the unwind edge from the copy of %inner.end for
 268 ; %right must be removed.
 269 ; CHECK-LABEL: define void @test4(
 270 ; CHECK:     left:
 271 ; CHECK:       catchpad []
 272 ; CHECK:           to label %left.catch unwind label %[[LEFT_END:.+]]
 273 ; CHECK:     left.catch:
 274 ; CHECK:       %x.for.left = call i32 @g()
 275 ; CHECK:       invoke void @f()
 276 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
 277 ; CHECK:     [[LEFT_END]]:
 278 ; CHECK:       catchendpad unwind label %right
 279 ; CHECK:     right:
 280 ; CHECK:           to label %right.catch unwind label %[[RIGHT_END:.+]]
 281 ; CHECK:     right.catch:
 282 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
 283 ; CHECK:     [[RIGHT_END]]:
 284 ; CHECK:       catchendpad unwind to caller
 285 ; CHECK:     [[SHARED_CONT_RIGHT]]:
 286 ; CHECK:       unreachable
 287 ; CHECK:     [[SHARED_CONT_LEFT]]:
 288 ; CHECK:       unreachable
 289 ; CHECK:     [[INNER_RIGHT]]:
 290 ; CHECK:       catchpad []
 291 ; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
 292 ; CHECK:     [[INNER_LEFT]]:
 293 ; CHECK:       catchpad []
 294 ; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
 295 ; CHECK:     [[INNER_CATCH_RIGHT]]:
 296 ; CHECK:       call void @h(i32 %x)
 297 ; CHECK:       unreachable
 298 ; CHECK:     [[INNER_CATCH_LEFT]]:
 299 ; CHECK:       call void @h(i32 %x.for.left)
 300 ; CHECK:       unreachable
 301 ; CHECK:     [[INNER_END_RIGHT]]:
 302 ; CHECK:       catchendpad unwind to caller
 303 ; CHECK:     [[INNER_END_LEFT]]:
 304 ; CHECK:       catchendpad unwind label %[[LEFT_END]]
 305
 306
 307 define void @test5() personality i32 (...)* @__CxxFrameHandler3 {
 308 entry:
 309   invoke void @f()
 310     to label %exit unwind label %left
 311 left:
 312   catchpad []
 313     to label %left.catch unwind label %left.end
 314 left.catch:
 315   br label %shared
 316 left.end:
 317   catchendpad unwind label %right
 318 right:
 319   %r = cleanuppad []
 320   br label %shared
 321 shared:
 322   %x = call i32 @g()
 323   invoke void @f()
 324     to label %shared.cont unwind label %inner
 325 shared.cont:
 326   unreachable
 327 inner:
 328   catchpad []
 329     to label %inner.catch unwind label %inner.end
 330 inner.catch:
 331   call void @h(i32 %x)
 332   unreachable
 333 inner.end:
 334   catchendpad unwind label %left.end
 335 exit:
 336   ret void
 337 }
 338 ; Like @test3, %left and %right are siblings with %entry as the parent of both,
 339 ; while %left and %right are both parents of %inner.  This case makes %left a
 340 ; catch and %right a cleanup so that %inner unwinds to %left.end, which is a
 341 ; block in %entry.  The %inner funclet is cloned for %left and %right, but the
 342 ; copy of %inner.end for %right must have its unwind edge removed because the
 343 ; catchendpad at %left.end is not compatible with %right.
 344 ; CHECK-LABEL: define void @test5(
 345 ; CHECK:     left:
 346 ; CHECK:       catchpad []
 347 ; CHECK:           to label %left.catch unwind label %[[LEFT_END:.+]]
 348 ; CHECK:     left.catch:
 349 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
 350 ; CHECK:     [[LEFT_END]]:
 351 ; CHECK:       catchendpad unwind label %right
 352 ; CHECK:     right:
 353 ; CHECK:       %r = cleanuppad []
 354 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
 355 ; CHECK:     [[SHARED_CONT_RIGHT]]:
 356 ; CHECK:       unreachable
 357 ; CHECK:     [[SHARED_CONT_LEFT]]:
 358 ; CHECK:       unreachable
 359 ; CHECK:     [[INNER_RIGHT]]:
 360 ; CHECK:       catchpad []
 361 ; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
 362 ; CHECK:     [[INNER_LEFT]]:
 363 ; CHECK:       catchpad []
 364 ; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
 365 ; CHECK:     [[INNER_CATCH_RIGHT]]:
 366 ; CHECK:       call void @h(i32 %x)
 367 ; CHECK:       unreachable
 368 ; CHECK:     [[INNER_CATCH_LEFT]]:
 369 ; CHECK:       call void @h(i32 %x.for.left)
 370 ; CHECK:       unreachable
 371 ; CHECK:     [[INNER_END_RIGHT]]:
 372 ; CHECK:       catchendpad unwind to caller
 373 ; CHECK:     [[INNER_END_LEFT]]:
 374 ; CHECK:       catchendpad unwind label %[[LEFT_END]]
 375
 376 define void @test6() personality i32 (...)* @__CxxFrameHandler3 {
 377 entry:
 378   invoke void @f()
 379     to label %exit unwind label %left
 380 left:
 381   catchpad []
 382     to label %left.catch unwind label %left.end
 383 left.catch:
 384   br label %shared
 385 left.end:
 386   catchendpad unwind label %middle
 387 middle:
 388   %m = catchpad []
 389     to label %middle.catch unwind label %middle.end
 390 middle.catch:
 391   catchret %m to label %exit
 392 middle.end:
 393   catchendpad unwind label %right
 394 right:
 395   %r = cleanuppad []
 396   br label %shared
 397 shared:
 398   %x = call i32 @g()
 399   invoke void @f()
 400     to label %shared.cont unwind label %inner
 401 shared.cont:
 402   unreachable
 403 inner:
 404   catchpad []
 405     to label %inner.catch unwind label %inner.end
 406 inner.catch:
 407   call void @h(i32 %x)
 408   unreachable
 409 inner.end:
 410   catchendpad unwind label %left.end
 411 exit:
 412   ret void
 413 }
 414 ; This is like @test5 but it inserts another sibling between %left and %right.
 415 ; In this case %left, %middle and %right are all siblings, while %left and
 416 ; %right are both parents of %inner.  This checks the proper handling of the
 417 ; catchendpad in %inner.end (which will be cloned so that %left and %right both
 418 ; have copies) unwinding to a catchendpad that unwinds to a sibling.
 419 ; CHECK-LABEL: define void @test6(
 420 ; CHECK:     left:
 421 ; CHECK:       catchpad []
 422 ; CHECK:           to label %left.catch unwind label %[[LEFT_END:.+]]
 423 ; CHECK:     left.catch:
 424 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
 425 ; CHECK:     [[LEFT_END]]:
 426 ; CHECK:       catchendpad unwind label %middle
 427 ; CHECK:     middle:
 428 ; CHECK:       catchpad []
 429 ; CHECK:         to label %middle.catch unwind label %middle.end
 430 ; CHECK:     middle.catch:
 431 ; CHECK:       catchret %m to label %exit
 432 ; CHECK:     middle.end:
 433 ; CHECK:       catchendpad unwind label %right
 434 ; CHECK:     right:
 435 ; CHECK:       %r = cleanuppad []
 436 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
 437 ; CHECK:     [[SHARED_CONT_RIGHT]]:
 438 ; CHECK:       unreachable
 439 ; CHECK:     [[SHARED_CONT_LEFT]]:
 440 ; CHECK:       unreachable
 441 ; CHECK:     [[INNER_RIGHT]]:
 442 ; CHECK:       catchpad []
 443 ; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
 444 ; CHECK:     [[INNER_LEFT]]:
 445 ; CHECK:       catchpad []
 446 ; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
 447 ; CHECK:     [[INNER_CATCH_RIGHT]]:
 448 ; CHECK:       call void @h(i32 %x)
 449 ; CHECK:       unreachable
 450 ; CHECK:     [[INNER_CATCH_LEFT]]:
 451 ; CHECK:       call void @h(i32 %x.for.left)
 452 ; CHECK:       unreachable
 453 ; CHECK:     [[INNER_END_RIGHT]]:
 454 ; CHECK:       catchendpad unwind to caller
 455 ; CHECK:     [[INNER_END_LEFT]]:
 456 ; CHECK:       catchendpad unwind label %[[LEFT_END]]
 457
 458
 459 define void @test7() personality i32 (...)* @__CxxFrameHandler3 {
 460 entry:
 461   invoke void @f()
 462     to label %exit unwind label %left
 463 left:
 464   catchpad []
 465     to label %left.catch unwind label %left.end
 466 left.catch:
 467   br label %shared
 468 left.end:
 469   catchendpad unwind label %right
 470 right:
 471   %r = cleanuppad []
 472   br label %shared
 473 shared:
 474   %x = call i32 @g()
 475   invoke void @f()
 476     to label %shared.cont unwind label %inner
 477 shared.cont:
 478   unreachable
 479 inner:
 480   catchpad []
 481     to label %inner.catch unwind label %inner.end
 482 inner.catch:
 483   call void @h(i32 %x)
 484   unreachable
 485 inner.end:
 486   catchendpad unwind label %inner.sibling
 487 inner.sibling:
 488   %is = cleanuppad []
 489   call void @h(i32 0)
 490   cleanupret %is unwind label %left.end
 491 exit:
 492   ret void
 493 }
 494 ; This is like @test5 but instead of unwinding to %left.end, the catchendpad
 495 ; in %inner.end unwinds to a sibling cleanup pad. Both %inner (along with its
 496 ; associated blocks) and %inner.sibling must be cloned for %left and %right.
 497 ; The clones of %inner will be identical, but the copy of %inner.sibling for
 498 ; %right must end with an unreachable instruction, because it cannot unwind to
 499 ; %left.end.
 500 ; CHECK-LABEL: define void @test7(
 501 ; CHECK:     left:
 502 ; CHECK:       catchpad []
 503 ; CHECK:           to label %left.catch unwind label %[[LEFT_END:.+]]
 504 ; CHECK:     left.catch:
 505 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
 506 ; CHECK:     [[LEFT_END]]:
 507 ; CHECK:       catchendpad unwind label %[[RIGHT:.+]]
 508 ; CHECK:     [[RIGHT]]:
 509 ; CHECK:       [[R:\%.+]] = cleanuppad []
 510 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
 511 ; CHECK:     [[SHARED_CONT_RIGHT]]:
 512 ; CHECK:       unreachable
 513 ; CHECK:     [[SHARED_CONT_LEFT]]:
 514 ; CHECK:       unreachable
 515 ; CHECK:     [[INNER_RIGHT]]:
 516 ; CHECK:       catchpad []
 517 ; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
 518 ; CHECK:     [[INNER_LEFT]]:
 519 ; CHECK:       catchpad []
 520 ; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
 521 ; CHECK:     [[INNER_CATCH_RIGHT]]:
 522 ; CHECK:       call void @h(i32 %x)
 523 ; CHECK:       unreachable
 524 ; CHECK:     [[INNER_CATCH_LEFT]]:
 525 ; CHECK:       call void @h(i32 %x.for.left)
 526 ; CHECK:       unreachable
 527 ; CHECK:     [[INNER_END_RIGHT]]:
 528 ; CHECK:       catchendpad unwind label %[[INNER_SIBLING_RIGHT:.+]]
 529 ; CHECK:     [[INNER_END_LEFT]]:
 530 ; CHECK:       catchendpad unwind label %[[INNER_SIBLING_LEFT:.+]]
 531 ; CHECK:     [[INNER_SIBLING_RIGHT]]
 532 ; CHECK:       [[IS_R:\%.+]] = cleanuppad []
 533 ; CHECK:       call void @h(i32 0)
 534 ; CHECK:       unreachable
 535 ; CHECK:     [[INNER_SIBLING_LEFT]]
 536 ; CHECK:       [[IS_L:\%.+]] = cleanuppad []
 537 ; CHECK:       call void @h(i32 0)
 538 ; CHECK:       cleanupret [[IS_L]] unwind label %[[LEFT_END]]
 539
 540
 541 define void @test8() personality i32 (...)* @__CxxFrameHandler3 {
 542 entry:
 543   invoke void @f()
 544     to label %invoke.cont unwind label %left
 545 invoke.cont:
 546   invoke void @f()
 547     to label %unreachable unwind label %right
 548 left:
 549   cleanuppad []
 550   invoke void @f() to label %unreachable unwind label %inner
 551 right:
 552   catchpad []
 553     to label %right.catch unwind label %right.end
 554 right.catch:
 555   invoke void @f() to label %unreachable unwind label %inner
 556 right.end:
 557   catchendpad unwind to caller
 558 inner:
 559   %i = cleanuppad []
 560   %x = call i32 @g()
 561   call void @h(i32 %x)
 562   cleanupret %i unwind label %right.end
 563 unreachable:
 564   unreachable
 565 }
 566 ; Another case of a two-parent child (like @test1), this time
 567 ; with the join at the entry itself instead of following a
 568 ; non-pad join.
 569 ; CHECK-LABEL: define void @test8(
 570 ; CHECK:     invoke.cont:
 571 ; CHECK:           to label %[[UNREACHABLE_ENTRY:.+]] unwind label %right
 572 ; CHECK:     left:
 573 ; CHECK:           to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
 574 ; CHECK:     right:
 575 ; CHECK:           to label %right.catch unwind label %right.end
 576 ; CHECK:     right.catch:
 577 ; CHECK:           to label %unreachable unwind label %[[INNER_RIGHT:.+]]
 578 ; CHECK:     right.end:
 579 ; CHECK:       catchendpad unwind to caller
 580 ; CHECK:     [[INNER_RIGHT]]:
 581 ; CHECK:       [[I_R:\%.+]] = cleanuppad []
 582 ; CHECK:       [[X_R:\%.+]] = call i32 @g()
 583 ; CHECK:       call void @h(i32 [[X_R]])
 584 ; CHECK:       cleanupret [[I_R]] unwind label %right.end
 585 ; CHECK:     [[INNER_LEFT]]:
 586 ; CHECK:       [[I_L:\%.+]] = cleanuppad []
 587 ; CHECK:       [[X_L:\%.+]] = call i32 @g()
 588 ; CHECK:       call void @h(i32 [[X_L]])
 589 ; CHECK:       unreachable
 590 ; CHECK:     unreachable:
 591 ; CHECK:       unreachable
 592 ; CHECK:     [[UNREACHABLE_LEFT]]:
 593 ; CHECK:       unreachable
 594 ; CHECK:     [[UNREACHABLE_ENTRY]]:
 595 ; CHECK:       unreachable
 596
 597
 598 define void @test9() personality i32 (...)* @__CxxFrameHandler3 {
 599 entry:
 600   invoke void @f()
 601     to label %invoke.cont unwind label %left
 602 invoke.cont:
 603   invoke void @f()
 604     to label %unreachable unwind label %right
 605 left:
 606   cleanuppad []
 607   br label %shared
 608 right:
 609   catchpad []
 610     to label %right.catch unwind label %right.end
 611 right.catch:
 612   br label %shared
 613 right.end:
 614   catchendpad unwind to caller
 615 shared:
 616   invoke void @f()
 617     to label %unreachable unwind label %inner
 618 inner:
 619   cleanuppad []
 620   invoke void @f()
 621     to label %unreachable unwind label %inner.child
 622 inner.child:
 623   cleanuppad []
 624   %x = call i32 @g()
 625   call void @h(i32 %x)
 626   unreachable
 627 unreachable:
 628   unreachable
 629 }
 630 ; %inner is a two-parent child which itself has a child; need
 631 ; to make two copies of both the %inner and %inner.child.
 632 ; CHECK-LABEL: define void @test9(
 633 ; CHECK:     invoke.cont:
 634 ; CHECK:               to label %[[UNREACHABLE_ENTRY:.+]] unwind label %right
 635 ; CHECK:     left:
 636 ; CHECK:               to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
 637 ; CHECK:     right:
 638 ; CHECK:               to label %right.catch unwind label %right.end
 639 ; CHECK:     right.catch:
 640 ; CHECK:               to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
 641 ; CHECK:     right.end:
 642 ; CHECK:       catchendpad unwind to caller
 643 ; CHECK:     [[INNER_RIGHT]]:
 644 ; CHECK:               to label %[[UNREACHABLE_INNER_RIGHT:.+]] unwind label %[[INNER_CHILD_RIGHT:.+]]
 645 ; CHECK:     [[INNER_LEFT]]:
 646 ; CHECK:               to label %[[UNREACHABLE_INNER_LEFT:.+]] unwind label %[[INNER_CHILD_LEFT:.+]]
 647 ; CHECK:     [[INNER_CHILD_RIGHT]]:
 648 ; CHECK:       [[TMP:\%.+]] = cleanuppad []
 649 ; CHECK:       [[X:\%.+]] = call i32 @g()
 650 ; CHECK:       call void @h(i32 [[X]])
 651 ; CHECK:       unreachable
 652 ; CHECK:     [[INNER_CHILD_LEFT]]:
 653 ; CHECK:       [[TMP:\%.+]] = cleanuppad []
 654 ; CHECK:       [[X:\%.+]] = call i32 @g()
 655 ; CHECK:       call void @h(i32 [[X]])
 656 ; CHECK:       unreachable
 657 ; CHECK:     [[UNREACHABLE_INNER_RIGHT]]:
 658 ; CHECK:       unreachable
 659 ; CHECK:     [[UNREACHABLE_INNER_LEFT]]:
 660 ; CHECK:       unreachable
 661 ; CHECK:     [[UNREACHABLE_RIGHT]]:
 662 ; CHECK:       unreachable
 663 ; CHECK:     [[UNREACHABLE_LEFT]]:
 664 ; CHECK:       unreachable
 665 ; CHECK:     [[UNREACHABLE_ENTRY]]:
 666 ; CHECK:       unreachable
 667
 668
 669 define void @test10() personality i32 (...)* @__CxxFrameHandler3 {
 670 entry:
 671   invoke void @f()
 672     to label %invoke.cont unwind label %left
 673 invoke.cont:
 674   invoke void @f()
 675     to label %unreachable unwind label %right
 676 left:
 677   cleanuppad []
 678   call void @h(i32 1)
 679   invoke void @f()
 680     to label %unreachable unwind label %right
 681 right:
 682   cleanuppad []
 683   call void @h(i32 2)
 684   invoke void @f()
 685     to label %unreachable unwind label %left
 686 unreachable:
 687   unreachable
 688 }
 689 ; This is an irreducible loop with two funclets that enter each other;
 690 ; need to make two copies of each funclet (one a child of root, the
 691 ; other a child of the opposite funclet), but also make sure not to
 692 ; clone self-descendants (if we tried to do that we'd need to make an
 693 ; infinite number of them).  Presumably if optimizations ever generated
 694 ; such a thing it would mean that one of the two cleanups was originally
 695 ; the parent of the other, but that we'd somehow lost track in the CFG
 696 ; of which was which along the way; generating each possibility lets
 697 ; whichever case was correct execute correctly.
 698 ; CHECK-LABEL: define void @test10(
 699 ; CHECK:     entry:
 700 ; CHECK:               to label %invoke.cont unwind label %[[LEFT:.+]]
 701 ; CHECK:     invoke.cont:
 702 ; CHECK:               to label %[[UNREACHABLE_ENTRY:.+]] unwind label %[[RIGHT:.+]]
 703 ; CHECK:     [[LEFT_FROM_RIGHT:.+]]:
 704 ; CHECK:       call void @h(i32 1)
 705 ; CHECK:       call void @f()
 706 ; CHECK:       unreachable
 707 ; CHECK:     [[LEFT]]:
 708 ; CHECK:       call void @h(i32 1)
 709 ; CHECK:       invoke void @f()
 710 ; CHECK:               to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[RIGHT_FROM_LEFT:.+]]
 711 ; CHECK:     [[RIGHT]]:
 712 ; CHECK:       call void @h(i32 2)
 713 ; CHECK:       invoke void @f()
 714 ; CHECK:               to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[LEFT_FROM_RIGHT]]
 715 ; CHECK:     [[RIGHT_FROM_LEFT]]:
 716 ; CHECK:       call void @h(i32 2)
 717 ; CHECK:       call void @f()
 718 ; CHECK:       unreachable
 719 ; CHECK:     [[UNREACHABLE_RIGHT]]:
 720 ; CHECK:       unreachable
 721 ; CHECK:     [[UNREACHABLE_LEFT]]:
 722 ; CHECK:       unreachable
 723 ; CHECK:     [[UNREACHABLE_ENTRY]]:
 724 ; CHECK:       unreachable
 725
 726
 727 define void @test11() personality i32 (...)* @__CxxFrameHandler3 {
 728 entry:
 729   invoke void @f()
 730     to label %exit unwind label %left
 731 left:
 732   catchpad []
 733     to label %left.catch unwind label %left.sibling
 734 left.catch:
 735   br label %shared
 736 left.sibling:
 737   %ls = catchpad []
 738     to label %left.sibling.catch unwind label %left.end
 739 left.sibling.catch:
 740   catchret %ls to label %exit
 741 left.end:
 742   catchendpad unwind label %right
 743 right:
 744   catchpad []
 745     to label %right.catch unwind label %right.end
 746 right.catch:
 747   br label %shared
 748 right.end:
 749   catchendpad unwind to caller
 750 shared:
 751   %x = call i32 @g()
 752   invoke void @f()
 753     to label %shared.cont unwind label %inner
 754 shared.cont:
 755   unreachable
 756 inner:
 757   catchpad []
 758     to label %inner.catch unwind label %inner.end
 759 inner.catch:
 760   call void @h(i32 %x)
 761   unreachable
 762 inner.end:
 763   catchendpad unwind label %left.end
 764 exit:
 765   ret void
 766 }
 767 ; This is a variation of @test4 in which the shared child funclet unwinds to a
 768 ; catchend pad that is the unwind destination of %left.sibling rather than %left
 769 ; but is still a valid destination for %inner as reach from %left.
 770 ; When %inner is cloned a copy of %inner.end will be made for both %left and
 771 ; %right, but because the catchpad in %right does not unwind to %left.end the
 772 ; unwind edge from the copy of %inner.end for %right must be removed.
 773 ; CHECK-LABEL: define void @test11(
 774 ; CHECK:     left:
 775 ; CHECK:       catchpad []
 776 ; CHECK:           to label %left.catch unwind label %left.sibling
 777 ; CHECK:     left.catch:
 778 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
 779 ; CHECK:     left.sibling:
 780 ; CHECK:       catchpad []
 781 ; CHECK:           to label %left.sibling.catch unwind label %[[LEFT_END:.+]]
 782 ; CHECK:     [[LEFT_END]]:
 783 ; CHECK:       catchendpad unwind label %right
 784 ; CHECK:     right:
 785 ; CHECK:           to label %right.catch unwind label %[[RIGHT_END:.+]]
 786 ; CHECK:     right.catch:
 787 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
 788 ; CHECK:     [[RIGHT_END]]:
 789 ; CHECK:       catchendpad unwind to caller
 790 ; CHECK:     [[SHARED_CONT_RIGHT]]:
 791 ; CHECK:       unreachable
 792 ; CHECK:     [[SHARED_CONT_LEFT]]:
 793 ; CHECK:       unreachable
 794 ; CHECK:     [[INNER_RIGHT]]:
 795 ; CHECK:       catchpad []
 796 ; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
 797 ; CHECK:     [[INNER_LEFT]]:
 798 ; CHECK:       catchpad []
 799 ; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
 800 ; CHECK:     [[INNER_CATCH_RIGHT]]:
 801 ; CHECK:       call void @h(i32 %x)
 802 ; CHECK:       unreachable
 803 ; CHECK:     [[INNER_CATCH_LEFT]]:
 804 ; CHECK:       call void @h(i32 %x.for.left)
 805 ; CHECK:       unreachable
 806 ; CHECK:     [[INNER_END_RIGHT]]:
 807 ; CHECK:       catchendpad unwind to caller
 808 ; CHECK:     [[INNER_END_LEFT]]:
 809 ; CHECK:       catchendpad unwind label %[[LEFT_END]]
 810
 811
 812 define void @test12() personality i32 (...)* @__CxxFrameHandler3 {
 813 entry:
 814   invoke void @f()
 815     to label %exit unwind label %left
 816 left:
 817   catchpad []
 818     to label %left.catch unwind label %right
 819 left.catch:
 820   br label %shared
 821 right:
 822   catchpad []
 823     to label %right.catch unwind label %right.end
 824 right.catch:
 825   br label %shared
 826 right.end:
 827   catchendpad unwind to caller
 828 shared:
 829   %x = call i32 @g()
 830   invoke void @f()
 831     to label %shared.cont unwind label %inner
 832 shared.cont:
 833   unreachable
 834 inner:
 835   catchpad []
 836     to label %inner.catch unwind label %inner.end
 837 inner.catch:
 838   call void @h(i32 %x)
 839   unreachable
 840 inner.end:
 841   catchendpad unwind label %right.end
 842 exit:
 843   ret void
 844 }
 845 ; In this case %left and %right are both parents of %inner, so %inner must be
 846 ; cloned but the catchendpad unwind target in %inner.end is valid for both
 847 ; parents, so the unwind edge should not be removed in either case.
 848 ; CHECK-LABEL: define void @test12(
 849 ; CHECK:     left:
 850 ; CHECK:       catchpad []
 851 ; CHECK:           to label %left.catch unwind label %right
 852 ; CHECK:     left.catch:
 853 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
 854 ; CHECK:     right:
 855 ; CHECK:           to label %right.catch unwind label %[[RIGHT_END:.+]]
 856 ; CHECK:     right.catch:
 857 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
 858 ; CHECK:     [[RIGHT_END]]:
 859 ; CHECK:       catchendpad unwind to caller
 860 ; CHECK:     [[SHARED_CONT_RIGHT]]:
 861 ; CHECK:       unreachable
 862 ; CHECK:     [[SHARED_CONT_LEFT]]:
 863 ; CHECK:       unreachable
 864 ; CHECK:     [[INNER_RIGHT]]:
 865 ; CHECK:       catchpad []
 866 ; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
 867 ; CHECK:     [[INNER_LEFT]]:
 868 ; CHECK:       catchpad []
 869 ; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
 870 ; CHECK:     [[INNER_CATCH_RIGHT]]:
 871 ; CHECK:       call void @h(i32 %x)
 872 ; CHECK:       unreachable
 873 ; CHECK:     [[INNER_CATCH_LEFT]]:
 874 ; CHECK:       call void @h(i32 %x.for.left)
 875 ; CHECK:       unreachable
 876 ; CHECK:     [[INNER_END_RIGHT]]:
 877 ; CHECK:       catchendpad unwind label %[[RIGHT_END]]
 878 ; CHECK:     [[INNER_END_LEFT]]:
 879 ; CHECK:       catchendpad unwind label %[[RIGHT_END]]
 880
 881 define void @test13() personality i32 (...)* @__CxxFrameHandler3 {
 882 entry:
 883   invoke void @f()
 884     to label %invoke.cont unwind label %left
 885 invoke.cont:
 886   invoke void @f()
 887     to label %exit unwind label %right
 888 left:
 889   %l = catchpad []
 890     to label %left.cont unwind label %left.end
 891 left.cont:
 892   invoke void @f()
 893     to label %left.ret unwind label %inner
 894 left.ret:
 895   catchret %l to label %invoke.cont
 896 left.end:
 897   catchendpad unwind to caller
 898 right:
 899   %r = catchpad []
 900     to label %right.catch unwind label %right.end
 901 right.catch:
 902   invoke void @f()
 903     to label %right.ret unwind label %inner
 904 right.ret:
 905   catchret %r to label %exit
 906 right.end:
 907   catchendpad unwind to caller
 908 shared:
 909   call void @h(i32 0)
 910   unreachable
 911 inner:
 912   %i = catchpad []
 913     to label %inner.catch unwind label %inner.end
 914 inner.catch:
 915   call void @h(i32 1)
 916   catchret %i to label %shared
 917 inner.end:
 918   catchendpad unwind label %left.end
 919 exit:
 920   ret void
 921 }
 922 ; This case tests the scenario where a funclet with multiple parents uses a
 923 ; catchret to return to a block that may exist in either parent funclets.
 924 ; Both %left and %right are parents of %inner.  During common block cloning
 925 ; a clone of %shared will be made so that both %left and %right have a copy,
 926 ; but the copy of %shared for one of the parent funclets will be unreachable
 927 ; until the %inner funclet is cloned.  When the %inner.catch block is cloned
 928 ; during the %inner funclet cloning, the catchret instruction should be updated
 929 ; so that the catchret in the copy %inner.catch for %left returns to the copy of
 930 ; %shared in %left and the catchret in the copy of %inner.catch for %right
 931 ; returns to the copy of %shared for %right.
 932 ; CHECK-LABEL: define void @test13(
 933 ; CHECK:     left:
 934 ; CHECK:       %l = catchpad []
 935 ; CHECK:           to label %left.cont unwind label %left.end
 936 ; CHECK:     left.cont:
 937 ; CHECK:       invoke void @f()
 938 ; CHECK:           to label %left.ret unwind label %[[INNER_LEFT:.+]]
 939 ; CHECK:     left.ret:
 940 ; CHECK:       catchret %l to label %invoke.cont
 941 ; CHECK:     left.end:
 942 ; CHECK:       catchendpad unwind to caller
 943 ; CHECK:     right:
 944 ; CHECK:       %r = catchpad []
 945 ; CHECK:           to label %right.catch unwind label %right.end
 946 ; CHECK:     right.catch:
 947 ; CHECK:       invoke void @f()
 948 ; CHECK:           to label %right.ret unwind label %[[INNER_RIGHT:.+]]
 949 ; CHECK:     right.ret:
 950 ; CHECK:       catchret %r to label %exit
 951 ; CHECK:     right.end:
 952 ; CHECK:       catchendpad unwind to caller
 953 ; CHECK:     [[SHARED_RIGHT:.+]]:
 954 ; CHECK:       call void @h(i32 0)
 955 ; CHECK:       unreachable
 956 ; CHECK:     [[SHARED_LEFT:.+]]:
 957 ; CHECK:       call void @h(i32 0)
 958 ; CHECK:       unreachable
 959 ; CHECK:     [[INNER_RIGHT]]:
 960 ; CHECK:       %[[I_RIGHT:.+]] = catchpad []
 961 ; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
 962 ; CHECK:     [[INNER_LEFT]]:
 963 ; CHECK:       %[[I_LEFT:.+]] = catchpad []
 964 ; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
 965 ; CHECK:     [[INNER_CATCH_RIGHT]]:
 966 ; CHECK:       call void @h(i32 1)
 967 ; CHECK:       catchret %[[I_RIGHT]] to label %[[SHARED_RIGHT]]
 968 ; CHECK:     [[INNER_CATCH_LEFT]]:
 969 ; CHECK:       call void @h(i32 1)
 970 ; CHECK:       catchret %[[I_LEFT]] to label %[[SHARED_LEFT]]
 971 ; CHECK:     [[INNER_END_LEFT]]:
 972 ; CHECK:       catchendpad unwind label %[[LEFT_END]]
 973 ; CHECK:     [[INNER_END_RIGHT]]:
 974 ; CHECK:       catchendpad unwind to caller
 975
 976
 977 define void @test14() personality i32 (...)* @__CxxFrameHandler3 {
 978 entry:
 979   invoke void @f()
 980     to label %exit unwind label %left
 981 left:
 982   %l = catchpad []
 983     to label %shared unwind label %left.end
 984 left.cont:
 985   invoke void @f()
 986     to label %left.ret unwind label %right
 987 left.ret:
 988   catchret %l to label %exit
 989 left.end:
 990   catchendpad unwind to caller
 991 right:
 992   catchpad []
 993     to label %right.catch unwind label %right.end
 994 right.catch:
 995   br label %shared
 996 right.end:
 997   catchendpad unwind label %left.end
 998 shared:
 999   invoke void @f()
1000     to label %shared.cont unwind label %inner
1001 shared.cont:
1002   unreachable
1003 inner:
1004   %i = catchpad []
1005     to label %inner.catch unwind label %inner.end
1006 inner.catch:
1007   call void @h(i32 0)
1008   catchret %i to label %left.cont
1009 inner.end:
1010   catchendpad unwind label %left.end
1011 exit:
1012   ret void
1013 }
1014 ; This case tests another scenario where a funclet with multiple parents uses a
1015 ; catchret to return to a block in one of the parent funclets.  Here %right and
1016 ; %left are both parents of %inner and %left is a parent of %right.  The
1017 ; catchret in %inner.catch will cause %left.cont and %left.ret to be cloned for
1018 ; both %left and %right, but the catchret in %left.ret is invalid for %right
1019 ; but the catchret instruction in the copy of %left.ret for %right will be
1020 ; removed as an implausible terminator.
1021 ; CHECK-LABEL: define void @test14(
1022 ; CHECK:     left:
1023 ; CHECK:       %l = catchpad []
1024 ; CHECK:           to label %[[SHARED_LEFT:.+]] unwind label %[[LEFT_END:.+]]
1025 ; CHECK:     [[LEFT_CONT:left.cont.*]]:
1026 ; CHECK:       invoke void @f()
1027 ; CHECK:           to label %[[LEFT_RET:.+]] unwind label %[[RIGHT:.+]]
1028 ; CHECK:     [[LEFT_RET]]:
1029 ; CHECK:       catchret %l to label %exit
1030 ; CHECK:     [[LEFT_END]]:
1031 ; CHECK:       catchendpad unwind to caller
1032 ; CHECK:     [[RIGHT]]:
1033 ; CHECK:       catchpad []
1034 ; CHECK:           to label %[[RIGHT_CATCH:.+]] unwind label %[[RIGHT_END:.+]]
1035 ; CHECK:     [[RIGHT_CATCH]]:
1036 ; CHECK:       invoke void @f()
1037 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
1038 ; CHECK:     [[RIGHT_END]]:
1039 ; CHECK:       catchendpad unwind label %[[LEFT_END]]
1040 ; CHECK:     [[SHARED_LEFT]]:
1041 ; CHECK:       invoke void @f()
1042 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
1043 ; CHECK:     [[SHARED_CONT_RIGHT]]:
1044 ; CHECK:       unreachable
1045 ; CHECK:     [[SHARED_CONT_LEFT]]:
1046 ; CHECK:       unreachable
1047 ; CHECK:     [[INNER_LEFT]]:
1048 ; CHECK:       [[I_LEFT:\%.+]] = catchpad []
1049 ; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
1050 ; CHECK:     [[INNER_RIGHT]]:
1051 ; CHECK:       [[I_RIGHT:\%.+]] = catchpad []
1052 ; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
1053 ; CHECK:     [[INNER_CATCH_LEFT]]:
1054 ; CHECK:       call void @h(i32 0)
1055 ; CHECK:       catchret [[I_LEFT]] to label %[[LEFT_CONT]]
1056 ; CHECK:     [[INNER_CATCH_RIGHT]]:
1057 ; CHECK:       call void @h(i32 0)
1058 ; CHECK:       unreachable
1059 ; CHECK:     [[INNER_END_LEFT]]:
1060 ; CHECK:       catchendpad unwind label %[[LEFT_END]]
1061 ; CHECK:     [[INNER_END_RIGHT]]:
1062 ; CHECK:       catchendpad unwind to caller
1063
1064 define void @test15() personality i32 (...)* @__CxxFrameHandler3 {
1065 entry:
1066   invoke void @f()
1067     to label %exit unwind label %left
1068 left:
1069   %l = catchpad []
1070     to label %left.catch unwind label %left.end
1071 left.catch:
1072   invoke void @f()
1073     to label %shared unwind label %right
1074 left.ret:
1075   catchret %l to label %exit
1076 left.end:
1077   catchendpad unwind to caller
1078 right:
1079   catchpad []
1080     to label %right.catch unwind label %right.end
1081 right.catch:
1082   br label %shared
1083 right.end:
1084   catchendpad unwind label %left.end
1085 shared:
1086   invoke void @f()
1087     to label %shared.cont unwind label %inner
1088 shared.cont:
1089   unreachable
1090 inner:
1091   %i = catchpad []
1092     to label %inner.catch unwind label %inner.end
1093 inner.catch:
1094   call void @h(i32 0)
1095   catchret %i to label %left.ret
1096 inner.end:
1097   catchendpad unwind label %left.end
1098 exit:
1099   ret void
1100 }
1101 ; This case is a variation of test14 but instead of returning to an invoke the
1102 ; catchret in %inner.catch returns to a catchret instruction.
1103 ; CHECK-LABEL: define void @test15(
1104 ; CHECK:     left:
1105 ; CHECK:       %l = catchpad []
1106 ; CHECK:           to label %left.catch unwind label %[[LEFT_END:.+]]
1107 ; CHECK:     left.catch:
1108 ; CHECK:       invoke void @f()
1109 ; CHECK:           to label %[[SHARED_LEFT:.+]] unwind label %[[RIGHT:.+]]
1110 ; CHECK:     [[LEFT_RET_RIGHT:.+]]:
1111 ; CHECK:       unreachable
1112 ; CHECK:     [[LEFT_RET_LEFT:.+]]:
1113 ; CHECK:       catchret %l to label %exit
1114 ; CHECK:     [[LEFT_END]]:
1115 ; CHECK:       catchendpad unwind to caller
1116 ; CHECK:     [[RIGHT]]:
1117 ; CHECK:       catchpad []
1118 ; CHECK:           to label %[[RIGHT_CATCH:.+]] unwind label %[[RIGHT_END:.+]]
1119 ; CHECK:     [[RIGHT_CATCH]]:
1120 ; CHECK:       invoke void @f()
1121 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
1122 ; CHECK:     [[RIGHT_END]]:
1123 ; CHECK:       catchendpad unwind label %[[LEFT_END]]
1124 ; CHECK:     [[SHARED_LEFT]]:
1125 ; CHECK:       invoke void @f()
1126 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
1127 ; CHECK:     [[SHARED_CONT_RIGHT]]:
1128 ; CHECK:       unreachable
1129 ; CHECK:     [[SHARED_CONT_LEFT]]:
1130 ; CHECK:       unreachable
1131 ; CHECK:     [[INNER_LEFT]]:
1132 ; CHECK:       [[I_LEFT:\%.+]] = catchpad []
1133 ; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
1134 ; CHECK:     [[INNER_RIGHT]]:
1135 ; CHECK:       [[I_RIGHT:\%.+]] = catchpad []
1136 ; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
1137 ; CHECK:     [[INNER_CATCH_LEFT]]:
1138 ; CHECK:       call void @h(i32 0)
1139 ; CHECK:       catchret [[I_LEFT]] to label %[[LEFT_RET_LEFT]]
1140 ; CHECK:     [[INNER_CATCH_RIGHT]]:
1141 ; CHECK:       call void @h(i32 0)
1142 ; CHECK:       catchret [[I_RIGHT]] to label %[[LEFT_RET_RIGHT]]
1143 ; CHECK:     [[INNER_END_RIGHT]]:
1144 ; CHECK:       catchendpad unwind to caller
1145 ; CHECK:     [[INNER_END_LEFT]]:
1146 ; CHECK:       catchendpad unwind label %[[LEFT_END]]
1147
1148
1149 define void @test16() personality i32 (...)* @__CxxFrameHandler3 {
1150 entry:
1151   invoke void @f()
1152     to label %exit unwind label %left
1153 left:
1154   %l = cleanuppad []
1155   br label %shared
1156 left.cont:
1157   cleanupret %l unwind label %right
1158 left.end:
1159   cleanupendpad %l unwind label %right
1160 right:
1161   catchpad []
1162     to label %right.catch unwind label %right.end
1163 right.catch:
1164   br label %shared
1165 right.end:
1166   catchendpad unwind to caller
1167 shared:
1168   invoke void @f()
1169     to label %shared.cont unwind label %inner
1170 shared.cont:
1171   unreachable
1172 inner:
1173   %i = catchpad []
1174     to label %inner.catch unwind label %inner.end
1175 inner.catch:
1176   call void @h(i32 0)
1177   catchret %i to label %left.cont
1178 inner.end:
1179   catchendpad unwind label %left.end
1180 exit:
1181   ret void
1182 }
1183 ; This case is another variation of test14 but here the catchret in %inner.catch
1184 ; returns to a cleanupret instruction.
1185 ; CHECK-LABEL: define void @test16(
1186 ; CHECK:     left:
1187 ; CHECK:       %l = cleanuppad []
1188 ; CHECK:       invoke void @f()
1189 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
1190 ; CHECK:     [[LEFT_CONT_RIGHT:.+]]:
1191 ; CHECK:       unreachable
1192 ; CHECK:     [[LEFT_CONT_LEFT:.+]]:
1193 ; CHECK:       cleanupret %l unwind label %[[RIGHT:.+]]
1194 ; CHECK:     [[LEFT_END_LEFT:.+]]:
1195 ; CHECK:       cleanupendpad %l unwind label %[[RIGHT]]
1196 ; CHECK:     [[RIGHT]]:
1197 ; CHECK:       catchpad []
1198 ; CHECK:           to label %[[RIGHT_CATCH:.+]] unwind label %[[RIGHT_END:.+]]
1199 ; CHECK:     [[RIGHT_CATCH]]:
1200 ; CHECK:       invoke void @f()
1201 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
1202 ; CHECK:     [[RIGHT_END]]:
1203 ; CHECK:       catchendpad unwind to caller
1204 ; CHECK:     [[SHARED_CONT_RIGHT]]:
1205 ; CHECK:       unreachable
1206 ; CHECK:     [[SHARED_CONT_LEFT]]:
1207 ; CHECK:       unreachable
1208 ; CHECK:     [[INNER_RIGHT]]:
1209 ; CHECK:       [[I_RIGHT:\%.+]] = catchpad []
1210 ; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
1211 ; CHECK:     [[INNER_LEFT]]:
1212 ; CHECK:       [[I_LEFT:\%.+]] = catchpad []
1213 ; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
1214 ; CHECK:     [[INNER_CATCH_RIGHT]]:
1215 ; CHECK:       call void @h(i32 0)
1216 ; CHECK:       catchret [[I_RIGHT]] to label %[[LEFT_CONT_RIGHT]]
1217 ; CHECK:     [[INNER_CATCH_LEFT]]:
1218 ; CHECK:       call void @h(i32 0)
1219 ; CHECK:       catchret [[I_LEFT]] to label %[[LEFT_CONT_LEFT]]
1220 ; CHECK:     [[INNER_END_LEFT]]:
1221 ; CHECK:       catchendpad unwind label %[[LEFT_END_LEFT]]
1222 ; CHECK:     [[INNER_END_RIGHT]]:
1223 ; CHECK:       catchendpad unwind to caller
1224
1225
1226 define void @test17() personality i32 (...)* @__CxxFrameHandler3 {
1227 entry:
1228   invoke void @f()
1229     to label %invoke.cont unwind label %left
1230 invoke.cont:
1231   invoke void @f()
1232     to label %exit unwind label %right
1233 left:
1234   %l = cleanuppad []
1235   br label %shared
1236 right:
1237   catchpad []
1238     to label %right.catch unwind label %right.end
1239 right.catch:
1240   br label %shared
1241 right.end:
1242   catchendpad unwind to caller
1243 shared:
1244   invoke void @f()
1245     to label %unreachable unwind label %inner
1246 unreachable:
1247   unreachable
1248 inner:
1249   %i = catchpad []
1250     to label %inner.catch unwind label %inner.sibling
1251 inner.catch:
1252   call void @h(i32 0)
1253   unreachable
1254 inner.sibling:
1255   %is = catchpad []
1256     to label %inner.sibling.catch unwind label %inner.end
1257 inner.sibling.catch:
1258   invoke void @f()
1259     to label %unreachable unwind label %inner.end
1260 inner.end:
1261   catchendpad unwind label %right.end
1262 exit:
1263   ret void
1264 }
1265 ; This case tests the scenario where two catchpads with the same catchendpad
1266 ; have multiple parents.  Both %left and %right are parents of %inner and
1267 ; %inner.sibling so both of the inner funclets must be cloned.  Because
1268 ; the catchendpad in %inner.end unwinds to the catchendpad for %right, the
1269 ; unwind edge should be removed for the copy of %inner.end that is reached
1270 ; from %left.  In addition, the %inner.siblin.catch block contains an invoke
1271 ; that unwinds to the shared inner catchendpad.  The unwind destination for
1272 ; this invoke should be updated to unwind to the correct cloned %inner.end
1273 ; for each path to the funclet.
1274 ; CHECK-LABEL: define void @test17(
1275 ; CHECK:     left:
1276 ; CHECK:       %l = cleanuppad []
1277 ; CHECK:       invoke void @f()
1278 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
1279 ; CHECK:     right:
1280 ; CHECK:       catchpad []
1281 ; CHECK:           to label %[[RIGHT_CATCH:.+]] unwind label %[[RIGHT_END:.+]]
1282 ; CHECK:     [[RIGHT_CATCH]]:
1283 ; CHECK:       invoke void @f()
1284 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
1285 ; CHECK:     [[RIGHT_END]]:
1286 ; CHECK:       catchendpad unwind to caller
1287 ; CHECK:     [[SHARED_CONT_RIGHT]]:
1288 ; CHECK:       unreachable
1289 ; CHECK:     [[SHARED_CONT_LEFT]]:
1290 ; CHECK:       unreachable
1291 ; CHECK:     [[INNER_RIGHT]]:
1292 ; CHECK:       [[I_RIGHT:\%.+]] = catchpad []
1293 ; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_SIBLING_RIGHT:.+]]
1294 ; CHECK:     [[INNER_LEFT]]:
1295 ; CHECK:       [[I_LEFT:\%.+]] = catchpad []
1296 ; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_SIBLING_LEFT:.+]]
1297 ; CHECK:     [[INNER_CATCH_RIGHT]]:
1298 ; CHECK:       call void @h(i32 0)
1299 ; CHECK:       unreachable
1300 ; CHECK:     [[INNER_CATCH_LEFT]]:
1301 ; CHECK:       call void @h(i32 0)
1302 ; CHECK:       unreachable
1303 ; CHECK:     [[INNER_SIBLING_RIGHT]]:
1304 ; CHECK:       [[IS_RIGHT:\%.+]] = catchpad []
1305 ; CHECK:           to label %[[INNER_SIBLING_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
1306 ; CHECK:     [[INNER_SIBLING_LEFT]]:
1307 ; CHECK:       [[IS_LEFT:\%.+]] = catchpad []
1308 ; CHECK:           to label %[[INNER_SIBLING_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
1309 ; CHECK:     [[INNER_SIBLING_CATCH_RIGHT]]:
1310 ; CHECK:       invoke void @f()
1311 ; CHECK:         to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[INNER_END_RIGHT]]
1312 ; CHECK:     [[INNER_SIBLING_CATCH_LEFT]]:
1313 ; CHECK:       invoke void @f()
1314 ; CHECK:         to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_END_LEFT]]
1315 ; CHECK:     [[INNER_END_LEFT]]:
1316 ; CHECK:       catchendpad unwind to caller
1317 ; CHECK:     [[INNER_END_RIGHT]]:
1318 ; CHECK:       catchendpad unwind label %[[RIGHT_END]]
1319
1320
1321 define void @test18() personality i32 (...)* @__CxxFrameHandler3 {
1322 entry:
1323   invoke void @f()
1324     to label %invoke.cont unwind label %left
1325 invoke.cont:
1326   invoke void @f()
1327     to label %exit unwind label %right
1328 left:
1329   %l = cleanuppad []
1330   br label %shared
1331 right:
1332   catchpad []
1333     to label %right.catch unwind label %right.end
1334 right.catch:
1335   br label %shared
1336 right.end:
1337   catchendpad unwind to caller
1338 shared:
1339   invoke void @f()
1340     to label %unreachable unwind label %inner
1341 unreachable:
1342   unreachable
1343 inner:
1344   %i = catchpad []
1345     to label %inner.catch unwind label %inner.sibling
1346 inner.catch:
1347   invoke void @f()
1348     to label %unreachable unwind label %inner.end
1349 inner.sibling:
1350   %is = catchpad []
1351     to label %inner.sibling.catch unwind label %inner.end
1352 inner.sibling.catch:
1353   call void @h(i32 0)
1354   unreachable
1355 inner.end:
1356   catchendpad unwind label %right.end
1357 exit:
1358   ret void
1359 }
1360 ; This is like test17 except that the inner invoke is moved from the
1361 ; %inner.sibling funclet to %inner so that it is unwinding to a
1362 ; catchendpad block that has not yet been cloned.  The unwind destination
1363 ; of the invoke should still be updated to reach the correct copy of
1364 ; %inner.end for the path by which it is reached.
1365 ; CHECK-LABEL: define void @test18(
1366 ; CHECK:     left:
1367 ; CHECK:       %l = cleanuppad []
1368 ; CHECK:       invoke void @f()
1369 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
1370 ; CHECK:     right:
1371 ; CHECK:       catchpad []
1372 ; CHECK:           to label %[[RIGHT_CATCH:.+]] unwind label %[[RIGHT_END:.+]]
1373 ; CHECK:     [[RIGHT_CATCH]]:
1374 ; CHECK:       invoke void @f()
1375 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
1376 ; CHECK:     [[RIGHT_END]]:
1377 ; CHECK:       catchendpad unwind to caller
1378 ; CHECK:     [[SHARED_CONT_RIGHT]]:
1379 ; CHECK:       unreachable
1380 ; CHECK:     [[SHARED_CONT_LEFT]]:
1381 ; CHECK:       unreachable
1382 ; CHECK:     [[INNER_RIGHT]]:
1383 ; CHECK:       [[I_RIGHT:\%.+]] = catchpad []
1384 ; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_SIBLING_RIGHT:.+]]
1385 ; CHECK:     [[INNER_LEFT]]:
1386 ; CHECK:       [[I_LEFT:\%.+]] = catchpad []
1387 ; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_SIBLING_LEFT:.+]]
1388 ; CHECK:     [[INNER_CATCH_RIGHT]]:
1389 ; CHECK:       invoke void @f()
1390 ; CHECK:         to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
1391 ; CHECK:     [[INNER_CATCH_LEFT]]:
1392 ; CHECK:       invoke void @f()
1393 ; CHECK:         to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
1394 ; CHECK:     [[INNER_SIBLING_RIGHT]]:
1395 ; CHECK:       [[IS_RIGHT:\%.+]] = catchpad []
1396 ; CHECK:           to label %[[INNER_SIBLING_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT]]
1397 ; CHECK:     [[INNER_SIBLING_LEFT]]:
1398 ; CHECK:       [[IS_LEFT:\%.+]] = catchpad []
1399 ; CHECK:           to label %[[INNER_SIBLING_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT]]
1400 ; CHECK:     [[INNER_SIBLING_CATCH_RIGHT]]:
1401 ; CHECK:       call void @h(i32 0)
1402 ; CHECK:       unreachable
1403 ; CHECK:     [[INNER_SIBLING_CATCH_LEFT]]:
1404 ; CHECK:       call void @h(i32 0)
1405 ; CHECK:       unreachable
1406 ; CHECK:     [[INNER_END_LEFT]]:
1407 ; CHECK:       catchendpad unwind to caller
1408 ; CHECK:     [[INNER_END_RIGHT]]:
1409 ; CHECK:       catchendpad unwind label %[[RIGHT_END]]
1410
1411
1412 define void @test19() personality i32 (...)* @__CxxFrameHandler3 {
1413 entry:
1414   invoke void @f()
1415     to label %invoke.cont unwind label %left
1416 invoke.cont:
1417   invoke void @f()
1418     to label %exit unwind label %right
1419 left:
1420   %l = cleanuppad []
1421   br label %shared
1422 right:
1423   catchpad []
1424     to label %right.catch unwind label %right.end
1425 right.catch:
1426   br label %shared
1427 right.end:
1428   catchendpad unwind to caller
1429 shared:
1430   invoke void @f()
1431     to label %unreachable unwind label %inner
1432 unreachable:
1433   unreachable
1434 inner:
1435   %i = cleanuppad []
1436   invoke void @f()
1437     to label %unreachable unwind label %inner.end
1438 inner.end:
1439   cleanupendpad %i unwind label %right.end
1440 exit:
1441   ret void
1442 }
1443 ; This case tests the scenario where an invoke in a funclet with multiple
1444 ; parents unwinds to a cleanup end pad for the funclet.  The unwind destination
1445 ; for the invoke should map to the correct copy of the cleanup end pad block.
1446 ; CHECK-LABEL: define void @test19(
1447 ; CHECK:     left:
1448 ; CHECK:       %l = cleanuppad []
1449 ; CHECK:       invoke void @f()
1450 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
1451 ; CHECK:     right:
1452 ; CHECK:       catchpad []
1453 ; CHECK:           to label %[[RIGHT_CATCH:.+]] unwind label %[[RIGHT_END:.+]]
1454 ; CHECK:     [[RIGHT_CATCH]]:
1455 ; CHECK:       invoke void @f()
1456 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
1457 ; CHECK:     [[RIGHT_END]]:
1458 ; CHECK:       catchendpad unwind to caller
1459 ; CHECK:     [[SHARED_CONT_RIGHT]]:
1460 ; CHECK:       unreachable
1461 ; CHECK:     [[SHARED_CONT_LEFT]]:
1462 ; CHECK:       unreachable
1463 ; CHECK:     [[INNER_RIGHT]]:
1464 ; CHECK:       [[I_RIGHT:\%.+]] = cleanuppad []
1465 ; CHECK:       invoke void @f()
1466 ; CHECK:         to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
1467 ; CHECK:     [[INNER_LEFT]]:
1468 ; CHECK:       [[I_LEFT:\%.+]] = cleanuppad []
1469 ; CHECK:       invoke void @f()
1470 ; CHECK:         to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
1471 ; CHECK:     [[INNER_END_RIGHT]]:
1472 ; CHECK:       cleanupendpad [[I_RIGHT]] unwind label %[[RIGHT_END]]
1473 ; CHECK:     [[INNER_END_LEFT]]:
1474 ; CHECK:       cleanupendpad [[I_LEFT]] unwind to caller
1475
1476 define void @test20() personality i32 (...)* @__CxxFrameHandler3 {
1477 entry:
1478   invoke void @f()
1479     to label %invoke.cont unwind label %left
1480 invoke.cont:
1481   invoke void @f()
1482     to label %exit unwind label %right
1483 left:
1484   %l = cleanuppad []
1485   br label %shared
1486 right:
1487   catchpad []
1488     to label %right.catch unwind label %right.end
1489 right.catch:
1490   br label %shared
1491 right.end:
1492   catchendpad unwind to caller
1493 shared:
1494   invoke void @f()
1495     to label %unreachable unwind label %inner
1496 unreachable:
1497   unreachable
1498 inner:
1499   %i = cleanuppad []
1500   invoke void @f()
1501     to label %unreachable unwind label %inner.cleanup
1502 inner.cleanup:
1503   cleanuppad []
1504   call void @f()
1505   unreachable
1506 exit:
1507   ret void
1508 }
1509 ; This tests the case where a funclet with multiple parents contains an invoke
1510 ; instruction that unwinds to a child funclet.  Here %left and %right are both
1511 ; parents of %inner.  Initially %inner is the only parent of %inner.cleanup but
1512 ; after %inner is cloned, %inner.cleanup has multiple parents and so it must
1513 ; also be cloned.
1514 ; CHECK-LABEL: define void @test20(
1515 ; CHECK:     left:
1516 ; CHECK:       %l = cleanuppad []
1517 ; CHECK:       invoke void @f()
1518 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
1519 ; CHECK:     right:
1520 ; CHECK:       catchpad []
1521 ; CHECK:           to label %[[RIGHT_CATCH:.+]] unwind label %[[RIGHT_END:.+]]
1522 ; CHECK:     [[RIGHT_CATCH]]:
1523 ; CHECK:       invoke void @f()
1524 ; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
1525 ; CHECK:     [[RIGHT_END]]:
1526 ; CHECK:       catchendpad unwind to caller
1527 ; CHECK:     [[SHARED_CONT_RIGHT]]:
1528 ; CHECK:       unreachable
1529 ; CHECK:     [[SHARED_CONT_LEFT]]:
1530 ; CHECK:       unreachable
1531 ; CHECK:     [[INNER_RIGHT]]:
1532 ; CHECK:       [[I_RIGHT:\%.+]] = cleanuppad []
1533 ; CHECK:       invoke void @f()
1534 ; CHECK:         to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[INNER_CLEANUP_RIGHT:.+]]
1535 ; CHECK:     [[INNER_LEFT]]:
1536 ; CHECK:       [[I_LEFT:\%.+]] = cleanuppad []
1537 ; CHECK:       invoke void @f()
1538 ; CHECK:         to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_CLEANUP_LEFT:.+]]
1539 ; CHECK:     [[INNER_CLEANUP_RIGHT]]:
1540 ; CHECK:       cleanuppad []
1541 ; CHECK:       call void @f()
1542 ; CHECK:       unreachable
1543 ; CHECK:     [[INNER_CLEANUP_LEFT]]:
1544 ; CHECK:       cleanuppad []
1545 ; CHECK:       call void @f()
1546 ; CHECK:       unreachable
1547
1548