From f4a0ff09a8ebffd2ebaaa11d45e40a684e8ed018 Mon Sep 17 00:00:00 2001 From: Chen Li Date: Thu, 22 Oct 2015 20:48:38 +0000 Subject: [PATCH] [SimplifyCFG] Extend SimplifyResume to handle phi of trivial landing pad. Summary: Currently SimplifyResume can convert an invoke instruction to a call instruction if its landing pad is trivial. In practice we could have several invoke instructions with trivial landing pads and share a common rethrow block, and in the common rethrow block, all the landing pads join to a phi node. The patch extends SimplifyResume to check the phi of landing pad and their incoming blocks. If any of them is trivial, remove it from the phi node and convert the invoke instruction to a call instruction. Reviewers: hfinkel, reames Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D13718 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@251061 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/Utils/SimplifyCFG.cpp | 76 +++++++++++++++++--- test/Transforms/SimplifyCFG/invoke_unwind.ll | 42 +++++++++++ 2 files changed, 107 insertions(+), 11 deletions(-) diff --git a/lib/Transforms/Utils/SimplifyCFG.cpp b/lib/Transforms/Utils/SimplifyCFG.cpp index e435537c3a7..ce550dc7fd1 100644 --- a/lib/Transforms/Utils/SimplifyCFG.cpp +++ b/lib/Transforms/Utils/SimplifyCFG.cpp @@ -2905,26 +2905,80 @@ bool SimplifyCFGOpt::SimplifyResume(ResumeInst *RI, IRBuilder<> &Builder) { // exception then zap the landing pad, turning its invokes into calls. BasicBlock *BB = RI->getParent(); LandingPadInst *LPInst = dyn_cast(BB->getFirstNonPHI()); - if (RI->getValue() != LPInst) - // Not a landing pad, or the resume is not unwinding the exception that - // caused control to branch here. + + // If RI->getValue() is a landing pad, check if the first instruction is + // the same landing pad that caused control to branch here. If RI->getValue + // is a phi of landing pad, check its predecessor blocks to see if any of + // them contains a trivial landing pad. + if (RI->getValue() != LPInst && !isa(RI->getValue())) return false; - // Check that there are no other instructions except for debug intrinsics. - BasicBlock::iterator I = LPInst->getIterator(), E = RI->getIterator(); + // Check that there are no other instructions except for debug intrinsics + // between the landing pad (or phi of landing pad) and resume instruction. + BasicBlock::iterator I = cast(RI->getValue()), E = RI; while (++I != E) if (!isa(I)) return false; + SmallVector TrivialUnwindBlocks; + if (RI->getValue() == LPInst) { + // Landing pad is in current block, which has already been checked. + TrivialUnwindBlocks.push_back(BB); + } else { + // Check incoming blocks to see if any of them are trivial. + auto *PhiLPInst = cast(RI->getValue()); + for (unsigned i = 0; i < PhiLPInst->getNumIncomingValues(); i++) { + auto *IncomingBB = PhiLPInst->getIncomingBlock(i); + auto *IncomingValue = PhiLPInst->getIncomingValue(i); + + auto *LandingPad = + dyn_cast(IncomingBB->getFirstNonPHI()); + // Not the landing pad that caused the control to branch here. + if (IncomingValue != LandingPad) + continue; + + bool isTrivial = true; + + I = IncomingBB->getFirstNonPHI(); + E = IncomingBB->getTerminator(); + while (++I != E) + if (!isa(I)) { + isTrivial = false; + break; + } + + if (isTrivial) + TrivialUnwindBlocks.push_back(IncomingBB); + } + } + // Turn all invokes that unwind here into calls and delete the basic block. - for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE;) { - BasicBlock *Pred = *PI++; - removeUnwindEdge(Pred); + for (auto *TrivialBB : TrivialUnwindBlocks) { + if (isa(RI->getValue())) { + // Blocks that will be deleted should also be removed + // from the phi node. + BB->removePredecessor(TrivialBB, true); + } + + for (pred_iterator PI = pred_begin(TrivialBB), PE = pred_end(TrivialBB); + PI != PE;) { + BasicBlock *Pred = *PI++; + removeUnwindEdge(Pred); + } + + // The landingpad is now unreachable. Zap it. + if (TrivialBB == BB) + BB = nullptr; + TrivialBB->eraseFromParent(); } - // The landingpad is now unreachable. Zap it. - BB->eraseFromParent(); - return true; + // Delete the resume block if all its predecessors have been deleted, and we + // haven't already deleted it above when deleting the landing pad blocks. + if (BB && pred_begin(BB) == pred_end(BB)) { + BB->eraseFromParent(); + } + + return TrivialUnwindBlocks.size() != 0; } bool SimplifyCFGOpt::SimplifyCleanupReturn(CleanupReturnInst *RI) { diff --git a/test/Transforms/SimplifyCFG/invoke_unwind.ll b/test/Transforms/SimplifyCFG/invoke_unwind.ll index 3b4c09d96f7..b1d0c404d57 100644 --- a/test/Transforms/SimplifyCFG/invoke_unwind.ll +++ b/test/Transforms/SimplifyCFG/invoke_unwind.ll @@ -17,4 +17,46 @@ Rethrow: resume { i8*, i32 } %exn } +declare i64 @dummy1() +declare i64 @dummy2() + +; This testcase checks to see if simplifycfg pass can convert two invoke +; instructions to call instructions if they share a common trivial unwind +; block. +define i64 @test2(i1 %cond) personality i32 (...)* @__gxx_personality_v0 { +entry: +; CHECK-LABEL: @test2( +; CHECK: %call1 = call i64 @dummy1() +; CHECK: %call2 = call i64 @dummy2() +; CHECK-NOT: resume { i8*, i32 } %lp + br i1 %cond, label %br1, label %br2 + +br1: + %call1 = invoke i64 @dummy1() + to label %invoke.cont unwind label %lpad1 + +br2: + %call2 = invoke i64 @dummy2() + to label %invoke.cont unwind label %lpad2 + +invoke.cont: + %c = phi i64 [%call1, %br1], [%call2, %br2] + ret i64 %c + + +lpad1: + %0 = landingpad { i8*, i32 } + cleanup + br label %rethrow + +lpad2: + %1 = landingpad { i8*, i32 } + cleanup + br label %rethrow + +rethrow: + %lp = phi { i8*, i32 } [%0, %lpad1], [%1, %lpad2] + resume { i8*, i32 } %lp +} + declare i32 @__gxx_personality_v0(...) -- 2.34.1