test/CodeGen/WinEH/wineh-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
  11 define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
  12 entry:
  13   ; %x def colors: {entry} subset of use colors; must spill
  14   %x = call i32 @g()
  15   invoke void @f()
  16     to label %noreturn unwind label %catch
  17 catch:
  18   catchpad []
  19     to label %noreturn unwind label %endcatch
  20 noreturn:
  21   ; %x use colors: {entry, cleanup}
  22   call void @h(i32 %x)
  23   unreachable
  24 endcatch:
  25   catchendpad unwind to caller
  26 }
  27 ; Need two copies of the call to @h, one under entry and one under catch.
  28 ; Currently we generate a load for each, though we shouldn't need one
  29 ; for the use in entry's copy.
  30 ; CHECK-LABEL: define void @test1(
  31 ; CHECK: entry:
  32 ; CHECK:   %x = call i32 @g()
  33 ; CHECK:   invoke void @f()
  34 ; CHECK:     to label %[[EntryCopy:[^ ]+]] unwind label %catch
  35 ; CHECK: catch:
  36 ; CHECK:   catchpad []
  37 ; CHECK-NEXT: to label %[[CatchCopy:[^ ]+]] unwind
  38 ; CHECK: [[CatchCopy]]:
  39 ; CHECK:   call void @h(i32 %x)
  40 ; CHECK: [[EntryCopy]]:
  41 ; CHECK:   call void @h(i32 %x)
  42
  43
  44 define void @test2() personality i32 (...)* @__CxxFrameHandler3 {
  45 entry:
  46   invoke void @f()
  47     to label %exit unwind label %cleanup
  48 cleanup:
  49   cleanuppad []
  50   br label %exit
  51 exit:
  52   call void @f()
  53   ret void
  54 }
  55 ; Need two copies of %exit's call to @f -- the subsequent ret is only
  56 ; valid when coming from %entry, but on the path from %cleanup, this
  57 ; might be a valid call to @f which might dynamically not return.
  58 ; CHECK-LABEL: define void @test2(
  59 ; CHECK: entry:
  60 ; CHECK:   invoke void @f()
  61 ; CHECK:     to label %[[exit:[^ ]+]] unwind label %cleanup
  62 ; CHECK: cleanup:
  63 ; CHECK:   cleanuppad []
  64 ; CHECK:   call void @f()
  65 ; CHECK-NEXT: unreachable
  66 ; CHECK: [[exit]]:
  67 ; CHECK:   call void @f()
  68 ; CHECK-NEXT: ret void
  69
  70
  71 define void @test3() personality i32 (...)* @__CxxFrameHandler3 {
  72 entry:
  73   invoke void @f()
  74     to label %invoke.cont unwind label %catch
  75 invoke.cont:
  76   invoke void @f()
  77     to label %exit unwind label %cleanup
  78 catch:
  79   catchpad [] to label %shared unwind label %endcatch
  80 endcatch:
  81   catchendpad unwind to caller
  82 cleanup:
  83   cleanuppad []
  84   br label %shared
  85 shared:
  86   call void @f()
  87   br label %exit
  88 exit:
  89   ret void
  90 }
  91 ; Need two copies of %shared's call to @f (similar to @test2 but
  92 ; the two regions here are siblings, not parent-child).
  93 ; CHECK-LABEL: define void @test3(
  94 ; CHECK:   invoke void @f()
  95 ; CHECK:   invoke void @f()
  96 ; CHECK:     to label %[[exit:[^ ]+]] unwind
  97 ; CHECK: catch:
  98 ; CHECK:   catchpad []
  99 ; CHECK-NEXT: to label %[[shared:[^ ]+]] unwind
 100 ; CHECK: cleanup:
 101 ; CHECK:   cleanuppad []
 102 ; CHECK:   call void @f()
 103 ; CHECK-NEXT: unreachable
 104 ; CHECK: [[shared]]:
 105 ; CHECK:   call void @f()
 106 ; CHECK-NEXT: unreachable
 107 ; CHECK: [[exit]]:
 108 ; CHECK:   ret void
 109
 110
 111 define void @test4() personality i32 (...)* @__CxxFrameHandler3 {
 112 entry:
 113   invoke void @f()
 114     to label %shared unwind label %catch
 115 catch:
 116   catchpad []
 117     to label %shared unwind label %endcatch
 118 endcatch:
 119   catchendpad unwind to caller
 120 shared:
 121   %x = call i32 @g()
 122   %i = call i32 @g()
 123   %zero.trip = icmp eq i32 %i, 0
 124   br i1 %zero.trip, label %exit, label %loop
 125 loop:
 126   %i.loop = phi i32 [ %i, %shared ], [ %i.dec, %loop.tail ]
 127   %b = call i1 @b()
 128   br i1 %b, label %left, label %right
 129 left:
 130   %y = call i32 @g()
 131   br label %loop.tail
 132 right:
 133   call void @h(i32 %x)
 134   br label %loop.tail
 135 loop.tail:
 136   %i.dec = sub i32 %i.loop, 1
 137   %done = icmp eq i32 %i.dec, 0
 138   br i1 %done, label %exit, label %loop
 139 exit:
 140   call void @h(i32 %x)
 141   unreachable
 142 }
 143 ; Make sure we can clone regions that have internal control
 144 ; flow and SSA values.  Here we need two copies of everything
 145 ; from %shared to %exit.
 146 ; CHECK-LABEL: define void @test4(
 147 ; CHECK:  entry:
 148 ; CHECK:    to label %[[shared_E:[^ ]+]] unwind label %catch
 149 ; CHECK:  catch:
 150 ; CHECK:    to label %[[shared_C:[^ ]+]] unwind label %endcatch
 151 ; CHECK:  [[shared_C]]:
 152 ; CHECK:    [[x_C:%[^ ]+]] = call i32 @g()
 153 ; CHECK:    [[i_C:%[^ ]+]] = call i32 @g()
 154 ; CHECK:    [[zt_C:%[^ ]+]] = icmp eq i32 [[i_C]], 0
 155 ; CHECK:    br i1 [[zt_C]], label %[[exit_C:[^ ]+]], label %[[loop_C:[^ ]+]]
 156 ; CHECK:  [[shared_E]]:
 157 ; CHECK:    [[x_E:%[^ ]+]] = call i32 @g()
 158 ; CHECK:    [[i_E:%[^ ]+]] = call i32 @g()
 159 ; CHECK:    [[zt_E:%[^ ]+]] = icmp eq i32 [[i_E]], 0
 160 ; CHECK:    br i1 [[zt_E]], label %[[exit_E:[^ ]+]], label %[[loop_E:[^ ]+]]
 161 ; CHECK:  [[loop_C]]:
 162 ; CHECK:    [[iloop_C:%[^ ]+]] = phi i32 [ [[i_C]], %[[shared_C]] ], [ [[idec_C:%[^ ]+]], %[[looptail_C:[^ ]+]] ]
 163 ; CHECK:    [[b_C:%[^ ]+]] = call i1 @b()
 164 ; CHECK:    br i1 [[b_C]], label %[[left_C:[^ ]+]], label %[[right_C:[^ ]+]]
 165 ; CHECK:  [[loop_E]]:
 166 ; CHECK:    [[iloop_E:%[^ ]+]] = phi i32 [ [[i_E]], %[[shared_E]] ], [ [[idec_E:%[^ ]+]], %[[looptail_E:[^ ]+]] ]
 167 ; CHECK:    [[b_E:%[^ ]+]] = call i1 @b()
 168 ; CHECK:    br i1 [[b_E]], label %[[left_E:[^ ]+]], label %[[right_E:[^ ]+]]
 169 ; CHECK:  [[left_C]]:
 170 ; CHECK:    [[y_C:%[^ ]+]] = call i32 @g()
 171 ; CHECK:    br label %[[looptail_C]]
 172 ; CHECK:  [[left_E]]:
 173 ; CHECK:    [[y_E:%[^ ]+]] = call i32 @g()
 174 ; CHECK:    br label %[[looptail_E]]
 175 ; CHECK:  [[right_C]]:
 176 ; CHECK:    call void @h(i32 [[x_C]])
 177 ; CHECK:    br label %[[looptail_C]]
 178 ; CHECK:  [[right_E]]:
 179 ; CHECK:    call void @h(i32 [[x_E]])
 180 ; CHECK:    br label %[[looptail_E]]
 181 ; CHECK:  [[looptail_C]]:
 182 ; CHECK:    [[idec_C]] = sub i32 [[iloop_C]], 1
 183 ; CHECK:    [[done_C:%[^ ]+]] = icmp eq i32 [[idec_C]], 0
 184 ; CHECK:    br i1 [[done_C]], label %[[exit_C]], label %[[loop_C]]
 185 ; CHECK:  [[looptail_E]]:
 186 ; CHECK:    [[idec_E]] = sub i32 [[iloop_E]], 1
 187 ; CHECK:    [[done_E:%[^ ]+]] = icmp eq i32 [[idec_E]], 0
 188 ; CHECK:    br i1 [[done_E]], label %[[exit_E]], label %[[loop_E]]
 189 ; CHECK:  [[exit_C]]:
 190 ; CHECK:    call void @h(i32 [[x_C]])
 191 ; CHECK:    unreachable
 192 ; CHECK:  [[exit_E]]:
 193 ; CHECK:    call void @h(i32 [[x_E]])
 194 ; CHECK:    unreachable
 195
 196
 197 define void @test5() personality i32 (...)* @__CxxFrameHandler3 {
 198 entry:
 199   invoke void @f()
 200     to label %exit unwind label %outer
 201 outer:
 202   %o = cleanuppad []
 203   %x = call i32 @g()
 204   invoke void @f()
 205     to label %outer.ret unwind label %inner
 206 inner:
 207   %i = catchpad []
 208     to label %inner.catch unwind label %inner.endcatch
 209 inner.catch:
 210   catchret %i to label %outer.post-inner
 211 inner.endcatch:
 212   catchendpad unwind to caller
 213 outer.post-inner:
 214   call void @h(i32 %x)
 215   br label %outer.ret
 216 outer.ret:
 217   cleanupret %o unwind to caller
 218 exit:
 219   ret void
 220 }
 221 ; Simple nested case (catch-inside-cleanup).  Nothing needs
 222 ; to be cloned.  The def and use of %x are both in %outer
 223 ; and so don't need to be spilled.
 224 ; CHECK-LABEL: define void @test5(
 225 ; CHECK:      outer:
 226 ; CHECK:        %x = call i32 @g()
 227 ; CHECK-NEXT:   invoke void @f()
 228 ; CHECK-NEXT:     to label %outer.ret unwind label %inner
 229 ; CHECK:      inner:
 230 ; CHECK:          to label %inner.catch unwind label %inner.endcatch
 231 ; CHECK:      inner.catch:
 232 ; CHECK-NEXT:   catchret %i to label %outer.post-inner
 233 ; CHECK:      outer.post-inner:
 234 ; CHECK-NEXT:   call void @h(i32 %x)
 235 ; CHECK-NEXT:   br label %outer.ret
 236
 237
 238 define void @test6() personality i32 (...)* @__CxxFrameHandler3 {
 239 entry:
 240   invoke void @f()
 241     to label %invoke.cont unwind label %left
 242 invoke.cont:
 243   invoke void @f()
 244     to label %exit unwind label %right
 245 left:
 246   cleanuppad []
 247   br label %shared
 248 right:
 249   catchpad []
 250     to label %right.catch unwind label %right.end
 251 right.catch:
 252   br label %shared
 253 right.end:
 254   catchendpad unwind to caller
 255 shared:
 256   %x = call i32 @g()
 257   invoke void @f()
 258     to label %shared.cont unwind label %inner
 259 shared.cont:
 260   unreachable
 261 inner:
 262   %i = cleanuppad []
 263   call void @h(i32 %x)
 264   cleanupret %i unwind label %right.end
 265 exit:
 266   ret void
 267 }
 268 ; %inner is a cleanup which appears both as a child of
 269 ; %left and as a child of %right.  Since statically we
 270 ; need each funclet to have a single parent, we need to
 271 ; clone the entire %inner funclet so we can have one
 272 ; copy under each parent.  The cleanupret in %inner
 273 ; unwinds to the catchendpad for %right, so the copy
 274 ; of %inner under %right should include it; the copy
 275 ; of %inner under %left should instead have an
 276 ; `unreachable` inserted there, but the copy under
 277 ; %left still needs to be created because it's possible
 278 ; the dynamic path enters %left, then enters %inner,
 279 ; then calls @h, and that the call to @h doesn't return.
 280 ; CHECK-LABEL: define void @test6(
 281 ; CHECK:     left:
 282 ; CHECK:       %x.for.left = call i32 @g()
 283 ; CHECK:       invoke void @f()
 284 ; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
 285 ; CHECK:     right:
 286 ; CHECK:       catchpad
 287 ; CHECK:           to label %right.catch unwind label %right.end
 288 ; CHECK:     right.catch:
 289 ; CHECK:       %x = call i32 @g()
 290 ; CHECK:           to label %shared.cont unwind label %[[INNER_RIGHT:.+]]
 291 ; CHECK:     right.end:
 292 ; CHECK:       catchendpad unwind to caller
 293 ; CHECK:     shared.cont:
 294 ; CHECK:       unreachable
 295 ; CHECK:     [[SHARED_CONT_LEFT]]:
 296 ; CHECK:       unreachable
 297 ; CHECK:     [[INNER_RIGHT]]:
 298 ; CHECK:       [[I_R:\%.+]] = cleanuppad []
 299 ; CHECK:       call void @h(i32 %x)
 300 ; CHECK:       cleanupret [[I_R]] unwind label %right.end
 301 ; CHECK:     [[INNER_LEFT]]:
 302 ; CHECK:       [[I_L:\%.+]] = cleanuppad []
 303 ; CHECK:       call void @h(i32 %x.for.left)
 304 ; CHECK:       unreachable
 305
 306
 307 define void @test7() personality i32 (...)* @__CxxFrameHandler3 {
 308 entry:
 309   invoke void @f()
 310     to label %invoke.cont unwind label %left
 311 invoke.cont:
 312   invoke void @f()
 313     to label %unreachable unwind label %right
 314 left:
 315   cleanuppad []
 316   invoke void @f() to label %unreachable unwind label %inner
 317 right:
 318   catchpad []
 319     to label %right.catch unwind label %right.end
 320 right.catch:
 321   invoke void @f() to label %unreachable unwind label %inner
 322 right.end:
 323   catchendpad unwind to caller
 324 inner:
 325   %i = cleanuppad []
 326   %x = call i32 @g()
 327   call void @h(i32 %x)
 328   cleanupret %i unwind label %right.end
 329 unreachable:
 330   unreachable
 331 }
 332 ; Another case of a two-parent child (like @test6), this time
 333 ; with the join at the entry itself instead of following a
 334 ; non-pad join.
 335 ; CHECK-LABEL: define void @test7(
 336 ; CHECK:     invoke.cont:
 337 ; CHECK:           to label %[[UNREACHABLE_ENTRY:.+]] unwind label %right
 338 ; CHECK:     left:
 339 ; CHECK:           to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
 340 ; CHECK:     right:
 341 ; CHECK:           to label %right.catch unwind label %right.end
 342 ; CHECK:     right.catch:
 343 ; CHECK:           to label %unreachable unwind label %[[INNER_RIGHT:.+]]
 344 ; CHECK:     right.end:
 345 ; CHECK:       catchendpad unwind to caller
 346 ; CHECK:     [[INNER_RIGHT]]:
 347 ; CHECK:       [[I_R:\%.+]] = cleanuppad []
 348 ; CHECK:       [[X_R:\%.+]] = call i32 @g()
 349 ; CHECK:       call void @h(i32 [[X_R]])
 350 ; CHECK:       cleanupret [[I_R]] unwind label %right.end
 351 ; CHECK:     [[INNER_LEFT]]:
 352 ; CHECK:       [[I_L:\%.+]] = cleanuppad []
 353 ; CHECK:       [[X_L:\%.+]] = call i32 @g()
 354 ; CHECK:       call void @h(i32 [[X_L]])
 355 ; CHECK:       unreachable
 356 ; CHECK:     unreachable:
 357 ; CHECK:       unreachable
 358 ; CHECK:     [[UNREACHABLE_LEFT]]:
 359 ; CHECK:       unreachable
 360 ; CHECK:     [[UNREACHABLE_ENTRY]]:
 361 ; CHECK:       unreachable
 362
 363
 364 define void @test8() personality i32 (...)* @__CxxFrameHandler3 {
 365 entry:
 366   invoke void @f()
 367     to label %invoke.cont unwind label %left
 368 invoke.cont:
 369   invoke void @f()
 370     to label %unreachable unwind label %right
 371 left:
 372   cleanuppad []
 373   br label %shared
 374 right:
 375   catchpad []
 376     to label %right.catch unwind label %right.end
 377 right.catch:
 378   br label %shared
 379 right.end:
 380   catchendpad unwind to caller
 381 shared:
 382   invoke void @f()
 383     to label %unreachable unwind label %inner
 384 inner:
 385   cleanuppad []
 386   invoke void @f()
 387     to label %unreachable unwind label %inner.child
 388 inner.child:
 389   cleanuppad []
 390   %x = call i32 @g()
 391   call void @h(i32 %x)
 392   unreachable
 393 unreachable:
 394   unreachable
 395 }
 396 ; %inner is a two-parent child which itself has a child; need
 397 ; to make two copies of both the %inner and %inner.child.
 398 ; CHECK-LABEL: define void @test8(
 399 ; CHECK:     invoke.cont:
 400 ; CHECK:               to label %[[UNREACHABLE_ENTRY:.+]] unwind label %right
 401 ; CHECK:     left:
 402 ; CHECK:               to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
 403 ; CHECK:     right:
 404 ; CHECK:               to label %right.catch unwind label %right.end
 405 ; CHECK:     right.catch:
 406 ; CHECK:               to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
 407 ; CHECK:     right.end:
 408 ; CHECK:       catchendpad unwind to caller
 409 ; CHECK:     [[INNER_RIGHT]]:
 410 ; CHECK:               to label %[[UNREACHABLE_INNER_RIGHT:.+]] unwind label %[[INNER_CHILD_RIGHT:.+]]
 411 ; CHECK:     [[INNER_LEFT]]:
 412 ; CHECK:               to label %[[UNREACHABLE_INNER_LEFT:.+]] unwind label %[[INNER_CHILD_LEFT:.+]]
 413 ; CHECK:     [[INNER_CHILD_RIGHT]]:
 414 ; CHECK:       [[TMP:\%.+]] = cleanuppad []
 415 ; CHECK:       [[X:\%.+]] = call i32 @g()
 416 ; CHECK:       call void @h(i32 [[X]])
 417 ; CHECK:       unreachable
 418 ; CHECK:     [[INNER_CHILD_LEFT]]:
 419 ; CHECK:       [[TMP:\%.+]] = cleanuppad []
 420 ; CHECK:       [[X:\%.+]] = call i32 @g()
 421 ; CHECK:       call void @h(i32 [[X]])
 422 ; CHECK:       unreachable
 423 ; CHECK:     [[UNREACHABLE_INNER_RIGHT]]:
 424 ; CHECK:       unreachable
 425 ; CHECK:     [[UNREACHABLE_INNER_LEFT]]:
 426 ; CHECK:       unreachable
 427 ; CHECK:     [[UNREACHABLE_RIGHT]]:
 428 ; CHECK:       unreachable
 429 ; CHECK:     [[UNREACHABLE_LEFT]]:
 430 ; CHECK:       unreachable
 431 ; CHECK:     [[UNREACHABLE_ENTRY]]:
 432 ; CHECK:       unreachable
 433
 434
 435 define void @test9() personality i32 (...)* @__CxxFrameHandler3 {
 436 entry:
 437   invoke void @f()
 438     to label %invoke.cont unwind label %left
 439 invoke.cont:
 440   invoke void @f()
 441     to label %unreachable unwind label %right
 442 left:
 443   cleanuppad []
 444   call void @h(i32 1)
 445   invoke void @f()
 446     to label %unreachable unwind label %right
 447 right:
 448   cleanuppad []
 449   call void @h(i32 2)
 450   invoke void @f()
 451     to label %unreachable unwind label %left
 452 unreachable:
 453   unreachable
 454 }
 455 ; This is an irreducible loop with two funclets that enter each other;
 456 ; need to make two copies of each funclet (one a child of root, the
 457 ; other a child of the opposite funclet), but also make sure not to
 458 ; clone self-descendants (if we tried to do that we'd need to make an
 459 ; infinite number of them).  Presumably if optimizations ever generated
 460 ; such a thing it would mean that one of the two cleanups was originally
 461 ; the parent of the other, but that we'd somehow lost track in the CFG
 462 ; of which was which along the way; generating each possibility lets
 463 ; whichever case was correct execute correctly.
 464 ; CHECK-LABEL: define void @test9(
 465 ; CHECK:     entry:
 466 ; CHECK:               to label %invoke.cont unwind label %[[LEFT:.+]]
 467 ; CHECK:     invoke.cont:
 468 ; CHECK:               to label %[[UNREACHABLE_ENTRY:.+]] unwind label %[[RIGHT:.+]]
 469 ; CHECK:     [[LEFT_FROM_RIGHT:.+]]:
 470 ; CHECK:       call void @h(i32 1)
 471 ; CHECK:       call void @f()
 472 ; CHECK:       unreachable
 473 ; CHECK:     [[LEFT]]:
 474 ; CHECK:       call void @h(i32 1)
 475 ; CHECK:       invoke void @f()
 476 ; CHECK:               to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[RIGHT_FROM_LEFT:.+]]
 477 ; CHECK:     [[RIGHT]]:
 478 ; CHECK:       call void @h(i32 2)
 479 ; CHECK:       invoke void @f()
 480 ; CHECK:               to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[LEFT_FROM_RIGHT]]
 481 ; CHECK:     [[RIGHT_FROM_LEFT]]:
 482 ; CHECK:       call void @h(i32 2)
 483 ; CHECK:       call void @f()
 484 ; CHECK:       unreachable
 485 ; CHECK:     [[UNREACHABLE_RIGHT]]:
 486 ; CHECK:       unreachable
 487 ; CHECK:     [[UNREACHABLE_LEFT]]:
 488 ; CHECK:       unreachable
 489 ; CHECK:     [[UNREACHABLE_ENTRY]]:
 490 ; CHECK:       unreachable
 491
 492
 493 define void @test10() personality i32 (...)* @__CxxFrameHandler3 {
 494 entry:
 495   invoke void @f()
 496     to label %unreachable unwind label %inner
 497 inner:
 498   %cleanup = cleanuppad []
 499   ; make sure we don't overlook this cleanupret and try to process
 500   ; successor %outer as a child of inner.
 501   cleanupret %cleanup unwind label %outer
 502 outer:
 503   %catch = catchpad [] to label %catch.body unwind label %endpad
 504 catch.body:
 505   catchret %catch to label %exit
 506 endpad:
 507   catchendpad unwind to caller
 508 exit:
 509   ret void
 510 unreachable:
 511   unreachable
 512 }
 513 ; CHECK-LABEL: define void @test10(
 514 ; CHECK-NEXT: entry:
 515 ; CHECK-NEXT:   invoke
 516 ; CHECK-NEXT:     to label %unreachable unwind label %inner
 517 ; CHECK:      inner:
 518 ; CHECK-NEXT:   %cleanup = cleanuppad
 519 ; CHECK-NEXT:   cleanupret %cleanup unwind label %outer
 520 ; CHECK:      outer:
 521 ; CHECK-NEXT:   %catch = catchpad []
 522 ; CHECK-NEXT:         to label %catch.body unwind label %endpad
 523 ; CHECK:      catch.body:
 524 ; CHECK-NEXT:   catchret %catch to label %exit
 525 ; CHECK:      endpad:
 526 ; CHECK-NEXT:   catchendpad unwind to caller
 527 ; CHECK:      exit:
 528 ; CHECK-NEXT:   ret void
 529
 530 define void @test11() personality i32 (...)* @__CxxFrameHandler3 {
 531 entry:
 532   invoke void @f()
 533     to label %exit unwind label %cleanup.outer
 534 cleanup.outer:
 535   %outer = cleanuppad []
 536   invoke void @f()
 537     to label %outer.cont unwind label %cleanup.inner
 538 outer.cont:
 539   br label %merge
 540 cleanup.inner:
 541   %inner = cleanuppad []
 542   br label %merge
 543 merge:
 544   invoke void @f()
 545     to label %unreachable unwind label %merge.end
 546 unreachable:
 547   unreachable
 548 merge.end:
 549   cleanupendpad %outer unwind to caller
 550 exit:
 551   ret void
 552 }
 553 ; merge.end will get cloned for outer and inner, but is implausible
 554 ; from inner, so the invoke @f() in inner's copy of merge should be
 555 ; rewritten to call @f()
 556 ; CHECK-LABEL: define void @test11()
 557 ; CHECK:      %inner = cleanuppad []
 558 ; CHECK-NEXT: call void @f()
 559 ; CHECK-NEXT: unreachable
 560
 561 define void @test12() personality i32 (...)* @__CxxFrameHandler3 !dbg !5 {
 562 entry:
 563   invoke void @f()
 564     to label %cont unwind label %left, !dbg !8
 565 cont:
 566   invoke void @f()
 567     to label %exit unwind label %right
 568 left:
 569   cleanuppad []
 570   br label %join
 571 right:
 572   cleanuppad []
 573   br label %join
 574 join:
 575   ; This call will get cloned; make sure we can handle cloning
 576   ; instructions with debug metadata attached.
 577   call void @f(), !dbg !9
 578   unreachable
 579 exit:
 580   ret void
 581 }
 582
 583 ; CHECK-LABEL: define void @test13()
 584 ; CHECK: ret void
 585 define void @test13() personality i32 (...)* @__CxxFrameHandler3 {
 586 entry:
 587   ret void
 588
 589 unreachable:
 590   cleanuppad []
 591   unreachable
 592 }
 593
 594 define void @test14() personality i32 (...)* @__CxxFrameHandler3 {
 595 entry:
 596   invoke void @f()
 597     to label %exit unwind label %catch1.pad
 598 catch1.pad:
 599   %catch1 = catchpad [i32 1]
 600     to label %catch1.body unwind label %catch2.pad
 601 catch1.body:
 602   invoke void @h(i32 1)
 603     to label %catch1.body2 unwind label %catch.end
 604 catch1.body2:
 605   invoke void @f()
 606     to label %catch1.ret unwind label %cleanup1.pad
 607 cleanup1.pad:
 608   %cleanup1 = cleanuppad []
 609   call void @f()
 610   cleanupret %cleanup1 unwind label %catch.end
 611 catch1.ret:
 612   catchret %catch1 to label %exit
 613 catch2.pad:
 614   %catch2 = catchpad [i32 2]
 615     to label %catch2.body unwind label %catch.end
 616 catch2.body:
 617   invoke void @h(i32 2)
 618     to label %catch2.body2 unwind label %catch.end
 619 catch2.body2:
 620   invoke void @f()
 621     to label %catch2.ret unwind label %cleanup2.pad
 622 cleanup2.pad:
 623   %cleanup2 = cleanuppad []
 624   call void @f()
 625   cleanupret %cleanup2 unwind label %catch.end
 626 catch2.ret:
 627   catchret %catch2 to label %exit
 628 catch.end:
 629   catchendpad unwind to caller
 630 exit:
 631   ret void
 632 }
 633 ; Make sure we don't clone the catchendpad even though the
 634 ; cleanupendpads targeting it would naively imply that it
 635 ; should get their respective parent colors (catch1 and catch2),
 636 ; as well as its properly getting the root function color.  The
 637 ; references from the invokes ensure that if we did make clones
 638 ; for each catch, they'd be reachable, as those invokes would get
 639 ; rewritten
 640 ; CHECK-LABEL: define void @test14()
 641 ; CHECK-NOT:  catchendpad
 642 ; CHECK:      invoke void @h(i32 1)
 643 ; CHECK-NEXT:   unwind label %catch.end
 644 ; CHECK-NOT:  catchendpad
 645 ; CHECK:      invoke void @h(i32 2)
 646 ; CHECK-NEXT:   unwind label %catch.end
 647 ; CHECK-NOT:   catchendpad
 648 ; CHECK:     catch.end:
 649 ; CHECK-NEXT:  catchendpad
 650 ; CHECK-NOT:   catchendpad
 651
 652 ;; Debug info (from test12)
 653
 654 ; Make sure the DISubprogram doesn't get cloned
 655 ; CHECK-LABEL: !llvm.module.flags
 656 ; CHECK-NOT: !DISubprogram
 657 ; CHECK: !{{[0-9]+}} = distinct !DISubprogram(name: "test12"
 658 ; CHECK-NOT: !DISubprogram
 659 !llvm.module.flags = !{!0}
 660 !llvm.dbg.cu = !{!1}
 661
 662 !0 = !{i32 2, !"Debug Info Version", i32 3}
 663 !1 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "compiler", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !3, subprograms: !4)
 664 !2 = !DIFile(filename: "test.cpp", directory: ".")
 665 !3 = !{}
 666 !4 = !{!5}
 667 !5 = distinct !DISubprogram(name: "test12", scope: !2, file: !2, type: !6, isLocal: false, isDefinition: true, scopeLine: 3, flags: DIFlagPrototyped, isOptimized: true, variables: !3)
 668 !6 = !DISubroutineType(types: !7)
 669 !7 = !{null}
 670 !8 = !DILocation(line: 1, scope: !5)
 671 !9 = !DILocation(line: 2, scope: !5)