JIT: cross-block local assertion prop in morph

During global morph, allow assertions to propagate to a block from the block's
predecessors. Handle special cases where we can't allow this to happen:
* block has preds that have not yet been morphed
* block has no preds
* block is specially flagged as one that might gain new preds during morph
* block is an EH handler entry

Contributes to dotnet#93246.

Author: AndyAyersMS

src/coreclr/jit/assertionprop.cpp

@@ -4379,12 +4379,11 @@ AssertionIndex Compiler::optAssertionIsNonNullInternal(GenTree*         op,
         // Find live assertions related to lclNum
         //
         unsigned const lclNum      = op->AsLclVarCommon()->GetLclNum();
-        ASSERT_TP      apDependent = GetAssertionDep(lclNum);
-        BitVecOps::IntersectionD(apTraits, apDependent, apLocal);
+        ASSERT_TP      apDependent = BitVecOps::Intersection(apTraits, GetAssertionDep(lclNum), assertions);
 
         // Scan those looking for a suitable assertion
         //
-        BitVecOps::Iter iter(apTraits, assertions);
+        BitVecOps::Iter iter(apTraits, apDependent);
         unsigned        index = 0;
         while (iter.NextElem(&index))
         {

src/coreclr/jit/jitconfigvalues.h

@@ -445,6 +445,9 @@ CONFIG_INTEGER(JitNoRngChks, W("JitNoRngChks"), 0) // If 1, don't generate range
 
 #if defined(OPT_CONFIG)
 CONFIG_INTEGER(JitDoAssertionProp, W("JitDoAssertionProp"), 1) // Perform assertion propagation optimization
+CONFIG_INTEGER(JitDoCrossBlockLocalAssertionProp, W("JitDoCrossBlockLocalAssertionProp"), 1) // Perform local assertion
+                                                                                             // propagation optimization
+                                                                                             // cross-block
 CONFIG_INTEGER(JitDoCopyProp, W("JitDoCopyProp"), 1)   // Perform copy propagation on variables that appear redundant
 CONFIG_INTEGER(JitDoEarlyProp, W("JitDoEarlyProp"), 1) // Perform Early Value Propagation
 CONFIG_INTEGER(JitDoLoopHoisting, W("JitDoLoopHoisting"), 1)   // Perform loop hoisting on loop invariant values

src/coreclr/jit/morph.cpp

@@ -13780,10 +13780,78 @@ void Compiler::fgMorphBlock(BasicBlock* block)
 
     if (optLocalAssertionProp)
     {
-        // For now, each block starts with an empty table, and no available assertions
+        // Determine if this block can leverage assertions from its pred blocks.
         //
-        optAssertionReset(0);
-        apLocal = BitVecOps::MakeEmpty(apTraits);
+        // Some blocks are ineligible.
+        //
+        bool canUsePredAssertions = ((block->bbFlags & BBF_CAN_ADD_PRED) == 0) && !bbIsHandlerBeg(block);
+
+#ifdef DEBUG
+        // Optionally suppress via config
+        //
+        if (JitConfig.JitDoCrossBlockLocalAssertionProp() == 0)
+        {
+            canUsePredAssertions = false;
+        }
+#endif
+
+        // Validate all preds have valid info
+        //
+        if (canUsePredAssertions)
+        {
+            bool hasPred = false;
+
+            for (BasicBlock* const pred : block->PredBlocks())
+            {
+                // A higher postorder number means the block appears earlier in
+                // the postorder. Use this to detect if a pred's assertion info is available.
+                //
+                if (pred->bbPostorderNum > block->bbPostorderNum)
+                {
+                    // Yes, available. If this is the first pred, copy.
+                    // If this is a subsequent pred, intersect.
+                    //
+                    if (!hasPred)
+                    {
+                        apLocal = BitVecOps::MakeCopy(apTraits, pred->bbAssertionOut);
+                        hasPred = true;
+                    }
+                    else
+                    {
+                        BitVecOps::IntersectionD(apTraits, apLocal, pred->bbAssertionOut);
+                    }
+
+                    continue;
+                }
+
+                // No, not available.
+                //
+                JITDUMP(FMT_BB " pred " FMT_BB " not processed; clearing assertions in\n", block->bbNum, pred->bbNum);
+                canUsePredAssertions = false;
+            }
+
+            // If there were no preds, there are no asserions in.
+            //
+            if (!hasPred)
+            {
+                JITDUMP(FMT_BB " has no preds, so no assertions in\n", block->bbNum);
+                canUsePredAssertions = false;
+            }
+
+            if (canUsePredAssertions)
+            {
+                JITDUMPEXEC(optDumpAssertionIndices("Assertions in: ", apLocal));
+            }
+        }
+        else
+        {
+            JITDUMP(FMT_BB " ineligible for cross-block; clearing assertions in\n", block->bbNum);
+        }
+
+        if (!canUsePredAssertions)
+        {
+            apLocal = BitVecOps::MakeEmpty(apTraits);
+        }
     }
 
     // Make the current basic block address available globally.
@@ -13801,6 +13869,11 @@ void Compiler::fgMorphBlock(BasicBlock* block)
         }
     }
 
+    if (optLocalAssertionProp && (block->NumSucc() > 0))
+    {
+        block->bbAssertionOut = BitVecOps::MakeCopy(apTraits, apLocal);
+    }
+
     compCurBB = nullptr;
 }