[turbofan] Store nodes use only MachineRepresentation, not MachineType.

src/compiler/change-lowering.cc

 // Copyright 2014 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/change-lowering.h"
 
 #include "src/address-map.h"
 #include "src/code-factory.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/linkage.h"
@@ skipping 69 matching lines @@
   Node* context = jsgraph()->NoContextConstant();
   Node* effect = graph()->NewNode(common()->BeginRegion(), graph()->start());
   if (!allocate_heap_number_operator_.is_set()) {
     CallDescriptor* descriptor = Linkage::GetStubCallDescriptor(
         isolate(), jsgraph()->zone(), callable.descriptor(), 0,
         CallDescriptor::kNoFlags, Operator::kNoThrow);
     allocate_heap_number_operator_.set(common()->Call(descriptor));
   }
   Node* heap_number = graph()->NewNode(allocate_heap_number_operator_.get(),
                                        target, context, effect, control);
-  Node* store = graph()->NewNode(machine()->Store(StoreRepresentation(
-                                     MachineType::Float64(), kNoWriteBarrier)),
-                                 heap_number, HeapNumberValueIndexConstant(),
-                                 value, heap_number, control);
+  Node* store = graph()->NewNode(
+      machine()->Store(StoreRepresentation(MachineRepresentation::kFloat64,
+                                           kNoWriteBarrier)),
+      heap_number, HeapNumberValueIndexConstant(), value, heap_number, control);
   return graph()->NewNode(common()->FinishRegion(), heap_number, store);
 }
 
 
 Node* ChangeLowering::ChangeInt32ToFloat64(Node* value) {
   return graph()->NewNode(machine()->ChangeInt32ToFloat64(), value);
 }
 
 
 Node* ChangeLowering::ChangeInt32ToSmi(Node* value) {
@@ skipping 374 matching lines @@
 
 
 Reduction ChangeLowering::StoreField(Node* node) {
   const FieldAccess& access = FieldAccessOf(node->op());
   Type* type = NodeProperties::GetType(node->InputAt(1));
   WriteBarrierKind kind = ComputeWriteBarrierKind(
       access.base_is_tagged, access.machine_type.representation(), access.type,
       type);
   Node* offset = jsgraph()->IntPtrConstant(access.offset - access.tag());
   node->InsertInput(graph()->zone(), 1, offset);
-  NodeProperties::ChangeOp(
-      node, machine()->Store(StoreRepresentation(access.machine_type, kind)));
+  NodeProperties::ChangeOp(node,
+                           machine()->Store(StoreRepresentation(
+                               access.machine_type.representation(), kind)));
   return Changed(node);
 }
 
 
 Node* ChangeLowering::ComputeIndex(const ElementAccess& access,
                                    Node* const key) {
   Node* index = key;
   const int element_size_shift =
       ElementSizeLog2Of(access.machine_type.representation());
   if (element_size_shift) {
@@ skipping 22 matching lines @@
   return Changed(node);
 }
 
 
 Reduction ChangeLowering::StoreElement(Node* node) {
   const ElementAccess& access = ElementAccessOf(node->op());
   Type* type = NodeProperties::GetType(node->InputAt(2));
   node->ReplaceInput(1, ComputeIndex(access, node->InputAt(1)));
   NodeProperties::ChangeOp(
       node, machine()->Store(StoreRepresentation(
-                access.machine_type,
+                access.machine_type.representation(),
                 ComputeWriteBarrierKind(access.base_is_tagged,
                                         access.machine_type.representation(),
                                         access.type, type))));
   return Changed(node);
 }
 
 
 Reduction ChangeLowering::Allocate(Node* node) {
   PretenureFlag pretenure = OpParameter<PretenureFlag>(node->op());
   if (pretenure == NOT_TENURED) {
@@ skipping 37 matching lines @@
 }
 
 
 MachineOperatorBuilder* ChangeLowering::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8