Move MachineRepresentation to machine-type.h and rename to MachineType in preparation for merging i…

test/cctest/compiler/test-simplified-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 <limits>
 
 #include "src/compiler/control-builders.h"
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/node-properties-inl.h"
@@ skipping 11 matching lines @@
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/graph-builder-tester.h"
 #include "test/cctest/compiler/value-helper.h"
 
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
 template <typename ReturnType>
 class SimplifiedLoweringTester : public GraphBuilderTester<ReturnType> {
  public:
-  SimplifiedLoweringTester(MachineRepresentation p0 = kMachineLast,
-                           MachineRepresentation p1 = kMachineLast,
-                           MachineRepresentation p2 = kMachineLast,
-                           MachineRepresentation p3 = kMachineLast,
-                           MachineRepresentation p4 = kMachineLast)
+  SimplifiedLoweringTester(MachineType p0 = kMachineLast,
+                           MachineType p1 = kMachineLast,
+                           MachineType p2 = kMachineLast,
+                           MachineType p3 = kMachineLast,
+                           MachineType p4 = kMachineLast)
       : GraphBuilderTester<ReturnType>(p0, p1, p2, p3, p4),
         typer(this->zone()),
         source_positions(this->graph()),
         jsgraph(this->graph(), this->common(), &typer),
         lowering(&jsgraph, &source_positions) {}
 
   Typer typer;
   SourcePositionTable source_positions;
   JSGraph jsgraph;
   SimplifiedLowering lowering;
@@ skipping 35 matching lines @@
 }
 
 
 ElementAccess ForFixedArrayElement() {
   ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Any(),
                           kMachineTagged};
   return access;
 }
 
 
-ElementAccess ForBackingStoreElement(MachineRepresentation rep) {
+ElementAccess ForBackingStoreElement(MachineType rep) {
   ElementAccess access = {kUntaggedBase,
                           kNonHeapObjectHeaderSize - kHeapObjectTag,
                           Type::Any(), rep};
   return access;
 }
 }
 
 
 // Create a simple JSObject with a unique map.
 static Handle<JSObject> TestObject() {
@@ skipping 253 matching lines @@
 }
 
 
 // A helper class for accessing fields and elements of various types, on both
 // tagged and untagged base pointers. Contains both tagged and untagged buffers
 // for testing direct memory access from generated code.
 template <typename E>
 class AccessTester : public HandleAndZoneScope {
  public:
   bool tagged;
-  MachineRepresentation rep;
+  MachineType rep;
   E* original_elements;
   size_t num_elements;
   E* untagged_array;
   Handle<ByteArray> tagged_array;  // TODO(titzer): use FixedArray for tagged.
 
-  AccessTester(bool t, MachineRepresentation r, E* orig, size_t num)
+  AccessTester(bool t, MachineType r, E* orig, size_t num)
       : tagged(t),
         rep(r),
         original_elements(orig),
         num_elements(num),
         untagged_array(static_cast<E*>(malloc(ByteSize()))),
         tagged_array(main_isolate()->factory()->NewByteArray(
             static_cast<int>(ByteSize()))) {
     Reinitialize();
   }
 
@@ skipping 127 matching lines @@
 
   void BoundsCheck(int index) {
     CHECK_GE(index, 0);
     CHECK_LT(index, static_cast<int>(num_elements));
     CHECK_EQ(static_cast<int>(ByteSize()), tagged_array->length());
   }
 };
 
 
 template <typename E>
-static void RunAccessTest(MachineRepresentation rep, E* original_elements,
-                          size_t num) {
+static void RunAccessTest(MachineType rep, E* original_elements, size_t num) {
   int num_elements = static_cast<int>(num);
 
   for (int taggedness = 0; taggedness < 2; taggedness++) {
     AccessTester<E> a(taggedness == 1, rep, original_elements, num);
     for (int field = 0; field < 2; field++) {
       for (int i = 0; i < num_elements - 1; i++) {
         a.Reinitialize();
         if (field == 0) {
           a.RunCopyField(i, i + 1);  // Test field read/write.
         } else {
@@ skipping 619 matching lines @@
     Int32BinopMatcher mul(index.left().node());
     CHECK_EQ(IrOpcode::kInt32Mul, mul.node()->opcode());
     CHECK(mul.right().Is(element_size));
     return mul.left().node();
   } else {
     return index.left().node();
   }
 }
 
 
-static const MachineRepresentation machine_reps[] = {
-    kMachineWord8,  kMachineWord16,  kMachineWord32,
-    kMachineWord64, kMachineFloat64, kMachineTagged};
+static const MachineType machine_reps[] = {kMachineWord8,   kMachineWord16,
+                                           kMachineWord32,  kMachineWord64,
+                                           kMachineFloat64, kMachineTagged};
 
 
 // Representation types corresponding to those above.
 static const RepType rep_types[] = {static_cast<RepType>(rWord32 | tUint32),
                                     static_cast<RepType>(rWord32 | tUint32),
                                     static_cast<RepType>(rWord32 | tInt32),
                                     static_cast<RepType>(rWord64),
                                     static_cast<RepType>(rFloat64 | tNumber),
                                     static_cast<RepType>(rTagged | tAny)};
 
 
 TEST(LowerLoadField_to_load) {
   TestingGraph t(Type::Any(), Type::Signed32());
 
   for (size_t i = 0; i < ARRAY_SIZE(machine_reps); i++) {
     FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
                           Handle<Name>::null(), Type::Any(), machine_reps[i]};
 
     Node* load =
         t.graph()->NewNode(t.simplified()->LoadField(access), t.p0, t.start);
     Node* use = t.Use(load, rep_types[i]);
     t.Return(use);
     t.Lower();
     CHECK_EQ(IrOpcode::kLoad, load->opcode());
     CHECK_EQ(t.p0, load->InputAt(0));
     CheckFieldAccessArithmetic(access, load);
 
-    MachineRepresentation rep = OpParameter<MachineRepresentation>(load);
+    MachineType rep = OpParameter<MachineType>(load);
     CHECK_EQ(machine_reps[i], rep);
   }
 }
 
 
 TEST(LowerStoreField_to_store) {
   TestingGraph t(Type::Any(), Type::Signed32());
 
   for (size_t i = 0; i < ARRAY_SIZE(machine_reps); i++) {
     FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
@@ skipping 27 matching lines @@
 
     Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
                                     t.p1, t.start);
     Node* use = t.Use(load, rep_types[i]);
     t.Return(use);
     t.Lower();
     CHECK_EQ(IrOpcode::kLoad, load->opcode());
     CHECK_EQ(t.p0, load->InputAt(0));
     CheckElementAccessArithmetic(access, load);
 
-    MachineRepresentation rep = OpParameter<MachineRepresentation>(load);
+    MachineType rep = OpParameter<MachineType>(load);
     CHECK_EQ(machine_reps[i], rep);
   }
 }
 
 
 TEST(LowerStoreElement_to_store) {
   TestingGraph t(Type::Any(), Type::Signed32());
 
   for (size_t i = 0; i < ARRAY_SIZE(machine_reps); i++) {
     ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
@@ skipping 114 matching lines @@
 
   Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
                                    t.p1, t.start, t.start);
   t.Effect(store);
   t.Lower();
 
   CHECK_EQ(IrOpcode::kStore, store->opcode());
   CHECK_EQ(t.p0, store->InputAt(0));
   CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p1, store->InputAt(2));
 }