[turbofan] Introduce initial support for TypedArrays.

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 45 matching lines @@
     case IrOpcode::kTransitionElementsKind:
       return ReduceTransitionElementsKind(node);
     case IrOpcode::kLoadField:
       return ReduceLoadField(node);
     case IrOpcode::kStoreField:
       return ReduceStoreField(node);
     case IrOpcode::kLoadElement:
       return ReduceLoadElement(node);
     case IrOpcode::kStoreElement:
       return ReduceStoreElement(node);
+    case IrOpcode::kStoreTypedElement:
+      return ReduceStoreTypedElement(node);
     case IrOpcode::kEffectPhi:
       return ReduceEffectPhi(node);
     case IrOpcode::kDead:
       break;
     case IrOpcode::kStart:
       return ReduceStart(node);
     default:
       return ReduceOtherNode(node);
   }
   return NoChange();
@@ skipping 372 matching lines @@
       break;
     case MachineRepresentation::kFloat64:
     case MachineRepresentation::kSimd128:
     case MachineRepresentation::kTagged:
       state = state->AddElement(object, index, new_value, zone());
       break;
   }
   return UpdateState(node, state);
 }
 
+Reduction LoadElimination::ReduceStoreTypedElement(Node* node) {
+  Node* const effect = NodeProperties::GetEffectInput(node);
+  AbstractState const* state = node_states_.Get(effect);
+  if (state == nullptr) return NoChange();
+  return UpdateState(node, state);
+}
+
 Reduction LoadElimination::ReduceEffectPhi(Node* node) {
   Node* const effect0 = NodeProperties::GetEffectInput(node, 0);
   Node* const control = NodeProperties::GetControlInput(node);
   AbstractState const* state0 = node_states_.Get(effect0);
   if (state0 == nullptr) return NoChange();
   if (control->opcode() == IrOpcode::kLoop) {
     // Here we rely on having only reducible loops:
     // The loop entry edge always dominates the header, so we can just take
     // the state from the first input, and compute the loop state based on it.
     AbstractState const* state = ComputeLoopState(node, state0);
@@ skipping 96 matching lines @@
       for (int i = 0; i < current->op()->EffectInputCount(); ++i) {
         queue.push(NodeProperties::GetEffectInput(current, i));
       }
     }
   }
   return state;
 }
 
 // static
 int LoadElimination::FieldIndexOf(FieldAccess const& access) {
-  switch (access.machine_type.representation()) {
+  MachineRepresentation rep = access.machine_type.representation();
+  switch (rep) {
     case MachineRepresentation::kNone:
     case MachineRepresentation::kBit:
       UNREACHABLE();
       break;
+    case MachineRepresentation::kWord32:
+    case MachineRepresentation::kWord64:
+      if (rep != MachineType::PointerRepresentation()) {
+        return -1;  // We currently only track pointer size fields.
+      }
+      break;
     case MachineRepresentation::kWord8:
     case MachineRepresentation::kWord16:
-    case MachineRepresentation::kWord32:
-    case MachineRepresentation::kWord64:
     case MachineRepresentation::kFloat32:
       return -1;  // Currently untracked.
     case MachineRepresentation::kFloat64:
     case MachineRepresentation::kSimd128:
     case MachineRepresentation::kTagged:
       // TODO(bmeurer): Check that we never do overlapping load/stores of
       // individual parts of Float64/Simd128 values.
       break;
   }
   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