Analyze reaching PHI in GetRangeFromAssertions (more branch foldings)

Author: EgorBo

src/coreclr/jit/assertionprop.cpp

@@ -4250,68 +4250,6 @@ GenTree* Compiler::optAssertionProp_RelOp(ASSERT_VALARG_TP assertions,
     return optAssertionPropLocal_RelOp(assertions, tree, stmt);
 }
 
-//--------------------------------------------------------------------------------
-// optVisitReachingAssertions: given a vn, call the specified callback function on all
-//    the assertions that reach it via PHI definitions if any.
-//
-// Arguments:
-//    vn         - The vn to visit all the reaching assertions for
-//    argVisitor - The callback function to call on the vn and its reaching assertions
-//
-// Return Value:
-//    AssertVisit::Aborted  - an argVisitor returned AssertVisit::Abort, we stop the walk and return
-//    AssertVisit::Continue - all argVisitor returned AssertVisit::Continue
-//
-template <typename TAssertVisitor>
-Compiler::AssertVisit Compiler::optVisitReachingAssertions(ValueNum vn, TAssertVisitor argVisitor)
-{
-    VNPhiDef phiDef;
-    if (!vnStore->GetPhiDef(vn, &phiDef))
-    {
-        // We assume that the caller already checked assertions for the current block, so we're
-        // interested only in assertions for PHI definitions.
-        return AssertVisit::Abort;
-    }
-
-    LclSsaVarDsc*        ssaDef = lvaGetDesc(phiDef.LclNum)->GetPerSsaData(phiDef.SsaDef);
-    GenTreeLclVarCommon* node   = ssaDef->GetDefNode();
-    assert(node->IsPhiDefn());
-
-    // Keep track of the set of phi-preds
-    //
-    BitVecTraits traits(fgBBNumMax + 1, this);
-    BitVec       visitedBlocks = BitVecOps::MakeEmpty(&traits);
-
-    for (GenTreePhi::Use& use : node->Data()->AsPhi()->Uses())
-    {
-        GenTreePhiArg* phiArg     = use.GetNode()->AsPhiArg();
-        const ValueNum phiArgVN   = vnStore->VNConservativeNormalValue(phiArg->gtVNPair);
-        ASSERT_TP      assertions = optGetEdgeAssertions(ssaDef->GetBlock(), phiArg->gtPredBB);
-        if (argVisitor(phiArgVN, assertions) == AssertVisit::Abort)
-        {
-            // The visitor wants to abort the walk.
-            return AssertVisit::Abort;
-        }
-        BitVecOps::AddElemD(&traits, visitedBlocks, phiArg->gtPredBB->bbNum);
-    }
-
-    // Verify the set of phi-preds covers the set of block preds
-    //
-    for (BasicBlock* const pred : ssaDef->GetBlock()->PredBlocks())
-    {
-        if (!BitVecOps::IsMember(&traits, visitedBlocks, pred->bbNum))
-        {
-            JITDUMP("... optVisitReachingAssertions in " FMT_BB ": pred " FMT_BB " not a phi-pred\n",
-                    ssaDef->GetBlock()->bbNum, pred->bbNum);
-
-            // We missed examining a block pred. Fail the phi inference.
-            //
-            return AssertVisit::Abort;
-        }
-    }
-    return AssertVisit::Continue;
-}
-
 //------------------------------------------------------------------------
 // optAssertionProp: try and optimize a relop via assertion propagation
 //
@@ -4400,7 +4338,7 @@ GenTree* Compiler::optAssertionPropGlobal_RelOp(ASSERT_VALARG_TP assertions,
     ValueNum op1VN = vnStore->VNConservativeNormalValue(op1->gtVNPair);
     ValueNum op2VN = vnStore->VNConservativeNormalValue(op2->gtVNPair);
 
-    // See if we can fold "X relop CNS" using TryGetRangeFromAssertions.
+    // IsVNIntegralConstant for op2VN is for reducing the TP regression, can be removed.
     int op2cns;
     if (op1->TypeIs(TYP_INT) && op2->TypeIs(TYP_INT) && vnStore->IsVNIntegralConstant(op2VN, &op2cns))
     {
@@ -4439,11 +4377,12 @@ GenTree* Compiler::optAssertionPropGlobal_RelOp(ASSERT_VALARG_TP assertions,
     {
         JITDUMP("Checking PHI [%06u] arguments for non-nullness\n", dspTreeID(op1))
         auto visitor = [this](ValueNum reachingVN, ASSERT_TP reachingAssertions) {
-            return optAssertionVNIsNonNull(reachingVN, reachingAssertions) ? AssertVisit::Continue : AssertVisit::Abort;
+            return optAssertionVNIsNonNull(reachingVN, reachingAssertions) ? RangeCheck::AssertVisit::Continue
+                                                                           : RangeCheck::AssertVisit::Abort;
         };
 
         ValueNum op1vn = vnStore->VNConservativeNormalValue(op1->gtVNPair);
-        if (optVisitReachingAssertions(op1vn, visitor) == AssertVisit::Continue)
+        if (RangeCheck::optVisitReachingAssertions(this, op1vn, visitor) == RangeCheck::AssertVisit::Continue)
         {
             JITDUMP("... all of PHI's arguments are never null!\n");
             assert(newTree->OperIs(GT_EQ, GT_NE));

src/coreclr/jit/compiler.h

@@ -8124,14 +8124,6 @@ class Compiler
     bool     optNonNullAssertionProp_Ind(ASSERT_VALARG_TP assertions, GenTree* indir);
     bool     optWriteBarrierAssertionProp_StoreInd(ASSERT_VALARG_TP assertions, GenTreeStoreInd* indir);
 
-    enum class AssertVisit
-    {
-        Continue,
-        Abort,
-    };
-    template <typename TAssertVisitor>
-    AssertVisit optVisitReachingAssertions(ValueNum vn, TAssertVisitor argVisitor);
-
     void optAssertionProp_RangeProperties(ASSERT_VALARG_TP assertions,
                                           GenTree*         tree,
                                           Statement*       stmt,

src/coreclr/jit/rangecheck.cpp

@@ -648,9 +648,9 @@ void RangeCheck::MergeEdgeAssertions(GenTreeLclVarCommon* lcl, ASSERT_VALARG_TP
 // Return Value:
 //    The computed range
 //
-Range RangeCheck::GetRangeFromAssertions(Compiler* comp, ValueNum num, ASSERT_VALARG_TP assertions)
+Range RangeCheck::GetRangeFromAssertions(Compiler* comp, ValueNum num, ASSERT_VALARG_TP assertions, int maxDepth)
 {
-    if (num == ValueNumStore::NoVN)
+    if (num == ValueNumStore::NoVN || maxDepth <= 0)
     {
         return Range(Limit(Limit::keUnknown));
     }
@@ -711,6 +711,17 @@ Range RangeCheck::GetRangeFromAssertions(Compiler* comp, ValueNum num, ASSERT_VA
                 }
                 break;
 
+            case VNF_NEG:
+            {
+                Range r1            = GetRangeFromAssertions(comp, funcApp.m_args[0], assertions, maxDepth - 1);
+                Range unaryOpResult = RangeOps::Negate(r1);
+                if (unaryOpResult.IsConstantRange())
+                {
+                    result = unaryOpResult;
+                }
+                break;
+            }
+
             case VNF_LSH:
             case VNF_ADD:
             case VNF_MUL:
@@ -721,8 +732,8 @@ Range RangeCheck::GetRangeFromAssertions(Compiler* comp, ValueNum num, ASSERT_VA
             case VNF_UMOD:
             {
                 // Get ranges of both operands and perform the same operation on the ranges.
-                Range r1 = GetRangeFromAssertions(comp, funcApp.m_args[0], assertions);
-                Range r2 = GetRangeFromAssertions(comp, funcApp.m_args[1], assertions);
+                Range r1          = GetRangeFromAssertions(comp, funcApp.m_args[0], assertions, maxDepth - 1);
+                Range r2          = GetRangeFromAssertions(comp, funcApp.m_args[1], assertions, maxDepth - 1);
                 Range binOpResult = Range(Limit(Limit::keUnknown));
                 switch (funcApp.m_func)
                 {
@@ -796,6 +807,19 @@ Range RangeCheck::GetRangeFromAssertions(Compiler* comp, ValueNum num, ASSERT_VA
         }
     }
 
+    Range phiRange = Range(Limit(Limit::keUndef));
+
+    if ((maxDepth > 1) &&
+        optVisitReachingAssertions(comp, num,
+                                   [comp, &phiRange, maxDepth](ValueNum reachingVN, ASSERT_TP reachingAssertions) {
+        Range edgeRange = GetRangeFromAssertions(comp, reachingVN, reachingAssertions, maxDepth - 1);
+        phiRange        = phiRange.LowerLimit().IsUndef() ? edgeRange : RangeOps::Union(phiRange, edgeRange);
+        return edgeRange.IsConstantRange() && !edgeRange.IsFullRange() ? AssertVisit::Continue : AssertVisit::Abort;
+    }) == AssertVisit::Continue)
+    {
+        result = phiRange;
+    }
+
     MergeEdgeAssertions(comp, num, ValueNumStore::NoVN, assertions, &result, false);
     assert(result.IsConstantRange());
     return result;