Find sccs

src/coreclr/jit/compiler.h

@@ -88,6 +88,7 @@ struct JumpThreadInfo;     // defined in redundantbranchopts.cpp
 class ProfileSynthesis;    // defined in profilesynthesis.h
 class PerLoopInfo;         // defined in inductionvariableopts.cpp
 class RangeCheck;          // defined in rangecheck.h
+class SCC;
 #ifdef DEBUG
 struct IndentStack;
 #endif
@@ -2751,6 +2752,7 @@ class Compiler
     bool bbInHandlerRegions(unsigned regionIndex, BasicBlock* blk);
     bool bbInCatchHandlerRegions(BasicBlock* tryBlk, BasicBlock* hndBlk);
     unsigned short bbFindInnermostCommonTryRegion(BasicBlock* bbOne, BasicBlock* bbTwo);
+    unsigned short bbFindInnermostCommonTryRegion(unsigned tryIndex, BasicBlock* bbTwo);
 
     unsigned short bbFindInnermostTryRegionContainingHandlerRegion(unsigned handlerIndex);
     unsigned short bbFindInnermostHandlerRegionContainingTryRegion(unsigned tryIndex);
@@ -6239,6 +6241,9 @@ class Compiler
     template <typename VisitPreorder, typename VisitPostorder, typename VisitEdge, const bool useProfile = false>
     unsigned fgRunDfs(VisitPreorder assignPreorder, VisitPostorder assignPostorder, VisitEdge visitEdge);
 
+    template <typename VisitPreorder, typename VisitPostorder, typename VisitEdge, const bool useProfile = false>
+    unsigned fgRunSubgraphDfs(VisitPreorder assignPreorder, VisitPostorder assignPostorder, VisitEdge visitEdge, BitVec& subgraph, BitVecTraits& subgraphTraits);
+
     template <const bool useProfile = false>
     FlowGraphDfsTree* fgComputeDfs();
     void fgInvalidateDfsTree();
@@ -7024,6 +7029,9 @@ class Compiler
     void optFindLoops();
     bool optCanonicalizeLoops();
 
+    bool optFindSCCs(bool& failedToModify);
+    void optFindSCCs(BitVec& subset, BitVecTraits& traits, ArrayStack<SCC*>& sccs, BasicBlock** postorder, unsigned postorderCount);
+
     void optCompactLoops();
     void optCompactLoop(FlowGraphNaturalLoop* loop);
     bool optCreatePreheader(FlowGraphNaturalLoop* loop);

src/coreclr/jit/compiler.hpp

@@ -5197,6 +5197,143 @@ unsigned Compiler::fgRunDfs(VisitPreorder visitPreorder, VisitPostorder visitPos
     return preOrderIndex;
 }
 
+//------------------------------------------------------------------------
+// fgRunSubgraphDfs: Run DFS over a subgraph of the flow graph.
+//
+// Type parameters:
+//   VisitPreorder  - Functor type that takes a BasicBlock* and its preorder number
+//   VisitPostorder - Functor type that takes a BasicBlock* and its postorder number
+//   VisitEdge      - Functor type that takes two BasicBlock*.
+//   useProfile     - If true, determines order of successors visited using profile data
+//
+// Parameters:
+//   visitPreorder  - Functor to visit block in its preorder
+//   visitPostorder - Functor to visit block in its postorder
+//   visitEdge      - Functor to visit an edge. Called after visitPreorder (if
+//                    this is the first time the successor is seen).
+//   subgraphBlocks - bitvector (in postorder num space) identifying the subgraph
+//   subgraphTraits - traits for the subgraphBlocks
+//
+// Returns:
+//   Number of blocks visited.
+//
+// Notes:
+//   Assumes m_dfs is valid (in particular, uses block post order numbers)
+//
+template <typename VisitPreorder, typename VisitPostorder, typename VisitEdge, const bool useProfile /* = false */>
+unsigned Compiler::fgRunSubgraphDfs(VisitPreorder  visitPreorder,
+                                    VisitPostorder visitPostorder,
+                                    VisitEdge      visitEdge,
+                                    BitVec&        subgraph,
+                                    BitVecTraits&  subgraphTraits)
+{
+    // just reuse the existing traits here, and index by bbPostorderNum?
+    JITDUMP("Running subgraph DFS on %u blocks\n", BitVecOps::Count(&subgraphTraits, subgraph));
+    BitVecTraits traits(fgBBNumMax + 1, this);
+    BitVec       visited(BitVecOps::MakeEmpty(&traits));
+
+    unsigned preOrderIndex  = 0;
+    unsigned postOrderIndex = 0;
+
+    ArrayStack<AllSuccessorEnumerator> blocks(getAllocator(CMK_DepthFirstSearch));
+
+    auto dfsFrom = [&](BasicBlock* firstBB) {
+        BitVecOps::AddElemD(&traits, visited, firstBB->bbNum);
+        blocks.Emplace(this, firstBB, useProfile);
+        JITDUMP(" visiting " FMT_BB "\n", firstBB->bbNum);
+        visitPreorder(firstBB, preOrderIndex++);
+
+        while (!blocks.Empty())
+        {
+            BasicBlock* const block = blocks.TopRef().Block();
+            BasicBlock* const succ  = blocks.TopRef().NextSuccessor();
+
+            if (succ != nullptr)
+            {
+                if (BitVecOps::IsMember(&subgraphTraits, subgraph, succ->bbPostorderNum))
+                {
+                    if (BitVecOps::TryAddElemD(&traits, visited, succ->bbNum))
+                    {
+                        blocks.Emplace(this, succ, useProfile);
+                        visitPreorder(succ, preOrderIndex++);
+                    }
+
+                    visitEdge(block, succ);
+                }
+
+                // If this is a callfinally but the finally itself is not
+                // in the subset, summarize the flow to the pair tail.
+                //
+                // Note a callfinally will only have one successor, so
+                // we don't need extra conditions here.
+                //
+                else if (block->isBBCallFinallyPair())
+                {
+                    BasicBlock* const callFinallyRet = block->Next();
+
+                    if (BitVecOps::IsMember(&subgraphTraits, subgraph, callFinallyRet->bbPostorderNum))
+                    {
+                        if (BitVecOps::TryAddElemD(&traits, visited, callFinallyRet->bbNum))
+                        {
+                            blocks.Emplace(this, callFinallyRet, useProfile);
+                            visitPreorder(callFinallyRet, preOrderIndex++);
+                        }
+
+                        visitEdge(block, callFinallyRet);
+                    }
+                }
+
+                continue;
+            }
+
+            blocks.Pop();
+            visitPostorder(block, postOrderIndex++);
+        }
+    };
+
+    // Find the subgraph entry blocks (blocks that have no pred, or a pred not in the subgraph).
+    //
+    ArrayStack<BasicBlock*> entries(getAllocator(CMK_DepthFirstSearch));
+
+    unsigned        poNum = 0;
+    BitVecOps::Iter iterator(&subgraphTraits, subgraph);
+    while (iterator.NextElem(&poNum))
+    {
+        BasicBlock* const block   = m_dfsTree->GetPostOrder(poNum);
+        bool              hasPred = false;
+        for (BasicBlock* const pred : block->PredBlocks())
+        {
+            hasPred = true;
+            if (!BitVecOps::IsMember(&subgraphTraits, subgraph, pred->bbPostorderNum))
+            {
+                JITDUMP(FMT_BB " is subgraph entry\n", block->bbNum);
+                entries.Emplace(block);
+            }
+        }
+
+        if (!hasPred)
+        {
+            JITDUMP(FMT_BB " is an isolated subgraph entry\n", block->bbNum);
+            entries.Emplace(block);
+        }
+    }
+
+    // Kick off a DFS from each unvisited entry
+    //
+    while (entries.Height() > 0)
+    {
+        BasicBlock* const block = entries.Pop();
+
+        if (!BitVecOps::IsMember(&traits, visited, block->bbNum))
+        {
+            dfsFrom(block);
+        }
+    }
+
+    assert(preOrderIndex == postOrderIndex);
+    return preOrderIndex;
+}
+
 //------------------------------------------------------------------------
 // fgVisitBlocksInLoopAwareRPO: Visit the blocks in 'dfsTree' in reverse post-order,
 // but ensure loop bodies are visited before loop successors.

src/coreclr/jit/fgbasic.cpp

@@ -4909,31 +4909,34 @@ BasicBlock* Compiler::fgSplitBlockAtBeginning(BasicBlock* curr)
 //    Returns a new block, that is a successor of 'curr' and which branches unconditionally to 'succ'
 //
 // Assumptions:
-//    'curr' must have a bbKind of BBJ_COND, BBJ_ALWAYS, or BBJ_SWITCH
+//    'curr' must have a bbKind of BBJ_COND, BBJ_ALWAYS, BBJ_SWITCH, BBJ_CALLFINALLYRET, or BBJ_EHCATCHRET
 //
 // Notes:
 //    The returned block is empty.
 //    Can be invoked before pred lists are built.
 
 BasicBlock* Compiler::fgSplitEdge(BasicBlock* curr, BasicBlock* succ)
 {
-    assert(curr->KindIs(BBJ_COND, BBJ_SWITCH, BBJ_ALWAYS));
+    assert(curr->KindIs(BBJ_COND, BBJ_SWITCH, BBJ_ALWAYS, BBJ_CALLFINALLYRET, BBJ_EHCATCHRET));
     assert(fgPredsComputed);
     assert(fgGetPredForBlock(succ, curr) != nullptr);
 
+    // For EHCATCHRET put the split block in succ's EH region
+    BasicBlock* const cursor = curr->KindIs(BBJ_EHCATCHRET) ? succ : curr;
+
     BasicBlock* newBlock;
     if (curr->NextIs(succ))
     {
         // The successor is the fall-through path of a BBJ_COND, or
         // an immediately following block of a BBJ_SWITCH (which has
         // no fall-through path). For this case, simply insert a new
         // fall-through block after 'curr'.
-        newBlock = fgNewBBafter(BBJ_ALWAYS, curr, true /* extendRegion */);
+        newBlock = fgNewBBafter(BBJ_ALWAYS, cursor, true /* extendRegion */);
     }
     else
     {
         // The new block always jumps to 'succ'
-        newBlock = fgNewBBinRegion(BBJ_ALWAYS, curr, /* isRunRarely */ curr->isRunRarely());
+        newBlock = fgNewBBinRegion(BBJ_ALWAYS, cursor, /* isRunRarely */ curr->isRunRarely());
     }
     newBlock->CopyFlags(curr, succ->GetFlagsRaw() & BBF_BACKWARD_JUMP);
 

src/coreclr/jit/jitconfigvalues.h

@@ -98,6 +98,9 @@ CONFIG_INTEGER(JitUnrollLoopMaxIterationCount,
 
 CONFIG_INTEGER(JitUnrollLoopsWithEH, "JitUnrollLoopsWithEH", 0) // If 0, don't unroll loops containing EH regions
 
+RELEASE_CONFIG_INTEGER(JitTransformIrreducibleLoops, "JitTransformIrreducibleLoops", 1) // 0: leave as is; 1: switch
+                                                                                        // dispatch
+
 CONFIG_INTEGER(JitDirectAlloc, "JitDirectAlloc", 0)
 CONFIG_INTEGER(JitDoubleAlign, "JitDoubleAlign", 1)
 CONFIG_INTEGER(JitEmitPrintRefRegs, "JitEmitPrintRefRegs", 0)

src/coreclr/jit/jiteh.cpp

@@ -615,6 +615,32 @@ unsigned short Compiler::bbFindInnermostCommonTryRegion(BasicBlock* bbOne, Basic
     return 0;
 }
 
+/******************************************************************************************
+ * Given a one-biased region index (which may be 0, indicating method region) and a block,
+ * return one-biased index for the inner-most enclosing try region that contains the block and the region.
+ * Return 0 if it does not find any try region (which means the inner-most region
+ * is the method itself).
+ */
+
+unsigned short Compiler::bbFindInnermostCommonTryRegion(unsigned index, BasicBlock* bbTwo)
+{
+    assert(index <= compHndBBtabCount);
+
+    if (index == 0)
+        return 0;
+
+    for (unsigned XTnum = index - 1; XTnum < compHndBBtabCount; XTnum++)
+    {
+        if (bbInTryRegions(XTnum, bbTwo))
+        {
+            noway_assert(XTnum < MAX_XCPTN_INDEX);
+            return (unsigned short)(XTnum + 1); // Return the tryIndex
+        }
+    }
+
+    return 0;
+}
+
 // bbIsTryBeg() returns true if this block is the start of any try region.
 //              This is computed by examining the current values in the
 //              EH table rather than just looking at the block's bbFlags.

src/coreclr/jit/jitmetadatalist.h

@@ -95,6 +95,8 @@ JITMETADATAMETRIC(MorphTrackedLocals,                    int,              0)
 JITMETADATAMETRIC(MorphLocals,                           int,              0)
 JITMETADATAMETRIC(EnumeratorGDVProvisionalNoEscape,      int,              0)
 JITMETADATAMETRIC(EnumeratorGDVCanCloneToEnsureNoEscape, int,              0)
+JITMETADATAMETRIC(IrreducibleLoopsFoundDuringOpts,       int,              0)
+JITMETADATAMETRIC(IrreducibleNestedLoopsFoundDuringOpts, int,              0)
 
 #undef JITMETADATA
 #undef JITMETADATAINFO