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