[Turbofan] Run escape analysis concurrently.

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 182 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,
+  bool MergeFrom(MergeCache* cache, Zone* zone, 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);
+  bool MergeFields(size_t i, Zone* zone, 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 193 matching lines @@
   }
   for (size_t i = 0; i < inputs.size(); ++i) {
     Node* input = NodeProperties::GetValueInput(phi, static_cast<int>(i));
     if (!IsEquivalentPhi(input, inputs[i])) {
       return false;
     }
   }
   return true;
 }
 
+Type* GetTypeForPhi(Node* phi, Zone* zone) {
+  int arity = phi->op()->ValueInputCount();
+  Type* type = Type::None();
+  for (int i = 1; i < arity; ++i) {
+    Node* inner_node = NodeProperties::GetValueInput(phi, i);
+    Type* inner_type = NodeProperties::IsTyped(inner_node)
+                           ? NodeProperties::GetType(inner_node)
+                           : Type::None();
+    type = Type::Union(type, inner_type, zone);
+  }
+  return type;
+}
 }  // namespace
 
-bool VirtualObject::MergeFields(size_t i, Node* at, MergeCache* cache,
-                                Graph* graph, CommonOperatorBuilder* common) {
+bool VirtualObject::MergeFields(size_t i, Zone* zone, 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);
+    NodeProperties::SetType(phi, GetTypeForPhi(phi, zone));
+
 #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 changed;
 }
 
-bool VirtualObject::MergeFrom(MergeCache* cache, Node* at, Graph* graph,
-                              CommonOperatorBuilder* common) {
+bool VirtualObject::MergeFrom(MergeCache* cache, Zone* zone, 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) {
     Node* field = cache->GetFields(i);
     if (field && !IsCreatedPhi(i)) {
       changed = changed || GetField(i) != field;
       SetField(i, field);
       TRACE("    Field %zu agree on rep #%d\n", i, field->id());
     } else {
       size_t arity = at->opcode() == IrOpcode::kEffectPhi
                          ? at->op()->EffectInputCount()
                          : at->op()->ValueInputCount();
       if (cache->fields().size() == arity &&
           (GetField(i) || !IsCreatedPhi(i))) {
-        changed = MergeFields(i, at, cache, graph, common) || changed;
+        changed = MergeFields(i, zone, at, cache, graph, common) || changed;
       } else {
         if (GetField(i) != nullptr) {
           TRACE("    Field %zu cleared\n", i);
           changed = true;
         }
         SetField(i, nullptr);
       }
     }
   }
   return changed;
@@ skipping 36 matching lines @@
 #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->MergeFrom(cache, at, graph, common) || changed;
+      changed =
+          mergeObject->MergeFrom(cache, zone, at, graph, common) || changed;
     } else {
       if (mergeObject) {
         TRACE("  Alias %d, virtual object removed\n", alias);
         changed = true;
       }
       SetVirtualObject(alias, nullptr);
     }
   }
   return changed;
 }
@@ skipping 301 matching lines @@
 
 EscapeAnalysis::EscapeAnalysis(Graph* graph, CommonOperatorBuilder* common,
                                Zone* zone)
     : zone_(zone),
       slot_not_analyzed_(graph->NewNode(common->NumberConstant(0x1c0debad))),
       common_(common),
       status_analysis_(new (zone) EscapeStatusAnalysis(this, graph, zone)),
       virtual_states_(zone),
       replacements_(zone),
       cycle_detection_(zone),
-      cache_(nullptr) {}
+      cache_(nullptr) {
+  // Type slot_not_analyzed_ manually.
+  double v = OpParameter<double>(slot_not_analyzed_);
+  NodeProperties::SetType(slot_not_analyzed_, Type::Range(v, v, zone));
+}
 
 EscapeAnalysis::~EscapeAnalysis() {}
 
 void EscapeAnalysis::Run() {
   replacements_.resize(graph()->NodeCount());
   status_analysis_->AssignAliases();
   if (status_analysis_->AliasCount() > 0) {
     cache_ = new (zone()) MergeCache(zone());
     replacements_.resize(graph()->NodeCount());
     status_analysis_->ResizeStatusVector();
@@ skipping 516 matching lines @@
   if (cache_->objects().size() == cache_->fields().size()) {
     cache_->GetFields(offset);
     if (cache_->fields().size() == cache_->objects().size()) {
       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());
+        NodeProperties::SetType(phi, GetTypeForPhi(phi, zone()));
         status_analysis_->ResizeStatusVector();
         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 {
@@ skipping 173 matching lines @@
         cache_->fields().clear();
         for (size_t i = 0; i < vobj->field_count(); ++i) {
           if (Node* field = vobj->GetField(i)) {
             cache_->fields().push_back(ResolveReplacement(field));
           }
         }
         int input_count = static_cast<int>(cache_->fields().size());
         Node* new_object_state =
             graph()->NewNode(common()->ObjectState(input_count), input_count,
                              &cache_->fields().front());
+        NodeProperties::SetType(new_object_state, Type::Internal());
         vobj->SetObjectState(new_object_state);
         TRACE(
             "Creating object state #%d for vobj %p (from node #%d) at effect "
             "#%d\n",
             new_object_state->id(), static_cast<void*>(vobj), node->id(),
             effect->id());
         // Now fix uses of other objects.
         for (size_t i = 0; i < vobj->field_count(); ++i) {
           if (Node* field = vobj->GetField(i)) {
             if (Node* field_object_state =
@@ skipping 79 matching lines @@
     }
   }
   return false;
 }
 
 Graph* EscapeAnalysis::graph() const { return status_analysis_->graph(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8