[turbofan] Limit the load/store machine types to the ones we actually use.

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 14 matching lines @@
  private:
   typedef ::testing::WithParamInterface< ::testing::tuple<MachineType, T> > B;
 };
 
 
 namespace {
 
 const MachineType kMachineReps[] = {kRepWord32, kRepWord64};
 
 
-const MachineType kMachineTypes[] = {
-    kMachFloat32, kMachFloat64,   kMachInt8,   kMachUint8,  kMachInt16,
-    kMachUint16,  kMachInt32,     kMachUint32, kMachInt64,  kMachUint64,
-    kMachPtr,     kMachAnyTagged, kRepBit,     kRepWord8,   kRepWord16,
-    kRepWord32,   kRepWord64,     kRepFloat32, kRepFloat64, kRepTagged};
+const MachineType kMachineTypesForAccess[] = {
+    kMachFloat32, kMachFloat64,   kMachInt8,   kMachUint8, kMachInt16,
+    kMachUint16,  kMachInt32,     kMachUint32, kMachInt64, kMachUint64,
+    kMachPtr,     kMachAnyTagged, kMachPtr};
 
 }  // namespace
 
 
 // -----------------------------------------------------------------------------
 // Load operator.
 
 
 typedef MachineOperatorTestWithParam<LoadRepresentation>
     MachineLoadOperatorTest;
@@ skipping 27 matching lines @@
 }
 
 
 TEST_P(MachineLoadOperatorTest, ParameterIsCorrect) {
   MachineOperatorBuilder machine(zone(), type());
   EXPECT_EQ(GetParam(),
             OpParameter<LoadRepresentation>(machine.Load(GetParam())));
 }
 
 
-INSTANTIATE_TEST_CASE_P(MachineOperatorTest, MachineLoadOperatorTest,
-                        ::testing::Combine(::testing::ValuesIn(kMachineReps),
-                                           ::testing::ValuesIn(kMachineTypes)));
+INSTANTIATE_TEST_CASE_P(
+    MachineOperatorTest, MachineLoadOperatorTest,
+    ::testing::Combine(::testing::ValuesIn(kMachineReps),
+                       ::testing::ValuesIn(kMachineTypesForAccess)));
 
 
 // -----------------------------------------------------------------------------
 // Store operator.
 
 
 class MachineStoreOperatorTest
     : public MachineOperatorTestWithParam<
           ::testing::tuple<MachineType, WriteBarrierKind> > {
  protected:
@@ skipping 39 matching lines @@
   MachineOperatorBuilder machine(zone(), type());
   EXPECT_EQ(GetParam(),
             OpParameter<StoreRepresentation>(machine.Store(GetParam())));
 }
 
 
 INSTANTIATE_TEST_CASE_P(
     MachineOperatorTest, MachineStoreOperatorTest,
     ::testing::Combine(
         ::testing::ValuesIn(kMachineReps),
-        ::testing::Combine(::testing::ValuesIn(kMachineTypes),
+        ::testing::Combine(::testing::ValuesIn(kMachineTypesForAccess),
                            ::testing::Values(kNoWriteBarrier,
                                              kFullWriteBarrier))));
 #endif
 
 // -----------------------------------------------------------------------------
 // Pure operators.
 
 namespace {
 
 struct PureOperator {
@@ skipping 234 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