Merge pull request #6077 from pgavlin/RemoveGtfDead

Remove GTF_DEAD.

Author: pgavlin

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]");

src/jit/gentree.h

@@ -635,11 +635,14 @@ struct GenTree
     #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 @@ struct GenTree
 #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 ? :)

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 @@ class CSE_Heuristic
             // 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 */

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;
         }
     }