[turbofan] Make MachineType a pair of enums.

test/cctest/compiler/codegen-tester.h

 // 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.
 
 #ifndef V8_CCTEST_COMPILER_CODEGEN_TESTER_H_
 #define V8_CCTEST_COMPILER_CODEGEN_TESTER_H_
 
 #include "src/compiler/instruction-selector.h"
 #include "src/compiler/pipeline.h"
 #include "src/compiler/raw-machine-assembler.h"
 #include "src/simulator.h"
 #include "test/cctest/compiler/call-tester.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 template <typename ReturnType>
 class RawMachineAssemblerTester : public HandleAndZoneScope,
                                   public CallHelper<ReturnType>,
                                   public RawMachineAssembler {
  public:
-  RawMachineAssemblerTester(MachineType p0 = kMachNone,
-                            MachineType p1 = kMachNone,
-                            MachineType p2 = kMachNone,
-                            MachineType p3 = kMachNone,
-                            MachineType p4 = kMachNone)
+  RawMachineAssemblerTester(MachineType p0 = MachineType::None(),
+                            MachineType p1 = MachineType::None(),
+                            MachineType p2 = MachineType::None(),
+                            MachineType p3 = MachineType::None(),
+                            MachineType p4 = MachineType::None())
       : HandleAndZoneScope(),
         CallHelper<ReturnType>(
             main_isolate(),
             CSignature::New(main_zone(), MachineTypeForC<ReturnType>(), p0, p1,
                             p2, p3, p4)),
         RawMachineAssembler(
             main_isolate(), new (main_zone()) Graph(main_zone()),
             Linkage::GetSimplifiedCDescriptor(
                 main_zone(),
                 CSignature::New(main_zone(), MachineTypeForC<ReturnType>(), p0,
                                 p1, p2, p3, p4)),
-            kMachPtr, InstructionSelector::SupportedMachineOperatorFlags()) {}
+            MachineType::PointerRepresentation(),
+            InstructionSelector::SupportedMachineOperatorFlags()) {}
 
   void CheckNumber(double expected, Object* number) {
     CHECK(this->isolate()->factory()->NewNumber(expected)->SameValue(number));
   }
 
   void CheckString(const char* expected, Object* string) {
     CHECK(
         this->isolate()->factory()->InternalizeUtf8String(expected)->SameValue(
             string));
   }
@@ skipping 20 matching lines @@
 
  private:
   MaybeHandle<Code> code_;
 };
 
 
 template <typename ReturnType>
 class BufferedRawMachineAssemblerTester
     : public RawMachineAssemblerTester<int32_t> {
  public:
-  BufferedRawMachineAssemblerTester(MachineType p0 = kMachNone,
-                                    MachineType p1 = kMachNone,
-                                    MachineType p2 = kMachNone,
-                                    MachineType p3 = kMachNone)
+  BufferedRawMachineAssemblerTester(MachineType p0 = MachineType::None(),
+                                    MachineType p1 = MachineType::None(),
+                                    MachineType p2 = MachineType::None(),
+                                    MachineType p3 = MachineType::None())
       : BufferedRawMachineAssemblerTester(ComputeParameterCount(p0, p1, p2, p3),
                                           p0, p1, p2, p3) {}
 
 
   // The BufferedRawMachineAssemblerTester does not pass parameters directly
   // to the constructed IR graph. Instead it passes a pointer to the parameter
   // to the IR graph, and adds Load nodes to the IR graph to load the
   // parameters from memory. Thereby it is possible to pass 64 bit parameters
   // to the IR graph.
   Node* Parameter(size_t index) {
@@ skipping 58 matching lines @@
         reinterpret_cast<void*>(&p2), reinterpret_cast<void*>(&p3),
         reinterpret_cast<void*>(&return_value));
     return return_value;
   }
 
  private:
   BufferedRawMachineAssemblerTester(uint32_t return_parameter_index,
                                     MachineType p0, MachineType p1,
                                     MachineType p2, MachineType p3)
       : RawMachineAssemblerTester<int32_t>(
-            kMachPtr, p0 == kMachNone ? kMachNone : kMachPtr,
-            p1 == kMachNone ? kMachNone : kMachPtr,
-            p2 == kMachNone ? kMachNone : kMachPtr,
-            p3 == kMachNone ? kMachNone : kMachPtr),
+            MachineType::Pointer(),
+            p0 == MachineType::None() ? MachineType::None()
+                                      : MachineType::Pointer(),
+            p1 == MachineType::None() ? MachineType::None()
+                                      : MachineType::Pointer(),
+            p2 == MachineType::None() ? MachineType::None()
+                                      : MachineType::Pointer(),
+            p3 == MachineType::None() ? MachineType::None()
+                                      : MachineType::Pointer()),
         test_graph_signature_(
-            CSignature::New(main_zone(), kMachInt32, p0, p1, p2, p3)),
+            CSignature::New(main_zone(), MachineType::Int32(), p0, p1, p2, p3)),
         return_parameter_index_(return_parameter_index) {
-    parameter_nodes_[0] =
-        p0 == kMachNone ? nullptr : Load(p0, RawMachineAssembler::Parameter(0));
-    parameter_nodes_[1] =
-        p1 == kMachNone ? nullptr : Load(p1, RawMachineAssembler::Parameter(1));
-    parameter_nodes_[2] =
-        p2 == kMachNone ? nullptr : Load(p2, RawMachineAssembler::Parameter(2));
-    parameter_nodes_[3] =
-        p3 == kMachNone ? nullptr : Load(p3, RawMachineAssembler::Parameter(3));
+    parameter_nodes_[0] = p0 == MachineType::None()
+                              ? nullptr
+                              : Load(p0, RawMachineAssembler::Parameter(0));
+    parameter_nodes_[1] = p1 == MachineType::None()
+                              ? nullptr
+                              : Load(p1, RawMachineAssembler::Parameter(1));
+    parameter_nodes_[2] = p2 == MachineType::None()
+                              ? nullptr
+                              : Load(p2, RawMachineAssembler::Parameter(2));
+    parameter_nodes_[3] = p3 == MachineType::None()
+                              ? nullptr
+                              : Load(p3, RawMachineAssembler::Parameter(3));
   }
 
 
   static uint32_t ComputeParameterCount(MachineType p0, MachineType p1,
                                         MachineType p2, MachineType p3) {
-    if (p0 == kMachNone) {
+    if (p0 == MachineType::None()) {
       return 0;
     }
-    if (p1 == kMachNone) {
+    if (p1 == MachineType::None()) {
       return 1;
     }
-    if (p2 == kMachNone) {
+    if (p2 == MachineType::None()) {
       return 2;
     }
-    if (p3 == kMachNone) {
+    if (p3 == MachineType::None()) {
       return 3;
     }
     return 4;
   }
 
 
   CSignature* test_graph_signature_;
   Node* parameter_nodes_[4];
   uint32_t return_parameter_index_;
 };
 
 
 template <>
 class BufferedRawMachineAssemblerTester<void>
     : public RawMachineAssemblerTester<void> {
  public:
-  BufferedRawMachineAssemblerTester(MachineType p0 = kMachNone,
-                                    MachineType p1 = kMachNone,
-                                    MachineType p2 = kMachNone,
-                                    MachineType p3 = kMachNone)
-      : RawMachineAssemblerTester<void>(p0 == kMachNone ? kMachNone : kMachPtr,
-                                        p1 == kMachNone ? kMachNone : kMachPtr,
-                                        p2 == kMachNone ? kMachNone : kMachPtr,
-                                        p3 == kMachNone ? kMachNone : kMachPtr),
+  BufferedRawMachineAssemblerTester(MachineType p0 = MachineType::None(),
+                                    MachineType p1 = MachineType::None(),
+                                    MachineType p2 = MachineType::None(),
+                                    MachineType p3 = MachineType::None())
+      : RawMachineAssemblerTester<void>(
+            p0 == MachineType::None() ? MachineType::None()
+                                      : MachineType::Pointer(),
+            p1 == MachineType::None() ? MachineType::None()
+                                      : MachineType::Pointer(),
+            p2 == MachineType::None() ? MachineType::None()
+                                      : MachineType::Pointer(),
+            p3 == MachineType::None() ? MachineType::None()
+                                      : MachineType::Pointer()),
         test_graph_signature_(
             CSignature::New(RawMachineAssemblerTester<void>::main_zone(),
-                            kMachNone, p0, p1, p2, p3)) {
-    parameter_nodes_[0] =
-        p0 == kMachNone ? nullptr : Load(p0, RawMachineAssembler::Parameter(0));
-    parameter_nodes_[1] =
-        p1 == kMachNone ? nullptr : Load(p1, RawMachineAssembler::Parameter(1));
-    parameter_nodes_[2] =
-        p2 == kMachNone ? nullptr : Load(p2, RawMachineAssembler::Parameter(2));
-    parameter_nodes_[3] =
-        p3 == kMachNone ? nullptr : Load(p3, RawMachineAssembler::Parameter(3));
+                            MachineType::None(), p0, p1, p2, p3)) {
+    parameter_nodes_[0] = p0 == MachineType::None()
+                              ? nullptr
+                              : Load(p0, RawMachineAssembler::Parameter(0));
+    parameter_nodes_[1] = p1 == MachineType::None()
+                              ? nullptr
+                              : Load(p1, RawMachineAssembler::Parameter(1));
+    parameter_nodes_[2] = p2 == MachineType::None()
+                              ? nullptr
+                              : Load(p2, RawMachineAssembler::Parameter(2));
+    parameter_nodes_[3] = p3 == MachineType::None()
+                              ? nullptr
+                              : Load(p3, RawMachineAssembler::Parameter(3));
   }
 
 
   // The BufferedRawMachineAssemblerTester does not pass parameters directly
   // to the constructed IR graph. Instead it passes a pointer to the parameter
   // to the IR graph, and adds Load nodes to the IR graph to load the
   // parameters from memory. Thereby it is possible to pass 64 bit parameters
   // to the IR graph.
   Node* Parameter(size_t index) {
     CHECK(index >= 0 && index < 4);
@@ skipping 39 matching lines @@
   CSignature* test_graph_signature_;
   Node* parameter_nodes_[4];
 };
 static const bool USE_RESULT_BUFFER = true;
 static const bool USE_RETURN_REGISTER = false;
 static const int32_t CHECK_VALUE = 0x99BEEDCE;
 
 
 // TODO(titzer): use the C-style calling convention, or any register-based
 // calling convention for binop tests.
-template <typename CType, MachineType rep, bool use_result_buffer>
+template <typename CType, bool use_result_buffer>
 class BinopTester {
  public:
-  explicit BinopTester(RawMachineAssemblerTester<int32_t>* tester)
+  explicit BinopTester(RawMachineAssemblerTester<int32_t>* tester,
+                       MachineType rep)
       : T(tester),
         param0(T->LoadFromPointer(&p0, rep)),
         param1(T->LoadFromPointer(&p1, rep)),
+        rep(rep),
         p0(static_cast<CType>(0)),
         p1(static_cast<CType>(0)),
         result(static_cast<CType>(0)) {}
 
   RawMachineAssemblerTester<int32_t>* T;
   Node* param0;
   Node* param1;
 
   CType call(CType a0, CType a1) {
     p0 = a0;
@@ skipping 21 matching lines @@
     typename Ci::const_iterator i;
     typename Cj::const_iterator j;
     for (i = ci.begin(); i != ci.end(); ++i) {
       for (j = cj.begin(); j != cj.end(); ++j) {
         CHECK_EQ(fn(*i, *j), this->call(*i, *j));
       }
     }
   }
 
  protected:
+  MachineType rep;
   CType p0;
   CType p1;
   CType result;
 };
 
 
 // A helper class for testing code sequences that take two int parameters and
 // return an int value.
-class Int32BinopTester
-    : public BinopTester<int32_t, kMachInt32, USE_RETURN_REGISTER> {
+class Int32BinopTester : public BinopTester<int32_t, USE_RETURN_REGISTER> {
  public:
   explicit Int32BinopTester(RawMachineAssemblerTester<int32_t>* tester)
-      : BinopTester<int32_t, kMachInt32, USE_RETURN_REGISTER>(tester) {}
+      : BinopTester<int32_t, USE_RETURN_REGISTER>(tester,
+                                                  MachineType::Int32()) {}
 };
 
 
 // A helper class for testing code sequences that take two uint parameters and
 // return an uint value.
-class Uint32BinopTester
-    : public BinopTester<uint32_t, kMachUint32, USE_RETURN_REGISTER> {
+class Uint32BinopTester : public BinopTester<uint32_t, USE_RETURN_REGISTER> {
  public:
   explicit Uint32BinopTester(RawMachineAssemblerTester<int32_t>* tester)
-      : BinopTester<uint32_t, kMachUint32, USE_RETURN_REGISTER>(tester) {}
+      : BinopTester<uint32_t, USE_RETURN_REGISTER>(tester,
+                                                   MachineType::Uint32()) {}
 
   uint32_t call(uint32_t a0, uint32_t a1) {
     p0 = a0;
     p1 = a1;
     return static_cast<uint32_t>(T->Call());
   }
 };
 
 
 // A helper class for testing code sequences that take two float parameters and
 // return a float value.
 // TODO(titzer): figure out how to return floats correctly on ia32.
-class Float32BinopTester
-    : public BinopTester<float, kMachFloat32, USE_RESULT_BUFFER> {
+class Float32BinopTester : public BinopTester<float, USE_RESULT_BUFFER> {
  public:
   explicit Float32BinopTester(RawMachineAssemblerTester<int32_t>* tester)
-      : BinopTester<float, kMachFloat32, USE_RESULT_BUFFER>(tester) {}
+      : BinopTester<float, USE_RESULT_BUFFER>(tester, MachineType::Float32()) {}
 };
 
 
 // A helper class for testing code sequences that take two double parameters and
 // return a double value.
 // TODO(titzer): figure out how to return doubles correctly on ia32.
-class Float64BinopTester
-    : public BinopTester<double, kMachFloat64, USE_RESULT_BUFFER> {
+class Float64BinopTester : public BinopTester<double, USE_RESULT_BUFFER> {
  public:
   explicit Float64BinopTester(RawMachineAssemblerTester<int32_t>* tester)
-      : BinopTester<double, kMachFloat64, USE_RESULT_BUFFER>(tester) {}
+      : BinopTester<double, USE_RESULT_BUFFER>(tester, MachineType::Float64()) {
+  }
 };
 
 
 // A helper class for testing code sequences that take two pointer parameters
 // and return a pointer value.
 // TODO(titzer): pick word size of pointers based on V8_TARGET.
 template <typename Type>
-class PointerBinopTester
-    : public BinopTester<Type*, kMachPtr, USE_RETURN_REGISTER> {
+class PointerBinopTester : public BinopTester<Type*, USE_RETURN_REGISTER> {
  public:
   explicit PointerBinopTester(RawMachineAssemblerTester<int32_t>* tester)
-      : BinopTester<Type*, kMachPtr, USE_RETURN_REGISTER>(tester) {}
+      : BinopTester<Type*, USE_RETURN_REGISTER>(tester,
+                                                MachineType::Pointer()) {}
 };
 
 
 // A helper class for testing code sequences that take two tagged parameters and
 // return a tagged value.
 template <typename Type>
-class TaggedBinopTester
-    : public BinopTester<Type*, kMachAnyTagged, USE_RETURN_REGISTER> {
+class TaggedBinopTester : public BinopTester<Type*, USE_RETURN_REGISTER> {
  public:
   explicit TaggedBinopTester(RawMachineAssemblerTester<int32_t>* tester)
-      : BinopTester<Type*, kMachAnyTagged, USE_RETURN_REGISTER>(tester) {}
+      : BinopTester<Type*, USE_RETURN_REGISTER>(tester,
+                                                MachineType::AnyTagged()) {}
 };
 
 // A helper class for testing compares. Wraps a machine opcode and provides
 // evaluation routines and the operators.
 class CompareWrapper {
  public:
   explicit CompareWrapper(IrOpcode::Value op) : opcode(op) {}
 
   Node* MakeNode(RawMachineAssemblerTester<int32_t>* m, Node* a, Node* b) {
     return m->AddNode(op(m->machine()), a, b);
@@ skipping 104 matching lines @@
   } else {
     CHECK_EQ(x, y);
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CCTEST_COMPILER_CODEGEN_TESTER_H_