[turbofan] Minor performance tweaks in escape analysis

src/compiler/escape-analysis.cc

 // Copyright 2015 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 "src/compiler/escape-analysis.h"
 
 #include <limits>
 
 #include "src/base/flags.h"
 #include "src/bootstrapper.h"
@@ skipping 148 matching lines @@
       changed = true;
       fields_[i] = other.fields_[i];
     }
   }
   return changed;
 }
 
 
 class VirtualState : public ZoneObject {
  public:
-  VirtualState(Node* owner, Zone* zone, size_t size);
-  VirtualState(Node* owner, const VirtualState& states);
+  VirtualState(NodeId owner, Zone* zone, size_t size);
+  VirtualState(NodeId owner, const VirtualState& states);
 
   VirtualObject* VirtualObjectFromAlias(size_t alias);
   VirtualObject* GetOrCreateTrackedVirtualObject(Alias alias, NodeId id,
                                                  size_t fields,
                                                  bool initialized, Zone* zone,
                                                  bool force_copy);
   void SetVirtualObject(Alias alias, VirtualObject* state);
   bool UpdateFrom(VirtualState* state, Zone* zone);
   bool MergeFrom(MergeCache* cache, Zone* zone, Graph* graph,
                  CommonOperatorBuilder* common, Node* control, int arity);
   size_t size() const { return info_.size(); }
-  Node* owner() const { return owner_; }
+  NodeId owner() const { return owner_; }
   VirtualObject* Copy(VirtualObject* obj, Alias alias);
   void SetCopyRequired() {
     for (VirtualObject* obj : info_) {
       if (obj) obj->SetCopyRequired();
     }
   }
 
  private:
   ZoneVector<VirtualObject*> info_;
-  Node* owner_;
+  NodeId owner_;
 
   DISALLOW_COPY_AND_ASSIGN(VirtualState);
 };
 
 
 class MergeCache : public ZoneObject {
  public:
   explicit MergeCache(Zone* zone)
       : states_(zone), objects_(zone), fields_(zone) {
     states_.reserve(5);
@@ skipping 62 matching lines @@
       fields_.push_back(field);
     }
     if (field != rep) {
       rep = nullptr;
     }
   }
   return rep;
 }
 
 
-VirtualState::VirtualState(Node* owner, Zone* zone, size_t size)
+VirtualState::VirtualState(NodeId owner, Zone* zone, size_t size)
     : info_(size, nullptr, zone), owner_(owner) {}
 
 
-VirtualState::VirtualState(Node* owner, const VirtualState& state)
+VirtualState::VirtualState(NodeId owner, const VirtualState& state)
     : info_(state.info_.size(), nullptr, state.info_.get_allocator().zone()),
       owner_(owner) {
   for (size_t i = 0; i < info_.size(); ++i) {
     if (state.info_[i]) {
       info_[i] = state.info_[i];
     }
   }
 }
 
 
@@ skipping 582 matching lines @@
   if (node->id() >= aliases_.size()) {
     return false;
   }
   return aliases_[node->id()] == kNotReachable;
 }
 
 
 void EscapeAnalysis::RunObjectAnalysis() {
   virtual_states_.resize(graph()->NodeCount());
   stack().push_back(graph()->start());
+  ZoneVector<Node*> danglers(zone());
   while (!stack().empty()) {
     Node* node = stack().back();
     stack().pop_back();
     if (Process(node)) {
       for (Edge edge : node->use_edges()) {
         Node* use = edge.from();
         if (IsNotReachable(use)) {
           continue;
         }
         if (NodeProperties::IsEffectEdge(edge)) {
           if ((use->opcode() != IrOpcode::kLoadField &&
                use->opcode() != IrOpcode::kLoadElement) ||
               !IsDanglingEffectNode(use)) {
             stack().push_back(use);
+          } else {
+            danglers.push_back(use);
           }
         }
       }
-      // First process loads: dangling loads are a problem otherwise.
-      for (Edge edge : node->use_edges()) {
-        Node* use = edge.from();
-        if (IsNotReachable(use)) {
-          continue;
-        }
-        if (NodeProperties::IsEffectEdge(edge)) {
-          if ((use->opcode() == IrOpcode::kLoadField ||
-               use->opcode() == IrOpcode::kLoadElement) &&
-              IsDanglingEffectNode(use)) {
-            stack().push_back(use);
-          }
-        }
-      }
+      stack().insert(stack().end(), danglers.begin(), danglers.end());
+      danglers.clear();
     }
   }
 #ifdef DEBUG
   if (FLAG_trace_turbo_escape) {
     DebugPrint();
   }
 #endif
 }
 
 
 bool EscapeStatusAnalysis::IsDanglingEffectNode(Node* node) {
   if (status_[node->id()] & kDanglingComputed) {
     return status_[node->id()] & kDangling;
   }
-  if (node->op()->EffectInputCount() == 0) return false;
-  if (node->op()->EffectOutputCount() == 0) return false;
-  if (node->op()->EffectInputCount() == 1 &&
-      NodeProperties::GetEffectInput(node)->opcode() == IrOpcode::kStart) {
+  if (node->op()->EffectInputCount() == 0 ||
+      node->op()->EffectOutputCount() == 0 ||
+      (node->op()->EffectInputCount() == 1 &&
+       NodeProperties::GetEffectInput(node)->opcode() == IrOpcode::kStart)) {
     // The start node is used as sentinel for nodes that are in general
     // effectful, but of which an analysis has determined that they do not
     // produce effects in this instance. We don't consider these nodes dangling.
     status_[node->id()] |= kDanglingComputed;
     return false;
   }
   for (Edge edge : node->use_edges()) {
     Node* use = edge.from();
     if (aliases_[use->id()] == kNotReachable) continue;
     if (NodeProperties::IsEffectEdge(edge)) {
       status_[node->id()] |= kDanglingComputed;
       return false;
     }
   }
   status_[node->id()] |= kDanglingComputed | kDangling;
   return true;
 }
 
 
 bool EscapeStatusAnalysis::IsEffectBranchPoint(Node* node) {
   if (status_[node->id()] & kBranchPointComputed) {
     return status_[node->id()] & kBranchPoint;
   }
   int count = 0;
   for (Edge edge : node->use_edges()) {
     Node* use = edge.from();
     if (aliases_[use->id()] == kNotReachable) continue;
     if (NodeProperties::IsEffectEdge(edge)) {
-      if ((node->opcode() == IrOpcode::kLoadField ||
-           node->opcode() == IrOpcode::kLoadElement ||
-           node->opcode() == IrOpcode::kLoad) &&
-          IsDanglingEffectNode(node))
+      if ((use->opcode() == IrOpcode::kLoadField ||
+           use->opcode() == IrOpcode::kLoadElement ||
+           use->opcode() == IrOpcode::kLoad) &&
+          IsDanglingEffectNode(use))
         continue;
       if (++count > 1) {
         status_[node->id()] |= kBranchPointComputed | kBranchPoint;
         return true;
       }
     }
   }
   status_[node->id()] |= kBranchPointComputed;
   return false;
 }
@@ skipping 68 matching lines @@
           }
         }
         break;
     }
   }
 }
 
 
 VirtualState* EscapeAnalysis::CopyForModificationAt(VirtualState* state,
                                                     Node* node) {
-  if (state->owner() != node) {
-    VirtualState* new_state = new (zone()) VirtualState(node, *state);
+  if (state->owner() != node->id()) {
+    VirtualState* new_state = new (zone()) VirtualState(node->id(), *state);
     virtual_states_[node->id()] = new_state;
     TRACE("Copying virtual state %p to new state %p at node %s#%d\n",
           static_cast<void*>(state), static_cast<void*>(new_state),
           node->op()->mnemonic(), node->id());
     return new_state;
   }
   return state;
 }
 
 
@@ skipping 17 matching lines @@
     PrintF("Dangeling effect node: #%d (%s)\n", node->id(),
            node->op()->mnemonic());
     UNREACHABLE();
   }
 #endif  // DEBUG
   Node* effect = NodeProperties::GetEffectInput(node);
   // Break the cycle for effect phis.
   if (effect->opcode() == IrOpcode::kEffectPhi &&
       virtual_states_[effect->id()] == nullptr) {
     VirtualState* state =
-        new (zone()) VirtualState(effect, zone(), AliasCount());
+        new (zone()) VirtualState(effect->id(), zone(), AliasCount());
     virtual_states_[effect->id()] = state;
     TRACE("Effect Phi #%d got new virtual state %p.\n", effect->id(),
           static_cast<void*>(virtual_states_[effect->id()]));
   }
   DCHECK_NOT_NULL(virtual_states_[effect->id()]);
   if (virtual_states_[node->id()]) {
     virtual_states_[node->id()]->UpdateFrom(virtual_states_[effect->id()],
                                             zone());
   } else {
     virtual_states_[node->id()] = virtual_states_[effect->id()];
     TRACE("Forwarding object state %p from %s#%d to %s#%d",
           static_cast<void*>(virtual_states_[effect->id()]),
           effect->op()->mnemonic(), effect->id(), node->op()->mnemonic(),
           node->id());
     if (IsEffectBranchPoint(effect) ||
         OperatorProperties::GetFrameStateInputCount(node->op()) > 0) {
       virtual_states_[node->id()]->SetCopyRequired();
       TRACE(", effect input %s#%d is branch point", effect->op()->mnemonic(),
             effect->id());
     }
     TRACE("\n");
   }
 }
 
 
 void EscapeAnalysis::ProcessStart(Node* node) {
   DCHECK_EQ(node->opcode(), IrOpcode::kStart);
   virtual_states_[node->id()] =
-      new (zone()) VirtualState(node, zone(), AliasCount());
+      new (zone()) VirtualState(node->id(), zone(), AliasCount());
 }
 
 
 bool EscapeAnalysis::ProcessEffectPhi(Node* node) {
   DCHECK_EQ(node->opcode(), IrOpcode::kEffectPhi);
   bool changed = false;
 
   VirtualState* mergeState = virtual_states_[node->id()];
   if (!mergeState) {
-    mergeState = new (zone()) VirtualState(node, zone(), AliasCount());
+    mergeState = new (zone()) VirtualState(node->id(), zone(), AliasCount());
     virtual_states_[node->id()] = mergeState;
     changed = true;
     TRACE("Effect Phi #%d got new virtual state %p.\n", node->id(),
           static_cast<void*>(mergeState));
   }
 
   cache_->Clear();
 
   TRACE("At Effect Phi #%d, merging states into %p:", node->id(),
         static_cast<void*>(mergeState));
 
   for (int i = 0; i < node->op()->EffectInputCount(); ++i) {
     Node* input = NodeProperties::GetEffectInput(node, i);
     VirtualState* state = virtual_states_[input->id()];
     if (state) {
       cache_->states().push_back(state);
       if (state == mergeState) {
-        mergeState = new (zone()) VirtualState(node, zone(), AliasCount());
+        mergeState =
+            new (zone()) VirtualState(node->id(), zone(), AliasCount());
         virtual_states_[node->id()] = mergeState;
         changed = true;
       }
     }
     TRACE(" %p (from %d %s)", static_cast<void*>(state), input->id(),
           input->op()->mnemonic());
   }
   TRACE("\n");
 
   if (cache_->states().size() == 0) {
@@ skipping 441 matching lines @@
         return true;
       }
     }
   }
   return false;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8