Revert of [turbofan] extend escape analysis to reduce CheckMaps

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 669 matching lines @@
     case IrOpcode::kStoreElement:
       ProcessStoreElement(node);
       break;
     case IrOpcode::kLoadField:
     case IrOpcode::kLoadElement: {
       if (Node* rep = object_analysis_->GetReplacement(node)) {
         if (IsAllocation(rep) && CheckUsesForEscape(node, rep)) {
           RevisitInputs(rep);
           RevisitUses(rep);
         }
-      } else {
-        Node* from = NodeProperties::GetValueInput(node, 0);
-        if (SetEscaped(from)) {
-          TRACE("Setting #%d (%s) to escaped because of unresolved load #%i\n",
-                from->id(), from->op()->mnemonic(), node->id());
-          RevisitInputs(from);
-          RevisitUses(from);
-        }
       }
-
       RevisitUses(node);
       break;
     }
     case IrOpcode::kPhi:
       if (!HasEntry(node)) {
         status_[node->id()] |= kTracked;
         RevisitUses(node);
       }
       if (!IsAllocationPhi(node) && SetEscaped(node)) {
         RevisitInputs(node);
@@ skipping 83 matching lines @@
         }
       // Fallthrough.
       case IrOpcode::kStoreField:
       case IrOpcode::kLoadField:
       case IrOpcode::kStoreElement:
       case IrOpcode::kLoadElement:
       case IrOpcode::kFrameState:
       case IrOpcode::kStateValues:
       case IrOpcode::kReferenceEqual:
       case IrOpcode::kFinishRegion:
-      case IrOpcode::kCheckMaps:
         if (IsEscaped(use) && SetEscaped(rep)) {
           TRACE(
               "Setting #%d (%s) to escaped because of use by escaping node "
               "#%d (%s)\n",
               rep->id(), rep->op()->mnemonic(), use->id(),
               use->op()->mnemonic());
           return true;
         }
         break;
       case IrOpcode::kObjectIsSmi:
@@ skipping 80 matching lines @@
       replacements_(zone),
       cycle_detection_(zone),
       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() {}
 
-bool EscapeAnalysis::Run() {
+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();
     RunObjectAnalysis();
     status_analysis_->RunStatusAnalysis();
-    return true;
-  } else {
-    return false;
   }
 }
 
 void EscapeStatusAnalysis::AssignAliases() {
   size_t max_size = 1024;
   size_t min_size = 32;
   size_t stack_size =
       std::min(std::max(graph()->NodeCount() / 5, min_size), max_size);
   stack_.reserve(stack_size);
   ResizeStatusVector();
@@ skipping 185 matching lines @@
       break;
     case IrOpcode::kLoadField:
       ProcessLoadField(node);
       break;
     case IrOpcode::kStoreElement:
       ProcessStoreElement(node);
       break;
     case IrOpcode::kLoadElement:
       ProcessLoadElement(node);
       break;
-    case IrOpcode::kCheckMaps:
-      ProcessCheckMaps(node);
-      break;
     case IrOpcode::kStart:
       ProcessStart(node);
       break;
     case IrOpcode::kEffectPhi:
       return ProcessEffectPhi(node);
       break;
     default:
       if (node->op()->EffectInputCount() > 0) {
         ForwardVirtualState(node);
       }
@@ skipping 17 matching lines @@
       case IrOpcode::kStoreField:
       case IrOpcode::kLoadField:
       case IrOpcode::kStoreElement:
       case IrOpcode::kLoadElement:
       case IrOpcode::kFrameState:
       case IrOpcode::kStateValues:
       case IrOpcode::kReferenceEqual:
       case IrOpcode::kFinishRegion:
       case IrOpcode::kObjectIsSmi:
         break;
-      case IrOpcode::kCheckMaps: {
-        CheckMapsParameters params = CheckMapsParametersOf(node->op());
-        if (params.flags() == CheckMapsFlag::kNone) break;
-      }  // Fallthrough.
       default:
         VirtualState* state = virtual_states_[node->id()];
         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",
                   status_analysis_->GetAlias(obj->id()), obj->id());
           }
@@ skipping 333 matching lines @@
   } else if (from->opcode() == IrOpcode::kPhi &&
              IsOffsetForFieldAccessCorrect(FieldAccessOf(node->op()))) {
     int offset = OffsetForFieldAccess(node);
     // Only binary phis are supported for now.
     ProcessLoadFromPhi(offset, from, node, state);
   } else {
     UpdateReplacement(state, node, nullptr);
   }
 }
 
-void EscapeAnalysis::ProcessCheckMaps(Node* node) {
-  DCHECK_EQ(node->opcode(), IrOpcode::kCheckMaps);
-  ForwardVirtualState(node);
-  Node* checked = ResolveReplacement(NodeProperties::GetValueInput(node, 0));
-  VirtualState* state = virtual_states_[node->id()];
-  if (VirtualObject* object = GetVirtualObject(state, checked)) {
-    if (!object->IsTracked()) {
-      if (status_analysis_->SetEscaped(node)) {
-        TRACE(
-            "Setting #%d (%s) to escaped because checked object #%i is not "
-            "tracked\n",
-            node->id(), node->op()->mnemonic(), object->id());
-      }
-      return;
-    }
-    CheckMapsParameters params = CheckMapsParametersOf(node->op());
-
-    Node* value = object->GetField(HeapObject::kMapOffset / kPointerSize);
-    if (value) {
-      value = ResolveReplacement(value);
-      // TODO(tebbi): We want to extend this beyond constant folding with a
-      // CheckMapsValue operator that takes the load-eliminated map value as
-      // input.
-      if (value->opcode() == IrOpcode::kHeapConstant &&
-          params.maps().contains(ZoneHandleSet<Map>(
-              Handle<Map>::cast(OpParameter<Handle<HeapObject>>(value))))) {
-        TRACE("CheckMaps #%i seems to be redundant (until now).\n", node->id());
-        return;
-      }
-    }
-  }
-  if (status_analysis_->SetEscaped(node)) {
-    TRACE("Setting #%d (%s) to escaped (checking #%i)\n", node->id(),
-          node->op()->mnemonic(), checked->id());
-  }
-}
-
 void EscapeAnalysis::ProcessLoadElement(Node* node) {
   DCHECK_EQ(node->opcode(), IrOpcode::kLoadElement);
   ForwardVirtualState(node);
   Node* from = ResolveReplacement(NodeProperties::GetValueInput(node, 0));
   VirtualState* state = virtual_states_[node->id()];
   Node* index_node = node->InputAt(1);
   NumberMatcher index(index_node);
   DCHECK(index_node->opcode() != IrOpcode::kInt32Constant &&
          index_node->opcode() != IrOpcode::kInt64Constant &&
          index_node->opcode() != IrOpcode::kFloat32Constant &&
@@ skipping 221 matching lines @@
     }
   }
   return false;
 }
 
 Graph* EscapeAnalysis::graph() const { return status_analysis_->graph(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8