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

test/unittests/compiler/machine-operator-unittest.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/machine-operator.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/compiler/operator-properties.h"
 #include "test/unittests/test-utils.h"
 
@@ skipping 25 matching lines @@
 const MachineRepresentation kMachineReps[] = {MachineRepresentation::kWord32,
                                               MachineRepresentation::kWord64};
 
 
 const MachineType kMachineTypesForAccess[] = {
     MachineType::Float32(), MachineType::Float64(),  MachineType::Int8(),
     MachineType::Uint8(),   MachineType::Int16(),    MachineType::Uint16(),
     MachineType::Int32(),   MachineType::Uint32(),   MachineType::Int64(),
     MachineType::Uint64(),  MachineType::AnyTagged()};
 
+
+const MachineRepresentation kRepresentationsForStore[] = {
+    MachineRepresentation::kFloat32, MachineRepresentation::kFloat64,
+    MachineRepresentation::kWord8,   MachineRepresentation::kWord16,
+    MachineRepresentation::kWord32,  MachineRepresentation::kWord64,
+    MachineRepresentation::kTagged};
+
 }  // namespace
 
 
 // -----------------------------------------------------------------------------
 // Load operator.
 
 
 typedef MachineOperatorTestWithParam<LoadRepresentation>
     MachineLoadOperatorTest;
 
@@ skipping 38 matching lines @@
     ::testing::Combine(::testing::ValuesIn(kMachineReps),
                        ::testing::ValuesIn(kMachineTypesForAccess)));
 
 
 // -----------------------------------------------------------------------------
 // Store operator.
 
 
 class MachineStoreOperatorTest
     : public MachineOperatorTestWithParam<
-          ::testing::tuple<MachineType, WriteBarrierKind> > {
+          ::testing::tuple<MachineRepresentation, WriteBarrierKind> > {
  protected:
   StoreRepresentation GetParam() const {
     return StoreRepresentation(
-        ::testing::get<0>(MachineOperatorTestWithParam<
-            ::testing::tuple<MachineType, WriteBarrierKind> >::GetParam()),
-        ::testing::get<1>(MachineOperatorTestWithParam<
-            ::testing::tuple<MachineType, WriteBarrierKind> >::GetParam()));
+        ::testing::get<0>(
+            MachineOperatorTestWithParam< ::testing::tuple<
+                MachineRepresentation, WriteBarrierKind> >::GetParam()),
+        ::testing::get<1>(
+            MachineOperatorTestWithParam< ::testing::tuple<
+                MachineRepresentation, WriteBarrierKind> >::GetParam()));
   }
 };
 
 
 TEST_P(MachineStoreOperatorTest, InstancesAreGloballyShared) {
   MachineOperatorBuilder machine1(zone(), representation());
   MachineOperatorBuilder machine2(zone(), representation());
   EXPECT_EQ(machine1.Store(GetParam()), machine2.Store(GetParam()));
 }
 
@@ skipping 23 matching lines @@
   MachineOperatorBuilder machine(zone(), representation());
   EXPECT_EQ(GetParam(),
             OpParameter<StoreRepresentation>(machine.Store(GetParam())));
 }
 
 
 INSTANTIATE_TEST_CASE_P(
     MachineOperatorTest, MachineStoreOperatorTest,
     ::testing::Combine(
         ::testing::ValuesIn(kMachineReps),
-        ::testing::Combine(::testing::ValuesIn(kMachineTypesForAccess),
+        ::testing::Combine(::testing::ValuesIn(kRepresentationsForStore),
                            ::testing::Values(kNoWriteBarrier,
                                              kFullWriteBarrier))));
 #endif
 
 // -----------------------------------------------------------------------------
 // Pure operators.
 
 namespace {
 
 struct PureOperator {
@@ skipping 238 matching lines @@
   EXPECT_EQ(machine.Uint64Div(), machine.UintDiv());
   EXPECT_EQ(machine.Int64Mod(), machine.IntMod());
   EXPECT_EQ(machine.Uint64Mod(), machine.UintMod());
   EXPECT_EQ(machine.Int64LessThan(), machine.IntLessThan());
   EXPECT_EQ(machine.Int64LessThanOrEqual(), machine.IntLessThanOrEqual());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8