[turbofan] Refactor the lowering of element/property accesses.

src/compiler/load-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 "src/compiler/load-elimination.h"
 
 #include "src/compiler/node-properties.h"
 #include "src/compiler/simplified-operator.h"
 
 namespace v8 {
@@ skipping 294 matching lines @@
   FieldAccess const& access = FieldAccessOf(node->op());
   Node* const object = NodeProperties::GetValueInput(node, 0);
   Node* const effect = NodeProperties::GetEffectInput(node);
   AbstractState const* state = node_states_.Get(effect);
   if (state == nullptr) return NoChange();
   int field_index = FieldIndexOf(access);
   if (field_index >= 0) {
     if (Node* const replacement = state->LookupField(object, field_index)) {
       // Make sure the {replacement} has at least as good type
       // as the original {node}.
-      if (NodeProperties::GetType(replacement)
+      if (!replacement->IsDead() &&
+          NodeProperties::GetType(replacement)
               ->Is(NodeProperties::GetType(node))) {
         ReplaceWithValue(node, replacement, effect);
-        DCHECK(!replacement->IsDead());
         return Replace(replacement);
       }
     }
     state = state->AddField(object, field_index, node, zone());
   }
   return UpdateState(node, state);
 }
 
 Reduction LoadElimination::ReduceStoreField(Node* node) {
   FieldAccess const& access = FieldAccessOf(node->op());
@@ skipping 21 matching lines @@
 
 Reduction LoadElimination::ReduceLoadElement(Node* node) {
   Node* const object = NodeProperties::GetValueInput(node, 0);
   Node* const index = NodeProperties::GetValueInput(node, 1);
   Node* const effect = NodeProperties::GetEffectInput(node);
   AbstractState const* state = node_states_.Get(effect);
   if (state == nullptr) return NoChange();
   if (Node* const replacement = state->LookupElement(object, index)) {
     // Make sure the {replacement} has at least as good type
     // as the original {node}.
-    if (NodeProperties::GetType(replacement)
+    if (!replacement->IsDead() &&
+        NodeProperties::GetType(replacement)
             ->Is(NodeProperties::GetType(node))) {
       ReplaceWithValue(node, replacement, effect);
-      DCHECK(!replacement->IsDead());
       return Replace(replacement);
     }
   }
   state = state->AddElement(object, index, node, zone());
   return UpdateState(node, state);
 }
 
 Reduction LoadElimination::ReduceStoreElement(Node* node) {
   ElementAccess const& access = ElementAccessOf(node->op());
   Node* const object = NodeProperties::GetValueInput(node, 0);
@@ skipping 168 matching lines @@
   DCHECK_EQ(kTaggedBase, access.base_is_tagged);
   DCHECK_EQ(0, access.offset % kPointerSize);
   int field_index = access.offset / kPointerSize;
   if (field_index >= static_cast<int>(kMaxTrackedFields)) return -1;
   return field_index;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8