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