Add MachineSignature, which is an encapsulation of the machine types for parameters and return valu…

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 "src/base/bits.h"
 #include "src/compiler/generic-node-inl.h"
 #include "test/cctest/cctest.h"
@@ skipping 3516 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;
     MachineType* arg_types = NULL;
-    Node* function =
-        call_direct ? m.PointerConstant(function_address)
-                    : m.LoadFromPointer(&function_address,
-                                        MachineOperatorBuilder::pointer_rep());
+    Node* function = call_direct
+                         ? m.PointerConstant(function_address)
+                         : m.LoadFromPointer(&function_address, kMachPtr);
     m.Return(m.CallC(function, kMachInt32, 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(kMachInt32);
     Node* args[] = {m.Parameter(0)};
     MachineType arg_types[] = {kMachInt32};
-    Node* function =
-        call_direct ? m.PointerConstant(function_address)
-                    : m.LoadFromPointer(&function_address,
-                                        MachineOperatorBuilder::pointer_rep());
+    Node* function = call_direct
+                         ? m.PointerConstant(function_address)
+                         : m.LoadFromPointer(&function_address, kMachPtr);
     m.Return(m.CallC(function, kMachInt32, 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(kMachInt32, kMachInt32);
     Node* args[] = {m.Parameter(0), m.Parameter(1)};
     MachineType arg_types[] = {kMachInt32, kMachInt32};
-    Node* function =
-        call_direct ? m.PointerConstant(function_address)
-                    : m.LoadFromPointer(&function_address,
-                                        MachineOperatorBuilder::pointer_rep());
+    Node* function = call_direct
+                         ? m.PointerConstant(function_address)
+                         : m.LoadFromPointer(&function_address, kMachPtr);
     m.Return(m.CallC(function, kMachInt32, arg_types, args, 2));
 
     FOR_INT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         int a = *i;
         int b = *j;
         int result = m.Call(a, b);
         CHECK_EQ(a + 2 * b, result);
       }
     }
@@ skipping 218 matching lines @@
 
 
 TEST(RunLoadStoreTruncation) {
   LoadStoreTruncation<int8_t, kMachInt8>();
   LoadStoreTruncation<int16_t, kMachInt16>();
 }
 
 
 static void IntPtrCompare(intptr_t left, intptr_t right) {
   for (int test = 0; test < 7; test++) {
-    RawMachineAssemblerTester<bool> m(MachineOperatorBuilder::pointer_rep(),
-                                      MachineOperatorBuilder::pointer_rep());
+    RawMachineAssemblerTester<bool> m(kMachPtr, kMachPtr);
     Node* p0 = m.Parameter(0);
     Node* p1 = m.Parameter(1);
     Node* res = NULL;
     bool expected = false;
     switch (test) {
       case 0:
         res = m.IntPtrLessThan(p0, p1);
         expected = true;
         break;
       case 1:
@@ skipping 482 matching lines @@
   RawMachineAssemblerTester<int32_t> m;
   m.Return(m.TruncateFloat64ToInt32(m.LoadFromPointer(&input, kMachFloat64)));
   for (size_t i = 0; i < arraysize(kValues); ++i) {
     input = kValues[i].from;
     uint64_t expected = static_cast<int64_t>(kValues[i].raw);
     CHECK_EQ(static_cast<int>(expected), m.Call());
   }
 }
 
 #endif  // V8_TURBOFAN_TARGET