[turbofan] Delay initialization 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 98 matching lines @@
   }
   bool AllFieldsClear() {
     for (size_t i = 0; i < fields_.size(); ++i) {
       if (fields_[i] != nullptr) {
         return false;
       }
     }
     return true;
   }
   bool UpdateFrom(const VirtualObject& other);
+  bool MergeFrom(MergeCache* cache, Node* at, Graph* graph,
+                 CommonOperatorBuilder* common);
   void SetObjectState(Node* node) { object_state_ = node; }
   Node* GetObjectState() const { return object_state_; }
   bool IsCopyRequired() const { return status_ & kCopyRequired; }
   void SetCopyRequired() { status_ |= kCopyRequired; }
   bool NeedCopyForModification() {
     if (!IsCopyRequired() || !IsInitialized()) {
       return false;
     }
     return true;
   }
 
   NodeId id() const { return id_; }
   void id(NodeId id) { id_ = id; }
 
  private:
+  bool MergeFields(size_t i, Node* at, MergeCache* cache, Graph* graph,
+                   CommonOperatorBuilder* common);
+
   NodeId id_;
   StatusFlags status_;
   ZoneVector<Node*> fields_;
   ZoneVector<bool> phi_;
   Node* object_state_;
   VirtualState* owner_;
 
   DISALLOW_COPY_AND_ASSIGN(VirtualObject);
 };
 
@@ skipping 25 matching lines @@
       : 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];
       }
     }
   }
 
   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);
+                 CommonOperatorBuilder* common, Node* at);
   size_t size() const { return info_.size(); }
   Node* owner() const { return owner_; }
   VirtualObject* Copy(VirtualObject* obj, Alias alias);
   void SetCopyRequired() {
     for (VirtualObject* obj : info_) {
       if (obj) obj->SetCopyRequired();
     }
   }
 
  private:
@@ skipping 84 matching lines @@
         static_cast<void*>(this), alias, obj->id(), static_cast<void*>(obj),
         static_cast<void*>(new_obj));
   info_[alias] = new_obj;
   return new_obj;
 }
 
 VirtualObject* VirtualState::VirtualObjectFromAlias(size_t alias) {
   return info_[alias];
 }
 
-VirtualObject* VirtualState::GetOrCreateTrackedVirtualObject(
-    Alias alias, NodeId id, size_t field_number, bool initialized, Zone* zone,
-    bool force_copy) {
-  if (!force_copy) {
-    if (VirtualObject* obj = VirtualObjectFromAlias(alias)) {
-      return obj;
-    }
-  }
-  VirtualObject* obj = new (zone) VirtualObject(id, this, zone, 0, initialized);
-  SetVirtualObject(alias, obj);
-  return obj;
-}
-
 void VirtualState::SetVirtualObject(Alias alias, VirtualObject* obj) {
   info_[alias] = obj;
 }
 
 bool VirtualState::UpdateFrom(VirtualState* from, Zone* zone) {
   if (from == this) return false;
   bool changed = false;
   for (Alias alias = 0; alias < size(); ++alias) {
     VirtualObject* ls = VirtualObjectFromAlias(alias);
     VirtualObject* rs = from->VirtualObjectFromAlias(alias);
@@ skipping 41 matching lines @@
     Node* input = NodeProperties::GetValueInput(phi, static_cast<int>(i));
     if (!IsEquivalentPhi(input, inputs[i])) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace
 
-Node* EscapeAnalysis::GetReplacementIfSame(ZoneVector<VirtualObject*>& objs) {
-  Node* rep = GetReplacement(objs.front()->id());
-  for (VirtualObject* obj : objs) {
-    if (GetReplacement(obj->id()) != rep) {
-      return nullptr;
+bool VirtualObject::MergeFields(size_t i, Node* at, MergeCache* cache,
+                                Graph* graph, CommonOperatorBuilder* common) {
+  bool changed = false;
+  int value_input_count = static_cast<int>(cache->fields().size());
+  Node* rep = GetField(i);
+  if (!rep || !IsCreatedPhi(i)) {
+    Node* control = NodeProperties::GetControlInput(at);
+    cache->fields().push_back(control);
+    Node* phi = graph->NewNode(
+        common->Phi(MachineRepresentation::kTagged, value_input_count),
+        value_input_count + 1, &cache->fields().front());
+    SetField(i, phi, true);
+#ifdef DEBUG
+    if (FLAG_trace_turbo_escape) {
+      PrintF("    Creating Phi #%d as merge of", phi->id());
+      for (int i = 0; i < value_input_count; i++) {
+        PrintF(" #%d (%s)", cache->fields()[i]->id(),
+               cache->fields()[i]->op()->mnemonic());
+      }
+      PrintF("\n");
+    }
+#endif
+    changed = true;
+  } else {
+    DCHECK(rep->opcode() == IrOpcode::kPhi);
+    for (int n = 0; n < value_input_count; ++n) {
+      Node* old = NodeProperties::GetValueInput(rep, n);
+      if (old != cache->fields()[n]) {
+        changed = true;
+        NodeProperties::ReplaceValueInput(rep, cache->fields()[n], n);
+      }
     }
   }
-  return rep;
+  return changed;
+}
+
+bool VirtualObject::MergeFrom(MergeCache* cache, Node* at, Graph* graph,
+                              CommonOperatorBuilder* common) {
+  DCHECK(at->opcode() == IrOpcode::kEffectPhi ||
+         at->opcode() == IrOpcode::kPhi);
+  bool changed = false;
+  for (size_t i = 0; i < field_count(); ++i) {
+    if (Node* field = cache->GetFields(i)) {
+      changed = changed || GetField(i) != field;
+      SetField(i, field);
+      TRACE("    Field %zu agree on rep #%d\n", i, field->id());
+    } else {
+      int arity = at->opcode() == IrOpcode::kEffectPhi
+                      ? at->op()->EffectInputCount()
+                      : at->op()->ValueInputCount();
+      if (cache->fields().size() == arity) {
+        changed = MergeFields(i, at, cache, graph, common) || changed;
+      } else {
+        if (GetField(i) != nullptr) {
+          TRACE("    Field %zu cleared\n", i);
+          changed = true;
+        }
+        SetField(i, nullptr);
+      }
+    }
+  }
+  return changed;
 }
 
 bool VirtualState::MergeFrom(MergeCache* cache, Zone* zone, Graph* graph,
-                             CommonOperatorBuilder* common, Node* control,
-                             int arity) {
+                             CommonOperatorBuilder* common, Node* at) {
   DCHECK_GT(cache->states().size(), 0u);
   bool changed = false;
   for (Alias alias = 0; alias < size(); ++alias) {
     cache->objects().clear();
     VirtualObject* mergeObject = VirtualObjectFromAlias(alias);
     bool copy_merge_object = false;
     size_t fields = std::numeric_limits<size_t>::max();
     for (VirtualState* state : cache->states()) {
       if (VirtualObject* obj = state->VirtualObjectFromAlias(alias)) {
         cache->objects().push_back(obj);
         if (mergeObject == obj) {
           copy_merge_object = true;
-          changed = true;
         }
         fields = std::min(obj->field_count(), fields);
       }
     }
     if (cache->objects().size() == cache->states().size()) {
-      mergeObject = GetOrCreateTrackedVirtualObject(
-          alias, cache->objects().front()->id(),
-          cache->objects().front()->IsInitialized(), fields, zone,
-          copy_merge_object);
+      if (!mergeObject) {
+        VirtualObject* obj = new (zone)
+            VirtualObject(cache->objects().front()->id(), this, zone, fields,
+                          cache->objects().front()->IsInitialized());
+        SetVirtualObject(alias, obj);
+        mergeObject = obj;
+        changed = true;
+      } else if (copy_merge_object) {
+        VirtualObject* obj = new (zone) VirtualObject(this, *mergeObject);
+        SetVirtualObject(alias, obj);
+        mergeObject = obj;
+        changed = true;
+      } else {
+        changed = mergeObject->ResizeFields(fields) || changed;
+      }
 #ifdef DEBUG
       if (FLAG_trace_turbo_escape) {
         PrintF("  Alias @%d, merging into %p virtual objects", alias,
                static_cast<void*>(mergeObject));
         for (size_t i = 0; i < cache->objects().size(); i++) {
           PrintF(" %p", static_cast<void*>(cache->objects()[i]));
         }
         PrintF("\n");
       }
 #endif  // DEBUG
-      changed = mergeObject->ResizeFields(fields) || changed;
-      for (size_t i = 0; i < fields; ++i) {
-        if (Node* field = cache->GetFields(i)) {
-          changed = changed || mergeObject->GetField(i) != field;
-          mergeObject->SetField(i, field);
-          TRACE("    Field %zu agree on rep #%d\n", i, field->id());
-        } else {
-          int value_input_count = static_cast<int>(cache->fields().size());
-          if (cache->fields().size() == arity) {
-            Node* rep = mergeObject->GetField(i);
-            if (!rep || !mergeObject->IsCreatedPhi(i)) {
-              cache->fields().push_back(control);
-              Node* phi = graph->NewNode(
-                  common->Phi(MachineRepresentation::kTagged,
-                              value_input_count),
-                  value_input_count + 1, &cache->fields().front());
-              mergeObject->SetField(i, phi, true);
-#ifdef DEBUG
-              if (FLAG_trace_turbo_escape) {
-                PrintF("    Creating Phi #%d as merge of", phi->id());
-                for (int i = 0; i < value_input_count; i++) {
-                  PrintF(" #%d (%s)", cache->fields()[i]->id(),
-                         cache->fields()[i]->op()->mnemonic());
-                }
-                PrintF("\n");
-              }
-#endif  // DEBUG
-              changed = true;
-            } else {
-              DCHECK(rep->opcode() == IrOpcode::kPhi);
-              for (int n = 0; n < value_input_count; ++n) {
-                Node* old = NodeProperties::GetValueInput(rep, n);
-                if (old != cache->fields()[n]) {
-                  changed = true;
-                  NodeProperties::ReplaceValueInput(rep, cache->fields()[n], n);
-                }
-              }
-            }
-          } else {
-            if (mergeObject->GetField(i) != nullptr) {
-              TRACE("    Field %zu cleared\n", i);
-              changed = true;
-            }
-            mergeObject->SetField(i, nullptr);
-          }
-        }
-      }
+      changed = mergeObject->MergeFrom(cache, at, graph, common) || changed;
     } else {
       if (mergeObject) {
         TRACE("  Alias %d, virtual object removed\n", alias);
         changed = true;
       }
       SetVirtualObject(alias, nullptr);
     }
   }
   return changed;
 }
 
 EscapeStatusAnalysis::EscapeStatusAnalysis(EscapeAnalysis* object_analysis,
                                            Graph* graph, Zone* zone)
     : stack_(zone),
       object_analysis_(object_analysis),
       graph_(graph),
       zone_(zone),
-      status_(graph->NodeCount(), kUnknown, zone),
+      status_(zone),
       next_free_alias_(0),
       status_stack_(zone),
       aliases_(zone) {}
 
 EscapeStatusAnalysis::~EscapeStatusAnalysis() {}
 
 bool EscapeStatusAnalysis::HasEntry(Node* node) {
   return status_[node->id()] & (kTracked | kEscaped);
 }
 
@@ skipping 271 matching lines @@
                                Zone* zone)
     : status_analysis_(this, graph, zone),
       common_(common),
       virtual_states_(zone),
       replacements_(zone),
       cache_(nullptr) {}
 
 EscapeAnalysis::~EscapeAnalysis() {}
 
 void EscapeAnalysis::Run() {
+#ifndef DEBUG
+  if (FLAG_trace_turbo_escape) {

[Michael Starzinger, 2016/02/04 10:10:17]

nit: This can be achieve more easily by moving the respective flag into the
"debug only" section of the flag-definitions.h file.

+    PrintF("--trace-turbo-escape only supported in DEBUG builds\n.");
+  }
+#endif
   replacements_.resize(graph()->NodeCount());
   status_analysis_.AssignAliases();
   if (status_analysis_.AliasCount() > 0) {
     cache_ = new (zone()) MergeCache(zone());
     replacements_.resize(graph()->NodeCount());
     status_analysis_.ResizeStatusVector();
     RunObjectAnalysis();
     status_analysis_.RunStatusAnalysis();
   }
 }
 
 void EscapeStatusAnalysis::AssignAliases() {
   size_t max_size = 1024;
   size_t min_size = 32;
-  size_t stack_size = std::min(
-      std::max(
-          std::min(graph()->NodeCount() / 5, graph()->NodeCount() / 20 + 128),
-          min_size),
-      max_size);
+  size_t stack_size =
+      std::min(std::max(graph()->NodeCount() / 5, min_size), max_size);
   stack_.reserve(stack_size);
   ResizeStatusVector();
   stack_.push_back(graph()->end());
   CHECK_LT(graph()->NodeCount(), kUntrackable);
   aliases_.resize(graph()->NodeCount(), kNotReachable);
   aliases_[graph()->end()->id()] = kUntrackable;
   status_stack_.reserve(8);
   TRACE("Discovering trackable nodes");
   while (!stack_.empty()) {
     Node* node = stack_.back();
@@ skipping 199 matching lines @@
       case IrOpcode::kStoreElement:
       case IrOpcode::kLoadElement:
       case IrOpcode::kFrameState:
       case IrOpcode::kStateValues:
       case IrOpcode::kReferenceEqual:
       case IrOpcode::kFinishRegion:
       case IrOpcode::kObjectIsSmi:
         break;
       default:
         VirtualState* state = virtual_states_[node->id()];
-        if (VirtualObject* obj = ResolveVirtualObject(state, input)) {
+        if (VirtualObject* obj =
+                GetVirtualObject(state, ResolveReplacement(input))) {
           if (!obj->AllFieldsClear()) {
             obj = CopyForModificationAt(obj, state, node);
             obj->ClearAllFields();
             TRACE("Cleared all fields of @%d:#%d\n", GetAlias(obj->id()),
                   obj->id());
           }
         }
         break;
     }
   }
@@ skipping 91 matching lines @@
     }
     TRACE(" %p (from %d %s)", static_cast<void*>(state), input->id(),
           input->op()->mnemonic());
   }
   TRACE("\n");
 
   if (cache_->states().size() == 0) {
     return changed;
   }
 
-  changed = mergeState->MergeFrom(cache_, zone(), graph(), common(),
-                                  NodeProperties::GetControlInput(node),
-                                  node->op()->EffectInputCount()) ||
-            changed;
+  changed =
+      mergeState->MergeFrom(cache_, zone(), graph(), common(), node) || changed;
 
   TRACE("Merge %s the node.\n", changed ? "changed" : "did not change");
 
   if (changed) {
     status_analysis_.ResizeStatusVector();
   }
   return changed;
 }
 
 void EscapeAnalysis::ProcessAllocation(Node* node) {
@@ skipping 105 matching lines @@
   return status_analysis_.SetEscaped(node);
 }
 
 VirtualObject* EscapeAnalysis::GetVirtualObject(Node* at, NodeId id) {
   if (VirtualState* states = virtual_states_[at->id()]) {
     return states->VirtualObjectFromAlias(GetAlias(id));
   }
   return nullptr;
 }
 
-VirtualObject* EscapeAnalysis::ResolveVirtualObject(VirtualState* state,
-                                                    Node* node) {
-  return GetVirtualObject(state, ResolveReplacement(node));
-}
-
 bool EscapeAnalysis::CompareVirtualObjects(Node* left, Node* right) {
   DCHECK(IsVirtual(left) && IsVirtual(right));
   left = ResolveReplacement(left);
   right = ResolveReplacement(right);
   if (IsEquivalentPhi(left, right)) {
     return true;
   }
   return false;
 }
 
 int EscapeAnalysis::OffsetFromAccess(Node* node) {
   DCHECK(OpParameter<FieldAccess>(node).offset % kPointerSize == 0);
   return OpParameter<FieldAccess>(node).offset / kPointerSize;
 }
 
-void EscapeAnalysis::ProcessLoadFromPhi(int offset, Node* from, Node* node,
+void EscapeAnalysis::ProcessLoadFromPhi(int offset, Node* from, Node* load,
                                         VirtualState* state) {
-  TRACE("Load #%d from phi #%d", node->id(), from->id());
+  TRACE("Load #%d from phi #%d", load->id(), from->id());
 
   cache_->fields().clear();
-  for (int i = 0; i < node->op()->ValueInputCount(); ++i) {
-    Node* input = NodeProperties::GetValueInput(node, i);
+  for (int i = 0; i < load->op()->ValueInputCount(); ++i) {
+    Node* input = NodeProperties::GetValueInput(load, i);
     cache_->fields().push_back(input);
   }
 
   cache_->LoadVirtualObjectsForFieldsFrom(state,
                                           status_analysis_.GetAliasMap());
   if (cache_->objects().size() == cache_->fields().size()) {
     cache_->GetFields(offset);
     if (cache_->fields().size() == cache_->objects().size()) {
-      Node* rep = replacement(node);
+      Node* rep = replacement(load);
       if (!rep || !IsEquivalentPhi(rep, cache_->fields())) {
         int value_input_count = static_cast<int>(cache_->fields().size());
         cache_->fields().push_back(NodeProperties::GetControlInput(from));
         Node* phi = graph()->NewNode(
             common()->Phi(MachineRepresentation::kTagged, value_input_count),
             value_input_count + 1, &cache_->fields().front());
         status_analysis_.ResizeStatusVector();
-        SetReplacement(node, phi);
+        SetReplacement(load, phi);
         TRACE(" got phi created.\n");
       } else {
         TRACE(" has already phi #%d.\n", rep->id());
       }
     } else {
       TRACE(" has incomplete field info.\n");
     }
   } else {
     TRACE(" has incomplete virtual object info.\n");
   }
@@ skipping 135 matching lines @@
               obj->id());
       }
     }
   }
 }
 
 Node* EscapeAnalysis::GetOrCreateObjectState(Node* effect, Node* node) {
   if ((node->opcode() == IrOpcode::kFinishRegion ||
        node->opcode() == IrOpcode::kAllocate) &&
       IsVirtual(node)) {
-    if (VirtualObject* vobj =
-            ResolveVirtualObject(virtual_states_[effect->id()], node)) {
+    if (VirtualObject* vobj = GetVirtualObject(virtual_states_[effect->id()],
+                                               ResolveReplacement(node))) {
       if (Node* object_state = vobj->GetObjectState()) {
         return object_state;
       } else {
         cache_->fields().clear();
         for (size_t i = 0; i < vobj->field_count(); ++i) {
           if (Node* field = vobj->GetField(i)) {
             cache_->fields().push_back(field);
           }
         }
         int input_count = static_cast<int>(cache_->fields().size());
@@ skipping 73 matching lines @@
         return true;
       }
     }
   }
   return false;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8