[turbofan] Instead of using properties, use a whitelist for store-store elimination.

src/compiler/store-store-elimination.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <iterator>
 
 #include "src/compiler/store-store-elimination.h"
 
 #include "src/compiler/all-nodes.h"
 #include "src/compiler/js-graph.h"
@@ skipping 129 matching lines @@
   const ZoneSet<Node*>& to_remove_const() { return to_remove_; }
 
   void Visit(Node* node);
 
  private:
   static bool IsEffectful(Node* node);
   void VisitEffectfulNode(Node* node);
   UnobservablesSet RecomputeUseIntersection(Node* node);
   UnobservablesSet RecomputeSet(Node* node, UnobservablesSet uses);
   static bool CannotObserveStoreField(Node* node);
-  static bool CanObserveAnything(Node* node);
 
   void MarkForRevisit(Node* node);
   bool HasBeenVisited(Node* node);
 
   JSGraph* jsgraph() const { return jsgraph_; }
   Zone* temp_zone() const { return temp_zone_; }
   ZoneVector<UnobservablesSet>& unobservable() { return unobservable_; }
   UnobservablesSet& unobservable_for_id(NodeId id) {
     DCHECK_LT(id, unobservable().size());
     return unobservable()[id];
@@ skipping 157 matching lines @@
           loaded_from->id(), offset);
 
       return uses.RemoveSameOffset(offset, temp_zone());
       break;
     }
     default:
       if (CannotObserveStoreField(node)) {
         TRACE("  #%d:%s can observe nothing, set stays unchanged", node->id(),
               node->op()->mnemonic());
         return uses;
-      } else if (CanObserveAnything(node)) {
-        TRACE("  #%d:%s can observe everything, recording empty set",
+      } else {
+        TRACE("  #%d:%s might observe anything, recording empty set",
               node->id(), node->op()->mnemonic());
         return unobservables_visited_empty_;
-      } else {
-        // It is safe to turn this check off in the future, but it is better
-        // to list opcodes in CannotObserveStoreField, in CanObserveAnything,
-        // or if you don't know, to add another case inside this DCHECK_EXTRA.
-        DCHECK_EXTRA(node->op()->opcode() == IrOpcode::kCall, "%s",
-                     node->op()->mnemonic());
-        TRACE(
-            "  cannot determine unobservables-set for #%d:%s; "
-            "conservatively recording empty set",
-            node->id(), node->op()->mnemonic());
-        return unobservables_visited_empty_;
       }
   }
   UNREACHABLE();
   return UnobservablesSet::Unvisited();
 }
 
 bool RedundantStoreFinder::CannotObserveStoreField(Node* node) {
-  Operator::Properties mask =
-      Operator::kNoRead | Operator::kNoDeopt | Operator::kNoThrow;
-
-  return (node->op()->properties() & mask) == mask ||
-         node->opcode() == IrOpcode::kAllocate ||
-         node->opcode() == IrOpcode::kCheckedLoad ||
+  return node->opcode() == IrOpcode::kCheckedLoad ||
          node->opcode() == IrOpcode::kLoadElement ||
-         node->opcode() == IrOpcode::kLoad;
-}
-
-bool RedundantStoreFinder::CanObserveAnything(Node* node) {
-  return !node->op()->HasProperty(Operator::kNoThrow) ||
-         !node->op()->HasProperty(Operator::kNoDeopt);
+         node->opcode() == IrOpcode::kLoad ||
+         node->opcode() == IrOpcode::kStore ||
+         node->opcode() == IrOpcode::kEffectPhi ||
+         node->opcode() == IrOpcode::kStoreElement ||
+         node->opcode() == IrOpcode::kCheckedStore ||
+         node->opcode() == IrOpcode::kUnsafePointerAdd ||
+         node->opcode() == IrOpcode::kRetain;
 }
 
 // Initialize unobservable_ with js_graph->graph->NodeCount() empty sets.
 RedundantStoreFinder::RedundantStoreFinder(JSGraph* js_graph, Zone* temp_zone)
     : jsgraph_(js_graph),
       temp_zone_(temp_zone),
       revisit_(temp_zone),
       in_revisit_(js_graph->graph()->NodeCount(), temp_zone),
       unobservable_(js_graph->graph()->NodeCount(),
                     UnobservablesSet::Unvisited(), temp_zone),
@@ skipping 41 matching lines @@
   if (!cur_set_changed) {
     // We will not be able to update the part of this chain above any more.
     // Exit.
     TRACE("+ No change: stabilized. Not visiting effect inputs.");
   } else {
     unobservable_for_id(node->id()) = before_set;
 
     // Mark effect inputs for visiting.
     for (int i = 0; i < node->op()->EffectInputCount(); i++) {
       Node* input = NodeProperties::GetEffectInput(node, i);
-      if (!CanObserveAnything(input) || !HasBeenVisited(input)) {
+      if (!HasBeenVisited(input)) {
         TRACE("    marking #%d:%s for revisit", input->id(),
               input->op()->mnemonic());
         MarkForRevisit(input);
       }
     }
   }
 }
 
 // Compute the intersection of the UnobservablesSets of all effect uses and
 // return it. This function only works if {node} has an effect use.
@@ skipping 142 matching lines @@
   return !(*this == other);
 }
 
 bool UnobservableStore::operator<(const UnobservableStore other) const {
   return (id_ < other.id_) || (id_ == other.id_ && offset_ < other.offset_);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8