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

test/cctest/compiler/test-run-machops.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 <functional>
 #include <limits>
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/value-helper.h"
@@ skipping 2475 matching lines @@
     int constant = 0x55555 + i;
     m.NewNode(ops[i], m.Parameter(0), m.Parameter(1));
     m.Return(m.Int32Constant(constant));
 
     CHECK_EQ(constant, m.Call(1, 1));
   }
 }
 
 
 template <typename Type, typename CType>
-static void RunLoadImmIndex(MachineRepresentation rep) {
+static void RunLoadImmIndex(MachineType rep) {
   const int kNumElems = 3;
   CType buffer[kNumElems];
 
   // initialize the buffer with raw data.
   byte* raw = reinterpret_cast<byte*>(buffer);
   for (size_t i = 0; i < sizeof(buffer); i++) {
     raw[i] = static_cast<byte>((i + sizeof(buffer)) ^ 0xAA);
   }
 
   // Test with various large and small offsets.
@@ skipping 18 matching lines @@
   RunLoadImmIndex<int16_t, uint16_t>(kMachineWord16);
   RunLoadImmIndex<int32_t, uint32_t>(kMachineWord32);
   RunLoadImmIndex<int32_t*, int32_t*>(kMachineTagged);
 
   // TODO(titzer): test kMachineFloat64 loads
   // TODO(titzer): test various indexing modes.
 }
 
 
 template <typename CType>
-static void RunLoadStore(MachineRepresentation rep) {
+static void RunLoadStore(MachineType rep) {
   const int kNumElems = 4;
   CType buffer[kNumElems];
 
   for (int32_t x = 0; x < kNumElems; x++) {
     int32_t y = kNumElems - x - 1;
     // initialize the buffer with raw data.
     byte* raw = reinterpret_cast<byte*>(buffer);
     for (size_t i = 0; i < sizeof(buffer); i++) {
       raw[i] = static_cast<byte>((i + sizeof(buffer)) ^ 0xAA);
     }
@@ skipping 798 matching lines @@
 
 
 TEST(RunCallSeven) {
   for (int i = 0; i < 2; i++) {
     bool call_direct = i == 0;
     void* function_address =
         reinterpret_cast<void*>(reinterpret_cast<intptr_t>(&Seven));
 
     RawMachineAssemblerTester<int32_t> m;
     Node** args = NULL;
-    MachineRepresentation* arg_types = NULL;
+    MachineType* arg_types = NULL;
     Node* function =
         call_direct ? m.PointerConstant(function_address)
                     : m.LoadFromPointer(&function_address,
                                         MachineOperatorBuilder::pointer_rep());
     m.Return(m.CallC(function, kMachineWord32, arg_types, args, 0));
 
     CHECK_EQ(7, m.Call());
   }
 }
 
 
 TEST(RunCallUnaryMinus) {
   for (int i = 0; i < 2; i++) {
     bool call_direct = i == 0;
     void* function_address =
         reinterpret_cast<void*>(reinterpret_cast<intptr_t>(&UnaryMinus));
 
     RawMachineAssemblerTester<int32_t> m(kMachineWord32);
     Node* args[] = {m.Parameter(0)};
-    MachineRepresentation arg_types[] = {kMachineWord32};
+    MachineType arg_types[] = {kMachineWord32};
     Node* function =
         call_direct ? m.PointerConstant(function_address)
                     : m.LoadFromPointer(&function_address,
                                         MachineOperatorBuilder::pointer_rep());
     m.Return(m.CallC(function, kMachineWord32, arg_types, args, 1));
 
     FOR_INT32_INPUTS(i) {
       int a = *i;
       CHECK_EQ(-a, m.Call(a));
     }
   }
 }
 
 
 TEST(RunCallAPlusTwoB) {
   for (int i = 0; i < 2; i++) {
     bool call_direct = i == 0;
     void* function_address =
         reinterpret_cast<void*>(reinterpret_cast<intptr_t>(&APlusTwoB));
 
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32);
     Node* args[] = {m.Parameter(0), m.Parameter(1)};
-    MachineRepresentation arg_types[] = {kMachineWord32, kMachineWord32};
+    MachineType arg_types[] = {kMachineWord32, kMachineWord32};
     Node* function =
         call_direct ? m.PointerConstant(function_address)
                     : m.LoadFromPointer(&function_address,
                                         MachineOperatorBuilder::pointer_rep());
     m.Return(m.CallC(function, kMachineWord32, arg_types, args, 2));
 
     FOR_INT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         int a = *i;
         int b = *j;
@@ skipping 181 matching lines @@
     FOR_FLOAT64_INPUTS(pr) {
       input_a = *pl;
       input_b = *pr;
       int32_t expected = cmp.Float64Compare(input_a, input_b) ? 1 : 0;
       CHECK_EQ(expected, m.Call());
     }
   }
 }
 
 
-template <typename IntType, MachineRepresentation kRepresentation>
+template <typename IntType, MachineType kRepresentation>
 static void LoadStoreTruncation() {
   IntType input;
 
   RawMachineAssemblerTester<int32_t> m;
   Node* a = m.LoadFromPointer(&input, kRepresentation);
   Node* ap1 = m.Int32Add(a, m.Int32Constant(1));
   m.StoreToPointer(&input, kRepresentation, ap1);
   m.Return(ap1);
 
   const IntType max = std::numeric_limits<IntType>::max();
@@ skipping 250 matching lines @@
   Node* one = m.Int32Constant(1);
   Node* acc = one;
   for (int i = 0; i < kInputSize; i++) {
     acc = m.Int32Add(acc, one);
     accs[i] = acc;
   }
   // If the spill slot computation is wrong, it might load from the c frame
   {
     void* func = reinterpret_cast<void*>(reinterpret_cast<intptr_t>(&Seven));
     Node** args = NULL;
-    MachineRepresentation* arg_types = NULL;
+    MachineType* arg_types = NULL;
     m.CallC(m.PointerConstant(func), kMachineWord32, arg_types, args, 0);
   }
   for (int i = 0; i < kInputSize; i++) {
     m.StoreToPointer(&outputs[i], kMachineWord32, accs[i]);
   }
   m.Return(one);
   m.Call();
   for (int i = 0; i < kInputSize; i++) {
     CHECK_EQ(outputs[i], i + 2);
   }
@@ skipping 187 matching lines @@
   FOR_UINT32_INPUTS(i) {
     FOR_UINT32_INPUTS(j) {
       int32_t expected;
       if (ssub_overflow(*i, *j, &expected)) expected = constant;
       CHECK_EQ(expected, bt.call(*i, *j));
     }
   }
 }
 
 #endif  // V8_TURBOFAN_TARGET