Remove GTF_DEAD.

This flag was only used by CSE to mark dead trees s.t. these trees
were not considered during CSE replacement. The same information,
however, can be provided by the gtCSEnum field: a tree with this
field set to NO_CSE is treated identically to a tree marked with
GTF_DEAD. The GTF_DEAD flag is therefore redundant and can be
eliminated.

This is part of dotnet/coreclr#5999.

Commit migrated from https://github.com/dotnet/coreclr/commit/a26d86b7d1562982b70776cffaeea8a633709dd0

diff --git a/src/coreclr/src/jit/compiler.cpp b/src/coreclr/src/jit/compiler.cpp
index 1302d11..aa280b5 100644 (file)
--- a/src/coreclr/src/jit/compiler.cpp
+++ b/src/coreclr/src/jit/compiler.cpp
@@ -8280,12 +8280,6 @@ int cTreeFlagsIR(Compiler *comp, GenTree *tree)
                 chars += printf("[IND_NONFAULTING]");
             }
         }
-#if FEATURE_ANYCSE
-        if (tree->gtFlags & GTF_DEAD)
-        {
-            chars += printf("[DEAD]");
-        }
-#endif
         if (tree->gtFlags & GTF_MAKE_CSE)
         {
             chars += printf("[MAKE_CSE]");

diff --git a/src/coreclr/src/jit/gentree.h b/src/coreclr/src/jit/gentree.h
index 30cb015..aa4d422 100644 (file)
--- a/src/coreclr/src/jit/gentree.h
+++ b/src/coreclr/src/jit/gentree.h
@@ -635,11 +635,14 @@ public:
     #define GTF_GLOB_EFFECT     (GTF_SIDE_EFFECT|GTF_GLOB_REF)
     #define GTF_ALL_EFFECT      (GTF_GLOB_EFFECT|GTF_ORDER_SIDEEFF)
 
-    // The extra flag GTF_DEAD is used to tell the consumer of these flags
-    // that we are calling in the context of performing a CSE, thus we 
+    // The extra flag GTF_IS_IN_CSE is used to tell the consumer of these flags
+    // that we are calling in the context of performing a CSE, thus we
     // should allow the run-once side effects of running a class constructor.
     //
-    #define GTF_PERSISTENT_SIDE_EFFECTS_IN_CSE (GTF_ASG|GTF_CALL|GTF_DEAD)
+    // The only requirement of this flag is that it not overlap any of the
+    // side-effect flags. The actual bit used is otherwise arbitrary.
+    #define GTF_IS_IN_CSE  GTF_MAKE_CSE
+    #define GTF_PERSISTENT_SIDE_EFFECTS_IN_CSE (GTF_ASG|GTF_CALL|GTF_IS_IN_CSE)
 
     // Can any side-effects be observed externally, say by a caller method?
     // For assignments, only assignments to global memory can be observed
@@ -673,10 +676,6 @@ public:
 #endif
     #define GTF_IND_NONFAULTING 0x00000800  // An indir that cannot fault.  GTF_SET_FLAGS is not used on indirs
 
-#if FEATURE_ANYCSE
-    #define GTF_DEAD            0x00001000  // this node won't be used any more
-#endif // FEATURE_ANYCSE
-
     #define GTF_MAKE_CSE        0x00002000  // Hoisted Expression: try hard to make this into CSE  (see optPerformHoistExpr)
     #define GTF_DONT_CSE        0x00004000  // don't bother CSE'ing this expr
     #define GTF_COLON_COND      0x00008000  // this node is conditionally executed (part of ? :)

diff --git a/src/coreclr/src/jit/optcse.cpp b/src/coreclr/src/jit/optcse.cpp
index ac7c34e..fa19445 100644 (file)
--- a/src/coreclr/src/jit/optcse.cpp
+++ b/src/coreclr/src/jit/optcse.cpp
@@ -87,7 +87,12 @@ Compiler::CSEdsc   *   Compiler::optCSEfindDsc(unsigned index)
 
 void                Compiler::optUnmarkCSE(GenTreePtr tree)
 {
-    noway_assert(IS_CSE_INDEX(tree->gtCSEnum));
+    if (!IS_CSE_INDEX(tree->gtCSEnum))
+    {
+        // This tree is not a CSE candidate, so there is nothing
+        // to do.
+        return;
+    }
 
     unsigned CSEnum = GET_CSE_INDEX(tree->gtCSEnum);
     CSEdsc * desc;
@@ -230,7 +235,6 @@ Compiler::fgWalkResult      Compiler::optUnmarkCSEs(GenTreePtr *pTree, fgWalkDat
             if (tree == op1)
             {
                 // This tree and all of its sub trees are being kept 
-                // so we skip marking with GTF_DEAD, etc...
                 return WALK_SKIP_SUBTREES;
             }
 
@@ -242,20 +246,14 @@ Compiler::fgWalkResult      Compiler::optUnmarkCSEs(GenTreePtr *pTree, fgWalkDat
         if (tree == keptTree)
         {
             // This tree and all of its sub trees are being kept 
-            // so we skip marking with GTF_DEAD, etc...
             return WALK_SKIP_SUBTREES;
         }
     }
 
     // This node is being removed from the graph of GenTreePtr
-    // Mark with GTF_DEAD, call optUnmarkCSE and 
-    // decrement the LclVar ref counts.
-    //
-    assert((tree->gtFlags & GTF_DEAD) == 0);
-    tree->gtFlags |= GTF_DEAD;
-
-    if  (IS_CSE_INDEX(tree->gtCSEnum))
-        comp->optUnmarkCSE(tree);
+    // Call optUnmarkCSE and  decrement the LclVar ref counts.
+    comp->optUnmarkCSE(tree);
+    assert(!IS_CSE_INDEX(tree->gtCSEnum));
 
     /* Look for any local variable references */
 
@@ -1713,13 +1711,8 @@ public:
             // Assert if we used DEBUG_DESTROY_NODE on this CSE exp 
             assert(exp->gtOper != GT_COUNT);
                 
-            /* Ignore the node if it's part of a removed CSE */
-            if  (exp->gtFlags & GTF_DEAD)
-                continue;
-                
             /* Ignore the node if it's not been marked as a CSE */
-                
-            if  (!IS_CSE_INDEX(exp->gtCSEnum))
+            if (!IS_CSE_INDEX(exp->gtCSEnum))
                 continue;
                 
             /* Make sure we update the weighted ref count correctly */

diff --git a/src/coreclr/src/jit/optimizer.cpp b/src/coreclr/src/jit/optimizer.cpp
index bcca2a6..21ebdc2 100644 (file)
--- a/src/coreclr/src/jit/optimizer.cpp
+++ b/src/coreclr/src/jit/optimizer.cpp
@@ -6832,8 +6832,7 @@ Compiler::fgWalkResult      Compiler::optRemoveTreeVisitor(GenTreePtr *pTree, fg
             //
             if (tree == op1)
             {
-                // This tree and all of its sub trees are being kept 
-                // so we skip marking with GTF_DEAD, etc...
+                // This tree and all of its sub trees are being kept.
                 return WALK_SKIP_SUBTREES;
             }
 
@@ -6844,8 +6843,7 @@ Compiler::fgWalkResult      Compiler::optRemoveTreeVisitor(GenTreePtr *pTree, fg
         }
         if (tree == keptTree)
         {
-            // This tree and all of its sub trees are being kept 
-            // so we skip marking with GTF_DEAD, etc...
+            // This tree and all of its sub trees are being kept.
             return WALK_SKIP_SUBTREES;
         }
     }