VN version

Author: EgorBo

src/coreclr/jit/assertionprop.cpp

@@ -2663,6 +2663,60 @@ AssertionIndex Compiler::optAssertionIsSubtype(GenTree* tree, GenTree* methodTab
     return NO_ASSERTION_INDEX;
 }
 
+//------------------------------------------------------------------------------
+// optVNStrengthReductionOnTree:
+//
+// Arguments:
+//    block  -  The block containing the tree.
+//    parent -  The parent node of the tree.
+//    tree   -  The tree node
+//
+// Return Value:
+//    Returns a new tree or nullptr if nothing is changed.
+//
+GenTree* Compiler::optVNStrengthReductionOnTree(BasicBlock* block, GenTree* parent, GenTree* tree)
+{
+    if (tree->IsHelperCall())
+    {
+        GenTreeCall* call = tree->AsCall();
+        switch (call->GetHelperNum())
+        {
+            // Fold "cast(cast(obj, cls), cls)" to "cast(obj, cls)"
+            case CORINFO_HELP_CHKCASTARRAY:
+            case CORINFO_HELP_CHKCASTANY:
+            case CORINFO_HELP_CHKCASTINTERFACE:
+            case CORINFO_HELP_CHKCASTCLASS:
+            case CORINFO_HELP_ISINSTANCEOFARRAY:
+            case CORINFO_HELP_ISINSTANCEOFCLASS:
+            case CORINFO_HELP_ISINSTANCEOFANY:
+            case CORINFO_HELP_ISINSTANCEOFINTERFACE:
+            {
+                GenTree* clsArg   = call->gtArgs.GetUserArgByIndex(0)->GetNode();
+                GenTree* objArg   = call->gtArgs.GetUserArgByIndex(1)->GetNode();
+                ValueNum clsArgVN = clsArg->gtVNPair.GetConservative();
+                ValueNum objArgVN = objArg->gtVNPair.GetConservative();
+
+                VNFuncApp funcApp;
+                if (vnStore->GetVNFunc(objArgVN, &funcApp) &&
+                    ((funcApp.m_func == VNF_CastClass) || (funcApp.m_func == VNF_IsInstanceOf)) &&
+                    (funcApp.m_args[0] == clsArgVN))
+                {
+                    // The outer cast is redundant, remove it and preserve its side effects
+                    // We do ignoreRoot here because the actual cast node is proven to never any exceptions
+                    // (namely, InvalidCastException).
+                    return gtWrapWithSideEffects(objArg, call, GTF_ALL_EFFECT, true);
+                }
+            }
+            break;
+
+            default:
+                break;
+        }
+    }
+
+    return nullptr;
+}
+
 //------------------------------------------------------------------------------
 // optVNConstantPropOnTree: Substitutes tree with an evaluated constant while
 //                          managing side-effects.
@@ -5098,41 +5152,30 @@ GenTree* Compiler::optAssertionProp_Call(ASSERT_VALARG_TP assertions, GenTreeCal
             (helper == CORINFO_HELP_CHKCASTCLASS) || (helper == CORINFO_HELP_CHKCASTANY) ||
             (helper == CORINFO_HELP_CHKCASTCLASS_SPECIAL))
         {
-            GenTree* arg1 = call->gtArgs.GetArgByIndex(1)->GetNode();
-            if (arg1->gtOper != GT_LCL_VAR)
+            GenTree* objArg = call->gtArgs.GetArgByIndex(1)->GetNode();
+            GenTree* clsArg = call->gtArgs.GetArgByIndex(0)->GetNode();
+
+            if (objArg->gtOper != GT_LCL_VAR)
             {
                 return nullptr;
             }
 
-            GenTree* arg2 = call->gtArgs.GetArgByIndex(0)->GetNode();
-
-            unsigned index = optAssertionIsSubtype(arg1, arg2, assertions);
+            unsigned index = optAssertionIsSubtype(objArg, clsArg, assertions);
             if (index != NO_ASSERTION_INDEX)
             {
-#ifdef DEBUG
-                if (verbose)
-                {
-                    printf("\nDid VN based subtype prop for index #%02u in " FMT_BB ":\n", index, compCurBB->bbNum);
-                    gtDispTree(call, nullptr, nullptr, true);
-                }
-#endif
-                GenTree* list = nullptr;
-                gtExtractSideEffList(call, &list, GTF_SIDE_EFFECT, true);
-                if (list != nullptr)
-                {
-                    arg1 = gtNewOperNode(GT_COMMA, call->TypeGet(), list, arg1);
-                    fgSetTreeSeq(arg1);
-                }
+                JITDUMP("\nDid VN based subtype prop for index #%02u in " FMT_BB ":\n", index, compCurBB->bbNum);
+                DISPTREE(call);
 
-                return optAssertionProp_Update(arg1, call, stmt);
+                objArg = gtWrapWithSideEffects(objArg, call, GTF_SIDE_EFFECT, true);
+                return optAssertionProp_Update(objArg, call, stmt);
             }
 
             // Leave a hint for fgLateCastExpansion that obj is never null.
             INDEBUG(AssertionIndex nonNullIdx = NO_ASSERTION_INDEX);
             INDEBUG(bool vnBased = false);
             // GTF_CALL_M_CAST_CAN_BE_EXPANDED check is to improve TP
             if (((call->gtCallMoreFlags & GTF_CALL_M_CAST_CAN_BE_EXPANDED) != 0) &&
-                optAssertionIsNonNull(arg1, assertions DEBUGARG(&vnBased) DEBUGARG(&nonNullIdx)))
+                optAssertionIsNonNull(objArg, assertions DEBUGARG(&vnBased) DEBUGARG(&nonNullIdx)))
             {
                 call->gtCallMoreFlags |= GTF_CALL_M_CAST_OBJ_NONNULL;
                 return optAssertionProp_Update(call, call, stmt);
@@ -6419,8 +6462,14 @@ Compiler::fgWalkResult Compiler::optVNConstantPropCurStmt(BasicBlock* block,
 
     if (newTree == nullptr)
     {
-        // Not propagated, keep going.
-        return WALK_CONTINUE;
+        // If it wasn't a constant, let's see if we can reduce the strength
+        // of the tree using VN.
+        newTree = optVNStrengthReductionOnTree(block, parent, tree);
+        if (newTree == nullptr)
+        {
+            // Not propagated, keep going.
+            return WALK_CONTINUE;
+        }
     }
 
     // TODO https://github.com/dotnet/runtime/issues/10450:

src/coreclr/jit/compiler.h

@@ -3515,6 +3515,11 @@ class Compiler
                               GenTreeFlags GenTreeFlags = GTF_SIDE_EFFECT,
                               bool         ignoreRoot   = false);
 
+    GenTree* gtWrapWithSideEffects(GenTree*     tree,
+                              GenTree*    sideEffectsSource,
+                              GenTreeFlags sideEffectsFlags = GTF_ALL_EFFECT,
+                              bool         ignoreRoot   = false);
+
     bool gtSplitTree(
         BasicBlock* block, Statement* stmt, GenTree* splitPoint, Statement** firstNewStmt, GenTree*** splitPointUse);
 
@@ -7713,6 +7718,7 @@ class Compiler
     fgWalkResult optVNConstantPropCurStmt(BasicBlock* block, Statement* stmt, GenTree* parent, GenTree* tree);
     GenTree* optVNConstantPropOnJTrue(BasicBlock* block, GenTree* test);
     GenTree* optVNConstantPropOnTree(BasicBlock* block, GenTree* parent, GenTree* tree);
+    GenTree* optVNStrengthReductionOnTree(BasicBlock* block, GenTree* parent, GenTree* tree);
     GenTree* optExtractSideEffListFromConst(GenTree* tree);
 
     AssertionIndex GetAssertionCount()

src/coreclr/jit/gentree.cpp

@@ -17063,6 +17063,38 @@ bool Compiler::gtSplitTree(
     return splitter.MadeChanges;
 }
 
+//------------------------------------------------------------------------
+// gtExtractSideEffList: Extracts side effects from sideEffectSource (if any)
+//    and wraps the input tree with a COMMA node with them.
+//
+// Arguments:
+//    tree             - the expression tree to wrap with side effects (if any)
+//    sideEffectSource - the expression tree to extract side effects from
+//    flags            - side effect flags to be considered
+//    ignoreRoot       - ignore side effects on the expression root node
+//
+// Return Value:
+//    The original tree wrapped with a COMMA node that contains the side effects
+//    or just the tree itself if sideEffectSource has no side effects.
+//
+GenTree* Compiler::gtWrapWithSideEffects(GenTree*     tree,
+                                         GenTree*     sideEffectSource,
+                                         GenTreeFlags sideEffectsFlags,
+                                         bool         ignoreRoot)
+{
+    GenTree* sideEffects = nullptr;
+    gtExtractSideEffList(sideEffectSource, &sideEffects, sideEffectsFlags, ignoreRoot);
+    if (sideEffects != nullptr)
+    {
+        tree = gtNewOperNode(GT_COMMA, tree->TypeGet(), sideEffects, tree);
+        if (fgNodeThreading == NodeThreading::AllTrees)
+        {
+            fgSetTreeSeq(tree);
+        }
+    }
+    return tree;
+}
+
 //------------------------------------------------------------------------
 // gtExtractSideEffList: Extracts side effects from the given expression.
 //

src/coreclr/jit/importer.cpp

@@ -1677,8 +1677,7 @@ GenTree* Compiler::impRuntimeLookupToTree(CORINFO_RESOLVED_TOKEN* pResolvedToken
         return slotPtrTree;
     }
 
-    slotPtrTree = gtNewIndir(TYP_I_IMPL, slotPtrTree, GTF_IND_NONFAULTING);
-    slotPtrTree->gtFlags &= ~GTF_GLOB_REF; // TODO-Bug?: this is a quirk. Can we mark this indirection invariant?
+    slotPtrTree = gtNewIndir(TYP_I_IMPL, slotPtrTree, GTF_IND_NONFAULTING | GTF_IND_INVARIANT);
 
     return slotPtrTree;
 }

src/coreclr/jit/morph.cpp

@@ -9653,22 +9653,8 @@ GenTree* Compiler::fgMorphSmpOp(GenTree* tree, MorphAddrContext* mac, bool* optA
                 }
                 else
                 {
-                    GenTree* op1SideEffects = nullptr;
-                    gtExtractSideEffList(op1, &op1SideEffects, GTF_ALL_EFFECT);
-                    if (op1SideEffects != nullptr)
-                    {
-                        DEBUG_DESTROY_NODE(tree);
-                        // Keep side-effects of op1
-                        tree = gtNewOperNode(GT_COMMA, TYP_INT, op1SideEffects, gtNewIconNode(0));
-                        JITDUMP("false with side effects:\n")
-                        DISPTREE(tree);
-                    }
-                    else
-                    {
-                        JITDUMP("false\n");
-                        DEBUG_DESTROY_NODE(tree, op1);
-                        tree = gtNewIconNode(0);
-                    }
+                    JITDUMP("false\n");
+                    tree = gtWrapWithSideEffects(gtNewIconNode(0), op1);
                 }
                 INDEBUG(tree->gtDebugFlags |= GTF_DEBUG_NODE_MORPHED);
                 return tree;