From 8a4d12ae5b3e6b2ef7c851c6865c04d5a84e05f1 Mon Sep 17 00:00:00 2001 From: Fedor Sergeev Date: Thu, 16 Jan 2020 00:57:34 +0300 Subject: [PATCH] [BasicBlock] add helper getPostdominatingDeoptimizeCall It appears to be rather useful when analyzing Loops with multiple deoptimizing exits, perhaps merged ones. For now it is used in LoopPredication, will be adding more uses in other loop passes. Reviewers: asbirlea, fhahn, skatkov, spatel, reames Reviewed By: reames Tags: #llvm Differential Revision: https://reviews.llvm.org/D72754 --- llvm/include/llvm/IR/BasicBlock.h | 9 +++++++++ llvm/lib/IR/BasicBlock.cpp | 7 +++++++ llvm/lib/Transforms/Scalar/LoopPredication.cpp | 18 +++++------------- 3 files changed, 21 insertions(+), 13 deletions(-) diff --git a/llvm/include/llvm/IR/BasicBlock.h b/llvm/include/llvm/IR/BasicBlock.h index d594145..7cfe7b1 100644 --- a/llvm/include/llvm/IR/BasicBlock.h +++ b/llvm/include/llvm/IR/BasicBlock.h @@ -133,6 +133,15 @@ public: static_cast(this)->getTerminatingDeoptimizeCall()); } + /// Returns the call instruction calling \@llvm.experimental.deoptimize + /// that is present either in current basic block or in block that is a unique + /// successor to current block, if such call is present. Otherwise, returns null. + const CallInst *getPostdominatingDeoptimizeCall() const; + CallInst *getPostdominatingDeoptimizeCall() { + return const_cast( + static_cast(this)->getPostdominatingDeoptimizeCall()); + } + /// Returns the call instruction marked 'musttail' prior to the terminating /// return instruction of this basic block, if such a call is present. /// Otherwise, returns null. diff --git a/llvm/lib/IR/BasicBlock.cpp b/llvm/lib/IR/BasicBlock.cpp index bdee699..61aad21 100644 --- a/llvm/lib/IR/BasicBlock.cpp +++ b/llvm/lib/IR/BasicBlock.cpp @@ -193,6 +193,13 @@ const CallInst *BasicBlock::getTerminatingDeoptimizeCall() const { return nullptr; } +const CallInst *BasicBlock::getPostdominatingDeoptimizeCall() const { + const BasicBlock* BB = this; + while (BB->getUniqueSuccessor()) + BB = BB->getUniqueSuccessor(); + return BB->getTerminatingDeoptimizeCall(); +} + const Instruction* BasicBlock::getFirstNonPHI() const { for (const Instruction &I : *this) if (!isa(I)) diff --git a/llvm/lib/Transforms/Scalar/LoopPredication.cpp b/llvm/lib/Transforms/Scalar/LoopPredication.cpp index 1a42f6b..b96352d 100644 --- a/llvm/lib/Transforms/Scalar/LoopPredication.cpp +++ b/llvm/lib/Transforms/Scalar/LoopPredication.cpp @@ -1020,17 +1020,6 @@ static const SCEV *getMinAnalyzeableBackedgeTakenCount(ScalarEvolution &SE, return SE.getUMinFromMismatchedTypes(ExitCounts); } -/// Return true if we can be fairly sure that executing block BB will probably -/// lead to executing an __llvm_deoptimize. This is a profitability heuristic, -/// not a legality constraint. -static bool isVeryLikelyToDeopt(BasicBlock *BB) { - while (BB->getUniqueSuccessor()) - // Will skip side effects, that's okay - BB = BB->getUniqueSuccessor(); - - return BB->getTerminatingDeoptimizeCall(); -} - /// This implements an analogous, but entirely distinct transform from the main /// loop predication transform. This one is phrased in terms of using a /// widenable branch *outside* the loop to allow us to simplify loop exits in a @@ -1150,10 +1139,13 @@ bool LoopPredication::predicateLoopExits(Loop *L, SCEVExpander &Rewriter) { const bool ExitIfTrue = !L->contains(*succ_begin(ExitingBB)); BasicBlock *ExitBB = BI->getSuccessor(ExitIfTrue ? 0 : 1); - if (!isVeryLikelyToDeopt(ExitBB)) - // Profitability: indicator of rarely/never taken exit + if (!ExitBB->getPostdominatingDeoptimizeCall()) continue; + /// Here we can be fairly sure that executing this exit will most likely + /// lead to executing llvm.experimental.deoptimize. + /// This is a profitability heuristic, not a legality constraint. + // If we found a widenable exit condition, do two things: // 1) fold the widened exit test into the widenable condition // 2) fold the branch to untaken - avoids infinite looping -- 2.7.4