[turbofan] Tester improvements; use CSignature and simplify ReturnValueTraits.

R=bmeurer@chromium.org,mstarzinger@chromium.org
BUG=

Review URL: https://codereview.chromium.org/1150083006

Cr-Commit-Position: refs/heads/master@{#28733}

diff --git a/test/cctest/compiler/c-signature.h b/test/cctest/compiler/c-signature.h
index 5d161db..fee8cb9 100644 (file)
--- a/test/cctest/compiler/c-signature.h
+++ b/test/cctest/compiler/c-signature.h
@@ -11,76 +11,74 @@ namespace v8 {
 namespace internal {
 namespace compiler {
 
+#define FOREACH_CTYPE_MACHINE_TYPE_MAPPING(V) \
+  V(void, kMachNone)                          \
+  V(bool, kMachBool)                          \
+  V(int8_t, kMachInt8)                        \
+  V(uint8_t, kMachUint8)                      \
+  V(int16_t, kMachInt16)                      \
+  V(uint16_t, kMachUint16)                    \
+  V(int32_t, kMachInt32)                      \
+  V(uint32_t, kMachUint32)                    \
+  V(int64_t, kMachInt64)                      \
+  V(uint64_t, kMachUint64)                    \
+  V(float, kMachFloat32)                      \
+  V(double, kMachFloat64)                     \
+  V(void*, kMachPtr)                          \
+  V(int*, kMachPtr)
+
 template <typename T>
 inline MachineType MachineTypeForC() {
-  CHECK(false);  // Instantiated with invalid type.
-  return kMachNone;
-}
-
-template <>
-inline MachineType MachineTypeForC<void>() {
-  return kMachNone;
-}
-
-template <>
-inline MachineType MachineTypeForC<int8_t>() {
-  return kMachInt8;
-}
-
-template <>
-inline MachineType MachineTypeForC<uint8_t>() {
-  return kMachUint8;
-}
-
-template <>
-inline MachineType MachineTypeForC<int16_t>() {
-  return kMachInt16;
-}
-
-template <>
-inline MachineType MachineTypeForC<uint16_t>() {
-  return kMachUint16;
-}
-
-template <>
-inline MachineType MachineTypeForC<int32_t>() {
-  return kMachInt32;
-}
-
-template <>
-inline MachineType MachineTypeForC<uint32_t>() {
-  return kMachUint32;
+  while (false) {
+    // All other types T must be assignable to Object*
+    *(static_cast<Object* volatile*>(0)) = static_cast<T>(0);
+  }
+  return kMachAnyTagged;
 }
 
-template <>
-inline MachineType MachineTypeForC<int64_t>() {
-  return kMachInt64;
-}
+#define DECLARE_TEMPLATE_SPECIALIZATION(ctype, mtype) \
+  template <>                                         \
+  inline MachineType MachineTypeForC<ctype>() {       \
+    return mtype;                                     \
+  }
+FOREACH_CTYPE_MACHINE_TYPE_MAPPING(DECLARE_TEMPLATE_SPECIALIZATION)
+#undef DECLARE_TEMPLATE_SPECIALIZATION
 
-template <>
-inline MachineType MachineTypeForC<uint64_t>() {
-  return kMachUint64;
-}
+// Helper for building machine signatures from C types.
+class CSignature : public MachineSignature {
+ protected:
+  CSignature(size_t return_count, size_t parameter_count, MachineType* reps)
+      : MachineSignature(return_count, parameter_count, reps) {}
 
-template <>
-inline MachineType MachineTypeForC<double>() {
-  return kMachFloat64;
-}
+ public:
+  template <typename P1 = void, typename P2 = void, typename P3 = void,
+            typename P4 = void, typename P5 = void>
+  void Verify() {
+    // Verifies the C signature against the machine types. Maximum {5} params.
+    CHECK_LT(parameter_count(), 6);
+    const int kMax = 5;
+    MachineType params[] = {MachineTypeForC<P1>(), MachineTypeForC<P2>(),
+                            MachineTypeForC<P3>(), MachineTypeForC<P4>(),
+                            MachineTypeForC<P5>()};
+    for (int p = kMax - 1; p >= 0; p--) {
+      if (p < parameter_count()) {
+        CHECK_EQ(GetParam(p), params[p]);
+      } else {
+        CHECK_EQ(kMachNone, params[p]);
+      }
+    }
+  }
+};
 
-template <>
-inline MachineType MachineTypeForC<Object*>() {
-  return kMachAnyTagged;
-}
 
 template <typename Ret, uint16_t kParamCount>
-class CSignatureOf : public MachineSignature {
+class CSignatureOf : public CSignature {
  protected:
   MachineType storage_[1 + kParamCount];
 
   CSignatureOf()
-      : MachineSignature(MachineTypeForC<Ret>() != kMachNone ? 1 : 0,
-                         kParamCount,
-                         reinterpret_cast<MachineType*>(&storage_)) {
+      : CSignature(MachineTypeForC<Ret>() != kMachNone ? 1 : 0, kParamCount,
+                   reinterpret_cast<MachineType*>(&storage_)) {
     if (return_count_ == 1) storage_[0] = MachineTypeForC<Ret>();
   }
   void Set(int index, MachineType type) {
@@ -123,9 +121,11 @@ class CSignature3 : public CSignatureOf<Ret, 3> {
   }
 };
 
-static const CSignature2<int32_t, int32_t, int32_t> int32_int32_to_int32;
-static const CSignature2<uint32_t, uint32_t, uint32_t> uint32_uint32_to_uint32;
-static const CSignature2<double, double, double> float64_float64_to_float64;
+typedef CSignature2<int32_t, int32_t, int32_t> CSignature_i_ii;
+typedef CSignature2<uint32_t, uint32_t, uint32_t> CSignature_u_uu;
+typedef CSignature2<float, float, float> CSignature_f_ff;
+typedef CSignature2<double, double, double> CSignature_d_dd;
+typedef CSignature2<Object*, Object*, Object*> CSignature_o_oo;
 }
 }
 }  // namespace v8::internal::compiler

diff --git a/test/cctest/compiler/call-tester.h b/test/cctest/compiler/call-tester.h
index 353ed3d..194af38 100644 (file)
--- a/test/cctest/compiler/call-tester.h
+++ b/test/cctest/compiler/call-tester.h
@@ -9,6 +9,8 @@
 
 #include "src/simulator.h"
 
+#include "test/cctest/compiler/c-signature.h"
+
 #if V8_TARGET_ARCH_IA32
 #if __GNUC__
 #define V8_CDECL __attribute__((cdecl))
@@ -23,95 +25,64 @@ namespace v8 {
 namespace internal {
 namespace compiler {
 
-// TODO(titzer): use c-signature.h instead of ReturnValueTraits
 template <typename R>
-struct ReturnValueTraits {
-  static R Cast(uintptr_t r) { return reinterpret_cast<R>(r); }
-  static MachineType Representation() {
-    // TODO(dcarney): detect when R is of a subclass of Object* instead of this
-    // type check.
-    while (false) {
-      *(static_cast<Object* volatile*>(0)) = static_cast<R>(0);
-    }
-    return kMachAnyTagged;
-  }
-};
-
-template <>
-struct ReturnValueTraits<int32_t*> {
-  static int32_t* Cast(uintptr_t r) { return reinterpret_cast<int32_t*>(r); }
-  static MachineType Representation() { return kMachPtr; }
-};
+inline R CastReturnValue(uintptr_t r) {
+  return reinterpret_cast<R>(r);
+}
 
 template <>
-struct ReturnValueTraits<void> {
-  static void Cast(uintptr_t r) {}
-  static MachineType Representation() { return kMachPtr; }
-};
+inline void CastReturnValue(uintptr_t r) {}
 
 template <>
-struct ReturnValueTraits<bool> {
-  static bool Cast(uintptr_t r) { return static_cast<bool>(r); }
-  static MachineType Representation() { return kRepBit; }
-};
+inline bool CastReturnValue(uintptr_t r) {
+  return static_cast<bool>(r);
+}
 
 template <>
-struct ReturnValueTraits<int32_t> {
-  static int32_t Cast(uintptr_t r) { return static_cast<int32_t>(r); }
-  static MachineType Representation() { return kMachInt32; }
-};
+inline int32_t CastReturnValue(uintptr_t r) {
+  return static_cast<int32_t>(r);
+}
 
 template <>
-struct ReturnValueTraits<uint32_t> {
-  static uint32_t Cast(uintptr_t r) { return static_cast<uint32_t>(r); }
-  static MachineType Representation() { return kMachUint32; }
-};
+inline uint32_t CastReturnValue(uintptr_t r) {
+  return static_cast<uint32_t>(r);
+}
 
 template <>
-struct ReturnValueTraits<int64_t> {
-  static int64_t Cast(uintptr_t r) { return static_cast<int64_t>(r); }
-  static MachineType Representation() { return kMachInt64; }
-};
+inline int64_t CastReturnValue(uintptr_t r) {
+  return static_cast<int64_t>(r);
+}
 
 template <>
-struct ReturnValueTraits<uint64_t> {
-  static uint64_t Cast(uintptr_t r) { return static_cast<uint64_t>(r); }
-  static MachineType Representation() { return kMachUint64; }
-};
+inline uint64_t CastReturnValue(uintptr_t r) {
+  return static_cast<uint64_t>(r);
+}
 
 template <>
-struct ReturnValueTraits<int16_t> {
-  static int16_t Cast(uintptr_t r) { return static_cast<int16_t>(r); }
-  static MachineType Representation() { return kMachInt16; }
-};
+inline int16_t CastReturnValue(uintptr_t r) {
+  return static_cast<int16_t>(r);
+}
 
 template <>
-struct ReturnValueTraits<uint16_t> {
-  static uint16_t Cast(uintptr_t r) { return static_cast<uint16_t>(r); }
-  static MachineType Representation() { return kMachUint16; }
-};
+inline uint16_t CastReturnValue(uintptr_t r) {
+  return static_cast<uint16_t>(r);
+}
 
 template <>
-struct ReturnValueTraits<int8_t> {
-  static int8_t Cast(uintptr_t r) { return static_cast<int8_t>(r); }
-  static MachineType Representation() { return kMachInt8; }
-};
+inline int8_t CastReturnValue(uintptr_t r) {
+  return static_cast<int8_t>(r);
+}
 
 template <>
-struct ReturnValueTraits<uint8_t> {
-  static uint8_t Cast(uintptr_t r) { return static_cast<uint8_t>(r); }
-  static MachineType Representation() { return kMachUint8; }
-};
+inline uint8_t CastReturnValue(uintptr_t r) {
+  return static_cast<uint8_t>(r);
+}
 
 template <>
-struct ReturnValueTraits<double> {
-  static double Cast(uintptr_t r) {
-    UNREACHABLE();
-    return 0.0;
-  }
-  static MachineType Representation() { return kMachFloat64; }
-};
-
+inline double CastReturnValue(uintptr_t r) {
+  UNREACHABLE();
+  return 0.0;
+}
 
 template <typename R>
 struct ParameterTraits {
@@ -213,27 +184,27 @@ class CallHelper {
   template <typename F>
   R DoCall(F* f) {
     Simulator::CallArgument args[] = {Simulator::CallArgument::End()};
-    return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f), args));
+    return CastReturnValue<R>(CallSimulator(FUNCTION_ADDR(f), args));
   }
   template <typename F, typename P1>
   R DoCall(F* f, P1 p1) {
     Simulator::CallArgument args[] = {Simulator::CallArgument(p1),
                                       Simulator::CallArgument::End()};
-    return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f), args));
+    return CastReturnValue<R>(CallSimulator(FUNCTION_ADDR(f), args));
   }
   template <typename F, typename P1, typename P2>
   R DoCall(F* f, P1 p1, P2 p2) {
     Simulator::CallArgument args[] = {Simulator::CallArgument(p1),
                                       Simulator::CallArgument(p2),
                                       Simulator::CallArgument::End()};
-    return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f), args));
+    return CastReturnValue<R>(CallSimulator(FUNCTION_ADDR(f), args));
   }
   template <typename F, typename P1, typename P2, typename P3>
   R DoCall(F* f, P1 p1, P2 p2, P3 p3) {
     Simulator::CallArgument args[] = {
         Simulator::CallArgument(p1), Simulator::CallArgument(p2),
         Simulator::CallArgument(p3), Simulator::CallArgument::End()};
-    return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f), args));
+    return CastReturnValue<R>(CallSimulator(FUNCTION_ADDR(f), args));
   }
   template <typename F, typename P1, typename P2, typename P3, typename P4>
   R DoCall(F* f, P1 p1, P2 p2, P3 p3, P4 p4) {
@@ -241,7 +212,7 @@ class CallHelper {
         Simulator::CallArgument(p1), Simulator::CallArgument(p2),
         Simulator::CallArgument(p3), Simulator::CallArgument(p4),
         Simulator::CallArgument::End()};
-    return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f), args));
+    return CastReturnValue<R>(CallSimulator(FUNCTION_ADDR(f), args));
   }
 #elif USE_SIMULATOR && (V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_PPC64)
   uintptr_t CallSimulator(byte* f, int64_t p1 = 0, int64_t p2 = 0,
@@ -253,28 +224,28 @@ class CallHelper {
 
   template <typename F>
   R DoCall(F* f) {
-    return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f)));
+    return CastReturnValue<R>(CallSimulator(FUNCTION_ADDR(f)));
   }
   template <typename F, typename P1>
   R DoCall(F* f, P1 p1) {
-    return ReturnValueTraits<R>::Cast(
+    return CastReturnValue<R>(
         CallSimulator(FUNCTION_ADDR(f), ParameterTraits<P1>::Cast(p1)));
   }
   template <typename F, typename P1, typename P2>
   R DoCall(F* f, P1 p1, P2 p2) {
-    return ReturnValueTraits<R>::Cast(
-        CallSimulator(FUNCTION_ADDR(f), ParameterTraits<P1>::Cast(p1),
-                      ParameterTraits<P2>::Cast(p2)));
+    return CastReturnValue<R>(CallSimulator(FUNCTION_ADDR(f),
+                                            ParameterTraits<P1>::Cast(p1),
+                                            ParameterTraits<P2>::Cast(p2)));
   }
   template <typename F, typename P1, typename P2, typename P3>
   R DoCall(F* f, P1 p1, P2 p2, P3 p3) {
-    return ReturnValueTraits<R>::Cast(CallSimulator(
+    return CastReturnValue<R>(CallSimulator(
         FUNCTION_ADDR(f), ParameterTraits<P1>::Cast(p1),
         ParameterTraits<P2>::Cast(p2), ParameterTraits<P3>::Cast(p3)));
   }
   template <typename F, typename P1, typename P2, typename P3, typename P4>
   R DoCall(F* f, P1 p1, P2 p2, P3 p3, P4 p4) {
-    return ReturnValueTraits<R>::Cast(CallSimulator(
+    return CastReturnValue<R>(CallSimulator(
         FUNCTION_ADDR(f), ParameterTraits<P1>::Cast(p1),
         ParameterTraits<P2>::Cast(p2), ParameterTraits<P3>::Cast(p3),
         ParameterTraits<P4>::Cast(p4)));
@@ -288,28 +259,28 @@ class CallHelper {
   }
   template <typename F>
   R DoCall(F* f) {
-    return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f)));
+    return CastReturnValue<R>(CallSimulator(FUNCTION_ADDR(f)));
   }
   template <typename F, typename P1>
   R DoCall(F* f, P1 p1) {
-    return ReturnValueTraits<R>::Cast(
+    return CastReturnValue<R>(
         CallSimulator(FUNCTION_ADDR(f), ParameterTraits<P1>::Cast(p1)));
   }
   template <typename F, typename P1, typename P2>
   R DoCall(F* f, P1 p1, P2 p2) {
-    return ReturnValueTraits<R>::Cast(
-        CallSimulator(FUNCTION_ADDR(f), ParameterTraits<P1>::Cast(p1),
-                      ParameterTraits<P2>::Cast(p2)));
+    return CastReturnValue<R>(CallSimulator(FUNCTION_ADDR(f),
+                                            ParameterTraits<P1>::Cast(p1),
+                                            ParameterTraits<P2>::Cast(p2)));
   }
   template <typename F, typename P1, typename P2, typename P3>
   R DoCall(F* f, P1 p1, P2 p2, P3 p3) {
-    return ReturnValueTraits<R>::Cast(CallSimulator(
+    return CastReturnValue<R>(CallSimulator(
         FUNCTION_ADDR(f), ParameterTraits<P1>::Cast(p1),
         ParameterTraits<P2>::Cast(p2), ParameterTraits<P3>::Cast(p3)));
   }
   template <typename F, typename P1, typename P2, typename P3, typename P4>
   R DoCall(F* f, P1 p1, P2 p2, P3 p3, P4 p4) {
-    return ReturnValueTraits<R>::Cast(CallSimulator(
+    return CastReturnValue<R>(CallSimulator(
         FUNCTION_ADDR(f), ParameterTraits<P1>::Cast(p1),
         ParameterTraits<P2>::Cast(p2), ParameterTraits<P3>::Cast(p3),
         ParameterTraits<P4>::Cast(p4)));
@@ -356,31 +327,27 @@ class CallHelper {
 
   template <typename P1>
   void VerifyParameters1() {
-    MachineType parameters[] = {ReturnValueTraits<P1>::Representation()};
+    MachineType parameters[] = {MachineTypeForC<P1>()};
     VerifyParameters(arraysize(parameters), parameters);
   }
 
   template <typename P1, typename P2>
   void VerifyParameters2() {
-    MachineType parameters[] = {ReturnValueTraits<P1>::Representation(),
-                                ReturnValueTraits<P2>::Representation()};
+    MachineType parameters[] = {MachineTypeForC<P1>(), MachineTypeForC<P2>()};
     VerifyParameters(arraysize(parameters), parameters);
   }
 
   template <typename P1, typename P2, typename P3>
   void VerifyParameters3() {
-    MachineType parameters[] = {ReturnValueTraits<P1>::Representation(),
-                                ReturnValueTraits<P2>::Representation(),
-                                ReturnValueTraits<P3>::Representation()};
+    MachineType parameters[] = {MachineTypeForC<P1>(), MachineTypeForC<P2>(),
+                                MachineTypeForC<P3>()};
     VerifyParameters(arraysize(parameters), parameters);
   }
 
   template <typename P1, typename P2, typename P3, typename P4>
   void VerifyParameters4() {
-    MachineType parameters[] = {ReturnValueTraits<P1>::Representation(),
-                                ReturnValueTraits<P2>::Representation(),
-                                ReturnValueTraits<P3>::Representation(),
-                                ReturnValueTraits<P4>::Representation()};
+    MachineType parameters[] = {MachineTypeForC<P1>(), MachineTypeForC<P2>(),
+                                MachineTypeForC<P3>(), MachineTypeForC<P4>()};
     VerifyParameters(arraysize(parameters), parameters);
   }
 #endif

diff --git a/test/cctest/compiler/codegen-tester.h b/test/cctest/compiler/codegen-tester.h
index 9272e50..35ea0b9 100644 (file)
--- a/test/cctest/compiler/codegen-tester.h
+++ b/test/cctest/compiler/codegen-tester.h
@@ -30,14 +30,12 @@ class RawMachineAssemblerTester : public HandleAndZoneScope,
       : HandleAndZoneScope(),
         CallHelper<ReturnType>(
             main_isolate(),
-            MakeMachineSignature(
-                main_zone(), ReturnValueTraits<ReturnType>::Representation(),
-                p0, p1, p2, p3, p4)),
+            MakeMachineSignature(main_zone(), MachineTypeForC<ReturnType>(), p0,
+                                 p1, p2, p3, p4)),
         RawMachineAssembler(
             main_isolate(), new (main_zone()) Graph(main_zone()),
-            MakeMachineSignature(
-                main_zone(), ReturnValueTraits<ReturnType>::Representation(),
-                p0, p1, p2, p3, p4),
+            MakeMachineSignature(main_zone(), MachineTypeForC<ReturnType>(), p0,
+                                 p1, p2, p3, p4),
             kMachPtr, InstructionSelector::SupportedMachineOperatorFlags()) {}
 
   void CheckNumber(double expected, Object* number) {

diff --git a/test/cctest/compiler/graph-builder-tester.h b/test/cctest/compiler/graph-builder-tester.h
index 848f250..6557db4 100644 (file)
--- a/test/cctest/compiler/graph-builder-tester.h
+++ b/test/cctest/compiler/graph-builder-tester.h
@@ -52,9 +52,8 @@ class GraphBuilderTester : public HandleAndZoneScope,
       : GraphAndBuilders(main_zone()),
         CallHelper<ReturnType>(
             main_isolate(),
-            MakeMachineSignature(
-                main_zone(), ReturnValueTraits<ReturnType>::Representation(),
-                p0, p1, p2, p3, p4)),
+            MakeMachineSignature(main_zone(), MachineTypeForC<ReturnType>(), p0,
+                                 p1, p2, p3, p4)),
         SimplifiedGraphBuilder(main_isolate(), main_graph_, &main_common_,
                                &main_machine_, &main_simplified_),
         parameters_(main_zone()->template NewArray<Node*>(parameter_count())) {

diff --git a/test/cctest/compiler/test-run-machops.cc b/test/cctest/compiler/test-run-machops.cc
index 66ac809..036c1fb 100644 (file)
--- a/test/cctest/compiler/test-run-machops.cc
+++ b/test/cctest/compiler/test-run-machops.cc
@@ -4412,7 +4412,7 @@ TEST(RunTestIntPtrArithmetic) {
 
 TEST(RunSpillLotsOfThings) {
   static const int kInputSize = 1000;
-  RawMachineAssemblerTester<void> m;
+  RawMachineAssemblerTester<int32_t> m;
   Node* accs[kInputSize];
   int32_t outputs[kInputSize];
   Node* one = m.Int32Constant(1);

diff --git a/test/cctest/compiler/test-simplified-lowering.cc b/test/cctest/compiler/test-simplified-lowering.cc
index d1bc803..9b23469 100644 (file)
--- a/test/cctest/compiler/test-simplified-lowering.cc
+++ b/test/cctest/compiler/test-simplified-lowering.cc
@@ -33,11 +33,8 @@ template <typename ReturnType>
 class SimplifiedLoweringTester : public GraphBuilderTester<ReturnType> {
  public:
   SimplifiedLoweringTester(MachineType p0 = kMachNone,
-                           MachineType p1 = kMachNone,
-                           MachineType p2 = kMachNone,
-                           MachineType p3 = kMachNone,
-                           MachineType p4 = kMachNone)
-      : GraphBuilderTester<ReturnType>(p0, p1, p2, p3, p4),
+                           MachineType p1 = kMachNone)
+      : GraphBuilderTester<ReturnType>(p0, p1),
         typer(this->isolate(), this->graph(), MaybeHandle<Context>()),
         javascript(this->zone()),
         jsgraph(this->isolate(), this->graph(), this->common(), &javascript,