677 lines · plain
1; RUN: opt -passes=inline -S %s | FileCheck %s2; RUN: opt -passes='cgscc(inline)' -S %s | FileCheck %s3 4declare void @g()5 6 7;;; Test with a call in a funclet that needs to remain a call8;;; when inlined because the funclet doesn't unwind to caller.9;;; CHECK-LABEL: define void @test1(10define void @test1() personality ptr @g {11entry:12; CHECK-NEXT: entry:13 invoke void @test1_inlinee()14 to label %exit unwind label %cleanup15cleanup:16 %pad = cleanuppad within none []17 call void @g() [ "funclet"(token %pad) ]18 cleanupret from %pad unwind to caller19exit:20 ret void21}22 23define void @test1_inlinee() alwaysinline personality ptr @g {24entry:25 invoke void @g()26 to label %exit unwind label %cleanup.inner27; CHECK-NEXT: invoke void @g()28; CHECK-NEXT: unwind label %[[cleanup_inner:.+]]29 30cleanup.inner:31 %pad.inner = cleanuppad within none []32 call void @g() [ "funclet"(token %pad.inner) ]33 cleanupret from %pad.inner unwind label %cleanup.outer34; CHECK: [[cleanup_inner]]:35; The call here needs to remain a call becuase pad.inner has a cleanupret36; that stays within the inlinee.37; CHECK-NEXT: %[[pad_inner:[^ ]+]] = cleanuppad within none38; CHECK-NEXT: call void @g() [ "funclet"(token %[[pad_inner]]) ]39; CHECK-NEXT: cleanupret from %[[pad_inner]] unwind label %[[cleanup_outer:.+]]40 41cleanup.outer:42 %pad.outer = cleanuppad within none []43 call void @g() [ "funclet"(token %pad.outer) ]44 cleanupret from %pad.outer unwind to caller45; CHECK: [[cleanup_outer]]:46; The call and cleanupret here need to be redirected to caller cleanup47; CHECK-NEXT: %[[pad_outer:[^ ]+]] = cleanuppad within none48; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[pad_outer]]) ]49; CHECK-NEXT: unwind label %cleanup50; CHECK: cleanupret from %[[pad_outer]] unwind label %cleanup{{$}}51 52exit:53 ret void54}55 56 57 58;;; Test with an "unwind to caller" catchswitch in a parent funclet59;;; that needs to remain "unwind to caller" because the parent60;;; doesn't unwind to caller.61;;; CHECK-LABEL: define void @test2(62define void @test2() personality ptr @g {63entry:64; CHECK-NEXT: entry:65 invoke void @test2_inlinee()66 to label %exit unwind label %cleanup67cleanup:68 %pad = cleanuppad within none []69 call void @g() [ "funclet"(token %pad) ]70 cleanupret from %pad unwind to caller71exit:72 ret void73}74 75define void @test2_inlinee() alwaysinline personality ptr @g {76entry:77 invoke void @g()78 to label %exit unwind label %cleanup179; CHECK-NEXT: invoke void @g()80; CHECK-NEXT: unwind label %[[cleanup1:.+]]81 82cleanup1:83 %outer = cleanuppad within none []84 invoke void @g() [ "funclet"(token %outer) ]85 to label %ret1 unwind label %catchswitch86; CHECK: [[cleanup1]]:87; CHECK-NEXT: %[[outer:[^ ]+]] = cleanuppad within none88; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[outer]]) ]89; CHECK-NEXT: unwind label %[[catchswitch:.+]]90 91catchswitch:92 %cs = catchswitch within %outer [label %catch] unwind to caller93; CHECK: [[catchswitch]]:94; The catchswitch here needs to remain "unwind to caller" since %outer95; has a cleanupret that remains within the inlinee.96; CHECK-NEXT: %[[cs:[^ ]+]] = catchswitch within %[[outer]] [label %[[catch:.+]]] unwind to caller97 98catch:99 %inner = catchpad within %cs []100 call void @g() [ "funclet"(token %inner) ]101 catchret from %inner to label %ret1102; CHECK: [[catch]]:103; The call here needs to remain a call since it too is within %outer104; CHECK: %[[inner:[^ ]+]] = catchpad within %[[cs]]105; CHECK-NEXT: call void @g() [ "funclet"(token %[[inner]]) ]106 107ret1:108 cleanupret from %outer unwind label %cleanup2109; CHECK: cleanupret from %[[outer]] unwind label %[[cleanup2:.+]]110 111cleanup2:112 %later = cleanuppad within none []113 cleanupret from %later unwind to caller114; CHECK: [[cleanup2]]:115; The cleanupret here needs to get redirected to the caller cleanup116; CHECK-NEXT: %[[later:[^ ]+]] = cleanuppad within none117; CHECK-NEXT: cleanupret from %[[later]] unwind label %cleanup{{$}}118 119exit:120 ret void121}122 123 124;;; Test with a call in a cleanup that has no definitive unwind125;;; destination, that must be rewritten to an invoke.126;;; CHECK-LABEL: define void @test3(127define void @test3() personality ptr @g {128entry:129; CHECK-NEXT: entry:130 invoke void @test3_inlinee()131 to label %exit unwind label %cleanup132cleanup:133 %pad = cleanuppad within none []134 call void @g() [ "funclet"(token %pad) ]135 cleanupret from %pad unwind to caller136exit:137 ret void138}139 140define void @test3_inlinee() alwaysinline personality ptr @g {141entry:142 invoke void @g()143 to label %exit unwind label %cleanup144; CHECK-NEXT: invoke void @g()145; CHECK-NEXT: unwind label %[[cleanup:.+]]146 147cleanup:148 %pad = cleanuppad within none []149 call void @g() [ "funclet"(token %pad) ]150 unreachable151; CHECK: [[cleanup]]:152; The call must be rewritten to an invoke targeting the caller cleanup153; because it may well unwind to there.154; CHECK-NEXT: %[[pad:[^ ]+]] = cleanuppad within none155; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[pad]]) ]156; CHECK-NEXT: unwind label %cleanup{{$}}157 158exit:159 ret void160}161 162 163;;; Test with a catchswitch in a cleanup that has no definitive164;;; unwind destination, that must be rewritten to unwind to the165;;; inlined invoke's unwind dest166;;; CHECK-LABEL: define void @test4(167define void @test4() personality ptr @g {168entry:169; CHECK-NEXT: entry:170 invoke void @test4_inlinee()171 to label %exit unwind label %cleanup172cleanup:173 %pad = cleanuppad within none []174 call void @g() [ "funclet"(token %pad) ]175 cleanupret from %pad unwind to caller176exit:177 ret void178}179 180define void @test4_inlinee() alwaysinline personality ptr @g {181entry:182 invoke void @g()183 to label %exit unwind label %cleanup184; CHECK-NEXT: invoke void @g()185; CHECK-NEXT: unwind label %[[cleanup:.+]]186 187cleanup:188 %clean = cleanuppad within none []189 invoke void @g() [ "funclet"(token %clean) ]190 to label %unreachable unwind label %dispatch191; CHECK: [[cleanup]]:192; CHECK-NEXT: %[[clean:[^ ]+]] = cleanuppad within none193; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[clean]]) ]194; CHECK-NEXT: unwind label %[[dispatch:.+]]195 196dispatch:197 %cs = catchswitch within %clean [label %catch] unwind to caller198; CHECK: [[dispatch]]:199; The catchswitch must be rewritten to unwind to %cleanup in the caller200; because it may well unwind to there.201; CHECK-NEXT: %[[cs:[^ ]+]] = catchswitch within %[[clean]] [label %[[catch:.+]]] unwind label %cleanup{{$}}202 203catch:204 catchpad within %cs []205 br label %unreachable206unreachable:207 unreachable208exit:209 ret void210}211 212 213;;; Test with multiple levels of nesting, and unwind dests214;;; that need to be inferred from ancestors, descendants,215;;; and cousins.216;;; CHECK-LABEL: define void @test5(217define void @test5() personality ptr @g {218entry:219; CHECK-NEXT: entry:220 invoke void @test5_inlinee()221 to label %exit unwind label %cleanup222cleanup:223 %pad = cleanuppad within none []224 call void @g() [ "funclet"(token %pad) ]225 cleanupret from %pad unwind to caller226exit:227 ret void228}229 230define void @test5_inlinee() alwaysinline personality ptr @g {231entry:232 invoke void @g()233 to label %cont unwind label %noinfo.root234; CHECK-NEXT: invoke void @g()235; CHECK-NEXT: to label %[[cont:[^ ]+]] unwind label %[[noinfo_root:.+]]236 237noinfo.root:238 %noinfo.root.pad = cleanuppad within none []239 call void @g() [ "funclet"(token %noinfo.root.pad) ]240 invoke void @g() [ "funclet"(token %noinfo.root.pad) ]241 to label %noinfo.root.cont unwind label %noinfo.left242; CHECK: [[noinfo_root]]:243; Nothing under "noinfo.root" has a definitive unwind destination, so244; we must assume all of it may actually unwind, and redirect unwinds245; to the cleanup in the caller.246; CHECK-NEXT: %[[noinfo_root_pad:[^ ]+]] = cleanuppad within none []247; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[noinfo_root_pad]]) ]248; CHECK-NEXT: to label %[[next:[^ ]+]] unwind label %cleanup{{$}}249; CHECK: [[next]]:250; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[noinfo_root_pad]]) ]251; CHECK-NEXT: to label %[[noinfo_root_cont:[^ ]+]] unwind label %[[noinfo_left:.+]]252 253noinfo.left:254 %noinfo.left.pad = cleanuppad within %noinfo.root.pad []255 invoke void @g() [ "funclet"(token %noinfo.left.pad) ]256 to label %unreachable unwind label %noinfo.left.child257; CHECK: [[noinfo_left]]:258; CHECK-NEXT: %[[noinfo_left_pad:[^ ]+]] = cleanuppad within %[[noinfo_root_pad]]259; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[noinfo_left_pad]]) ]260; CHECK-NEXT: unwind label %[[noinfo_left_child:.+]]261 262noinfo.left.child:263 %noinfo.left.child.cs = catchswitch within %noinfo.left.pad [label %noinfo.left.child.catch] unwind to caller264; CHECK: [[noinfo_left_child]]:265; CHECK-NEXT: %[[noinfo_left_child_cs:[^ ]+]] = catchswitch within %[[noinfo_left_pad]] [label %[[noinfo_left_child_catch:[^ ]+]]] unwind label %cleanup{{$}}266 267noinfo.left.child.catch:268 %noinfo.left.child.pad = catchpad within %noinfo.left.child.cs []269 call void @g() [ "funclet"(token %noinfo.left.child.pad) ]270 br label %unreachable271; CHECK: [[noinfo_left_child_catch]]:272; CHECK-NEXT: %[[noinfo_left_child_pad:[^ ]+]] = catchpad within %[[noinfo_left_child_cs]] []273; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[noinfo_left_child_pad]]) ]274; CHECK-NEXT: unwind label %cleanup{{$}}275 276noinfo.root.cont:277 invoke void @g() [ "funclet"(token %noinfo.root.pad) ]278 to label %unreachable unwind label %noinfo.right279; CHECK: [[noinfo_root_cont]]:280; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[noinfo_root_pad]]) ]281; CHECK-NEXT: unwind label %[[noinfo_right:.+]]282 283noinfo.right:284 %noinfo.right.cs = catchswitch within %noinfo.root.pad [label %noinfo.right.catch] unwind to caller285; CHECK: [[noinfo_right]]:286; CHECK-NEXT: %[[noinfo_right_cs:[^ ]+]] = catchswitch within %[[noinfo_root_pad]] [label %[[noinfo_right_catch:[^ ]+]]] unwind label %cleanup{{$}}287 288noinfo.right.catch:289 %noinfo.right.pad = catchpad within %noinfo.right.cs []290 invoke void @g() [ "funclet"(token %noinfo.right.pad) ]291 to label %unreachable unwind label %noinfo.right.child292; CHECK: [[noinfo_right_catch]]:293; CHECK-NEXT: %[[noinfo_right_pad:[^ ]+]] = catchpad within %[[noinfo_right_cs]]294; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[noinfo_right_pad]]) ]295; CHECK-NEXT: unwind label %[[noinfo_right_child:.+]]296 297noinfo.right.child:298 %noinfo.right.child.pad = cleanuppad within %noinfo.right.pad []299 call void @g() [ "funclet"(token %noinfo.right.child.pad) ]300 br label %unreachable301; CHECK: [[noinfo_right_child]]:302; CHECK-NEXT: %[[noinfo_right_child_pad:[^ ]+]] = cleanuppad within %[[noinfo_right_pad]]303; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[noinfo_right_child_pad]]) ]304; CHECK-NEXT: unwind label %cleanup{{$}}305 306cont:307 invoke void @g()308 to label %exit unwind label %implicit.root309; CHECK: [[cont]]:310; CHECK-NEXT: invoke void @g()311; CHECK-NEXT: unwind label %[[implicit_root:.+]]312 313implicit.root:314 %implicit.root.pad = cleanuppad within none []315 call void @g() [ "funclet"(token %implicit.root.pad) ]316 invoke void @g() [ "funclet"(token %implicit.root.pad) ]317 to label %implicit.root.cont unwind label %implicit.left318; CHECK: [[implicit_root]]:319; There's an unwind edge to %internal in implicit.right, and we need to propagate that320; fact down to implicit.right.grandchild, up to implicit.root, and down to321; implicit.left.child.catch, leaving all calls and "unwind to caller" catchswitches322; alone to so they don't conflict with the unwind edge in implicit.right323; CHECK-NEXT: %[[implicit_root_pad:[^ ]+]] = cleanuppad within none324; CHECK-NEXT: call void @g() [ "funclet"(token %[[implicit_root_pad]]) ]325; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[implicit_root_pad]]) ]326; CHECK-NEXT: to label %[[implicit_root_cont:[^ ]+]] unwind label %[[implicit_left:.+]]327 328implicit.left:329 %implicit.left.pad = cleanuppad within %implicit.root.pad []330 invoke void @g() [ "funclet"(token %implicit.left.pad) ]331 to label %unreachable unwind label %implicit.left.child332; CHECK: [[implicit_left]]:333; CHECK-NEXT: %[[implicit_left_pad:[^ ]+]] = cleanuppad within %[[implicit_root_pad:[^ ]+]]334; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[implicit_left_pad]]) ]335; CHECK-NEXT: unwind label %[[implicit_left_child:.+]]336 337implicit.left.child:338 %implicit.left.child.cs = catchswitch within %implicit.left.pad [label %implicit.left.child.catch] unwind to caller339; CHECK: [[implicit_left_child]]:340; CHECK-NEXT: %[[implicit_left_child_cs:[^ ]+]] = catchswitch within %[[implicit_left_pad]] [label %[[implicit_left_child_catch:[^ ]+]]] unwind to caller341 342implicit.left.child.catch:343 %implicit.left.child.pad = catchpad within %implicit.left.child.cs []344 call void @g() [ "funclet"(token %implicit.left.child.pad) ]345 br label %unreachable346; CHECK: [[implicit_left_child_catch]]:347; CHECK-NEXT: %[[implicit_left_child_pad:[^ ]+]] = catchpad within %[[implicit_left_child_cs]]348; CHECK-NEXT: call void @g() [ "funclet"(token %[[implicit_left_child_pad]]) ]349 350implicit.root.cont:351 invoke void @g() [ "funclet"(token %implicit.root.pad) ]352 to label %unreachable unwind label %implicit.right353; CHECK: [[implicit_root_cont]]:354; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[implicit_root_pad]]) ]355; CHECK-NEXT: unwind label %[[implicit_right:.+]]356 357implicit.right:358 %implicit.right.cs = catchswitch within %implicit.root.pad [label %implicit.right.catch] unwind label %internal359; CHECK: [[implicit_right]]:360; This is the unwind edge (to %internal) whose existence needs to get propagated around the "implicit" tree361; CHECK-NEXT: %[[implicit_right_cs:[^ ]+]] = catchswitch within %[[implicit_root_pad]] [label %[[implicit_right_catch:[^ ]+]]] unwind label %[[internal:.+]]362 363implicit.right.catch:364 %implicit.right.pad = catchpad within %implicit.right.cs []365 invoke void @g() [ "funclet"(token %implicit.right.pad) ]366 to label %unreachable unwind label %implicit.right.child367; CHECK: [[implicit_right_catch]]:368; CHECK-NEXT: %[[implicit_right_pad:[^ ]+]] = catchpad within %[[implicit_right_cs]]369; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[implicit_right_pad]]) ]370; CHECK-NEXT: unwind label %[[implicit_right_child:.+]]371 372implicit.right.child:373 %implicit.right.child.pad = cleanuppad within %implicit.right.pad []374 invoke void @g() [ "funclet"(token %implicit.right.child.pad) ]375 to label %unreachable unwind label %implicit.right.grandchild376; CHECK: [[implicit_right_child]]:377; CHECK-NEXT: %[[implicit_right_child_pad:[^ ]+]] = cleanuppad within %[[implicit_right_pad]]378; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[implicit_right_child_pad]]) ]379; CHECK-NEXT: unwind label %[[implicit_right_grandchild:.+]]380 381implicit.right.grandchild:382 %implicit.right.grandchild.cs = catchswitch within %implicit.right.child.pad [label %implicit.right.grandchild.catch] unwind to caller383; CHECK: [[implicit_right_grandchild]]:384; CHECK-NEXT: %[[implicit_right_grandchild_cs:[^ ]+]] = catchswitch within %[[implicit_right_child_pad]] [label %[[implicit_right_grandchild_catch:[^ ]+]]] unwind to caller385 386implicit.right.grandchild.catch:387 %implicit.right.grandhcild.pad = catchpad within %implicit.right.grandchild.cs []388 call void @g() [ "funclet"(token %implicit.right.grandhcild.pad) ]389 br label %unreachable390; CHECK: [[implicit_right_grandchild_catch]]:391; CHECK-NEXT: %[[implicit_right_grandhcild_pad:[^ ]+]] = catchpad within %[[implicit_right_grandchild_cs]]392; CHECK-NEXT: call void @g() [ "funclet"(token %[[implicit_right_grandhcild_pad]]) ]393 394internal:395 %internal.pad = cleanuppad within none []396 call void @g() [ "funclet"(token %internal.pad) ]397 cleanupret from %internal.pad unwind to caller398; CHECK: [[internal]]:399; internal is a cleanup with a "return to caller" cleanuppad; that needs to get redirected400; to %cleanup in the caller, and the call needs to get similarly rewritten to an invoke.401; CHECK-NEXT: %[[internal_pad:[^ ]+]] = cleanuppad within none402; CHECK-NEXT: invoke void @g() [ "funclet"(token %internal.pad.i) ]403; CHECK-NEXT: to label %[[next:[^ ]+]] unwind label %cleanup{{$}}404; CHECK: [[next]]:405; CHECK-NEXT: cleanupret from %[[internal_pad]] unwind label %cleanup{{$}}406 407unreachable:408 unreachable409exit:410 ret void411}412 413;;; Test with funclets that don't have information for themselves, but have414;;; descendants which unwind to other descendants (left.left unwinds to415;;; left.right, and right unwinds to far_right). Make sure that these local416;;; unwinds don't trip up processing of the ancestor nodes (left and root) that417;;; ultimately have no information.418;;; CHECK-LABEL: define void @test6(419define void @test6() personality ptr @ProcessCLRException {420entry:421; CHECK-NEXT: entry:422 invoke void @test6_inlinee()423 to label %exit unwind label %cleanup424cleanup:425 %pad = cleanuppad within none []426 call void @g() [ "funclet"(token %pad) ]427 cleanupret from %pad unwind to caller428exit:429 ret void430}431 432define void @test6_inlinee() alwaysinline personality ptr @ProcessCLRException {433entry:434 invoke void @g()435 to label %exit unwind label %root436 ; CHECK-NEXT: invoke void @g()437 ; CHECK-NEXT: unwind label %[[root:.+]]438root:439 %root.pad = cleanuppad within none []440 invoke void @g() [ "funclet"(token %root.pad) ]441 to label %root.cont unwind label %left442; CHECK: [[root]]:443; CHECK-NEXT: %[[root_pad:.+]] = cleanuppad within none []444; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[root_pad]]) ]445; CHECK-NEXT: to label %[[root_cont:.+]] unwind label %[[left:.+]]446 447left:448 %left.cs = catchswitch within %root.pad [label %left.catch] unwind to caller449; CHECK: [[left]]:450; CHECK-NEXT: %[[left_cs:.+]] = catchswitch within %[[root_pad]] [label %[[left_catch:.+]]] unwind label %cleanup451 452left.catch:453 %left.cp = catchpad within %left.cs []454 call void @g() [ "funclet"(token %left.cp) ]455 invoke void @g() [ "funclet"(token %left.cp) ]456 to label %unreach unwind label %left.left457; CHECK: [[left_catch:.+]]:458; CHECK-NEXT: %[[left_cp:.+]] = catchpad within %[[left_cs]] []459; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[left_cp]]) ]460; CHECK-NEXT: to label %[[lc_cont:.+]] unwind label %cleanup461; CHECK: [[lc_cont]]:462; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[left_cp]]) ]463; CHECK-NEXT: to label %[[unreach:.+]] unwind label %[[left_left:.+]]464 465left.left:466 %ll.pad = cleanuppad within %left.cp []467 cleanupret from %ll.pad unwind label %left.right468; CHECK: [[left_left]]:469; CHECK-NEXT: %[[ll_pad:.+]] = cleanuppad within %[[left_cp]] []470; CHECK-NEXT: cleanupret from %[[ll_pad]] unwind label %[[left_right:.+]]471 472left.right:473 %lr.pad = cleanuppad within %left.cp []474 unreachable475; CHECK: [[left_right]]:476; CHECK-NEXT: %[[lr_pad:.+]] = cleanuppad within %[[left_cp]] []477; CHECK-NEXT: unreachable478 479root.cont:480 call void @g() [ "funclet"(token %root.pad) ]481 invoke void @g() [ "funclet"(token %root.pad) ]482 to label %unreach unwind label %right483; CHECK: [[root_cont]]:484; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[root_pad]]) ]485; CHECK-NEXT: to label %[[root_cont_cont:.+]] unwind label %cleanup486; CHECK: [[root_cont_cont]]:487; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[root_pad]]) ]488; CHECK-NEXT: to label %[[unreach]] unwind label %[[right:.+]]489 490right:491 %right.pad = cleanuppad within %root.pad []492 invoke void @g() [ "funclet"(token %right.pad) ]493 to label %unreach unwind label %right.child494; CHECK: [[right]]:495; CHECK-NEXT: %[[right_pad:.+]] = cleanuppad within %[[root_pad]] []496; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[right_pad]]) ]497; CHECK-NEXT: to label %[[unreach]] unwind label %[[right_child:.+]]498 499right.child:500 %rc.pad = cleanuppad within %right.pad []501 invoke void @g() [ "funclet"(token %rc.pad) ]502 to label %unreach unwind label %far_right503; CHECK: [[right_child]]:504; CHECK-NEXT: %[[rc_pad:.+]] = cleanuppad within %[[right_pad]] []505; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[rc_pad]]) ]506; CHECK-NEXT: to label %[[unreach]] unwind label %[[far_right:.+]]507 508far_right:509 %fr.cs = catchswitch within %root.pad [label %fr.catch] unwind to caller510; CHECK: [[far_right]]:511; CHECK-NEXT: %[[fr_cs:.+]] = catchswitch within %[[root_pad]] [label %[[fr_catch:.+]]] unwind label %cleanup512 513fr.catch:514 %fr.cp = catchpad within %fr.cs []515 unreachable516; CHECK: [[fr_catch]]:517; CHECK-NEXT: %[[fr_cp:.+]] = catchpad within %[[fr_cs]] []518; CHECK-NEXT: unreachable519 520unreach:521 unreachable522; CHECK: [[unreach]]:523; CHECK-NEXT: unreachable524 525exit:526 ret void527}528 529 530;;; Test with a no-info funclet (right) which has a cousin (left.left) that531;;; unwinds to another cousin (left.right); make sure we don't trip over this532;;; when propagating unwind destination info to "right".533;;; CHECK-LABEL: define void @test7(534define void @test7() personality ptr @ProcessCLRException {535entry:536; CHECK-NEXT: entry:537 invoke void @test7_inlinee()538 to label %exit unwind label %cleanup539cleanup:540 %pad = cleanuppad within none []541 call void @g() [ "funclet"(token %pad) ]542 cleanupret from %pad unwind to caller543exit:544 ret void545}546 547define void @test7_inlinee() alwaysinline personality ptr @ProcessCLRException {548entry:549 invoke void @g()550 to label %exit unwind label %root551; CHECK-NEXT: invoke void @g()552; CHECK-NEXT: unwind label %[[root:.+]]553 554root:555 %root.cp = cleanuppad within none []556 invoke void @g() [ "funclet"(token %root.cp) ]557 to label %root.cont unwind label %child558; CHECK: [[root]]:559; CHECK-NEXT: %[[root_cp:.+]] = cleanuppad within none []560; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[root_cp]]) ]561; CHECK-NEXT: to label %[[root_cont:.+]] unwind label %[[child:.+]]562 563root.cont:564 cleanupret from %root.cp unwind to caller565; CHECK: [[root_cont]]:566; CHECK-NEXT: cleanupret from %[[root_cp]] unwind label %cleanup567 568child:569 %child.cp = cleanuppad within %root.cp []570 invoke void @g() [ "funclet"(token %child.cp) ]571 to label %child.cont unwind label %left572; CHECK: [[child]]:573; CHECK-NEXT: %[[child_cp:.+]] = cleanuppad within %[[root_cp]] []574; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[child_cp]]) ]575; CHECK-NEXT: to label %[[child_cont:.+]] unwind label %[[left:.+]]576 577left:578 %left.cp = cleanuppad within %child.cp []579 invoke void @g() [ "funclet"(token %left.cp) ]580 to label %left.cont unwind label %left.left581; CHECK: [[left]]:582; CHECK-NEXT: %[[left_cp:.+]] = cleanuppad within %[[child_cp]] []583; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[left_cp]]) ]584; CHECK-NEXT: to label %[[left_cont:.+]] unwind label %[[left_left:.+]]585 586left.left:587 %ll.cp = cleanuppad within %left.cp []588 cleanupret from %ll.cp unwind label %left.right589; CHECK: [[left_left]]:590; CHECK-NEXT: %[[ll_cp:.+]] = cleanuppad within %[[left_cp]] []591; CHECK-NEXT: cleanupret from %[[ll_cp]] unwind label %[[left_right:.+]]592 593left.cont:594 invoke void @g() [ "funclet"(token %left.cp) ]595 to label %unreach unwind label %left.right596; CHECK: [[left_cont]]:597; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[left_cp]]) ]598; CHECK-NEXT: to label %[[unreach:.+]] unwind label %[[left_right]]599 600left.right:601 %lr.cp = cleanuppad within %left.cp []602 unreachable603; CHECK: [[left_right]]:604; CHECK-NEXT: %[[lr_cp:.+]] = cleanuppad within %[[left_cp]] []605; CHECK-NEXT: unreachable606 607child.cont:608 invoke void @g() [ "funclet"(token %child.cp) ]609 to label %unreach unwind label %right610; CHECK: [[child_cont]]:611; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[child_cp]]) ]612; CHECK-NEXT: to label %[[unreach]] unwind label %[[right:.+]]613 614right:615 %right.cp = cleanuppad within %child.cp []616 call void @g() [ "funclet"(token %right.cp) ]617 unreachable618; CHECK: [[right]]:619; CHECK-NEXT: %[[right_cp:.+]] = cleanuppad within %[[child_cp]]620; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[right_cp]]) ]621; CHECK-NEXT: to label %[[right_cont:.+]] unwind label %cleanup622; CHECK: [[right_cont]]:623; CHECK-NEXT: unreachable624 625unreach:626 unreachable627; CHECK: [[unreach]]:628; CHECK-NEXT: unreachable629 630exit:631 ret void632}633 634declare void @ProcessCLRException()635 636; Make sure the logic doesn't get tripped up when the inlined invoke is637; itself within a funclet in the caller.638; CHECK-LABEL: define void @test8(639define void @test8() personality ptr @ProcessCLRException {640entry:641 invoke void @g()642 to label %exit unwind label %callsite_parent643callsite_parent:644 %callsite_parent.pad = cleanuppad within none []645; CHECK: %callsite_parent.pad = cleanuppad within none646 invoke void @test8_inlinee() [ "funclet"(token %callsite_parent.pad) ]647 to label %ret unwind label %cleanup648ret:649 cleanupret from %callsite_parent.pad unwind label %cleanup650cleanup:651 %pad = cleanuppad within none []652 call void @g() [ "funclet"(token %pad) ]653 cleanupret from %pad unwind to caller654exit:655 ret void656}657 658define void @test8_inlinee() alwaysinline personality ptr @ProcessCLRException {659entry:660 invoke void @g()661 to label %exit unwind label %inlinee_cleanup662; CHECK-NEXT: invoke void @g() [ "funclet"(token %callsite_parent.pad) ]663; CHECK-NEXT: unwind label %[[inlinee_cleanup:.+]]664 665inlinee_cleanup:666 %inlinee.pad = cleanuppad within none []667 call void @g() [ "funclet"(token %inlinee.pad) ]668 unreachable669; CHECK: [[inlinee_cleanup]]:670; CHECK-NEXT: %[[inlinee_pad:[^ ]+]] = cleanuppad within %callsite_parent.pad671; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[inlinee_pad]]) ]672; CHECK-NEXT: unwind label %cleanup{{$}}673 674exit:675 ret void676}677