[turbofan] Make MachineType a pair of enums.

test/unittests/compiler/instruction-selector-unittest.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 "test/unittests/compiler/instruction-selector-unittest.h"
 
 #include "src/code-factory.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/schedule.h"
 #include "src/flags.h"
@@ skipping 140 matching lines @@
       Handle<SharedFunctionInfo>(), CALL_MAINTAINS_NATIVE_CONTEXT);
 }
 
 
 // -----------------------------------------------------------------------------
 // Return.
 
 
 TARGET_TEST_F(InstructionSelectorTest, ReturnFloat32Constant) {
   const float kValue = 4.2f;
-  StreamBuilder m(this, kMachFloat32);
+  StreamBuilder m(this, MachineType::Float32());
   m.Return(m.Float32Constant(kValue));
   Stream s = m.Build(kAllInstructions);
   ASSERT_EQ(3U, s.size());
   EXPECT_EQ(kArchNop, s[0]->arch_opcode());
   ASSERT_EQ(InstructionOperand::CONSTANT, s[0]->OutputAt(0)->kind());
   EXPECT_FLOAT_EQ(kValue, s.ToFloat32(s[0]->OutputAt(0)));
   EXPECT_EQ(kArchRet, s[1]->arch_opcode());
   EXPECT_EQ(1U, s[1]->InputCount());
 }
 
 
 TARGET_TEST_F(InstructionSelectorTest, ReturnParameter) {
-  StreamBuilder m(this, kMachInt32, kMachInt32);
+  StreamBuilder m(this, MachineType::Int32(), MachineType::Int32());
   m.Return(m.Parameter(0));
   Stream s = m.Build(kAllInstructions);
   ASSERT_EQ(3U, s.size());
   EXPECT_EQ(kArchNop, s[0]->arch_opcode());
   ASSERT_EQ(1U, s[0]->OutputCount());
   EXPECT_EQ(kArchRet, s[1]->arch_opcode());
   EXPECT_EQ(1U, s[1]->InputCount());
 }
 
 
 TARGET_TEST_F(InstructionSelectorTest, ReturnZero) {
-  StreamBuilder m(this, kMachInt32);
+  StreamBuilder m(this, MachineType::Int32());
   m.Return(m.Int32Constant(0));
   Stream s = m.Build(kAllInstructions);
   ASSERT_EQ(3U, s.size());
   EXPECT_EQ(kArchNop, s[0]->arch_opcode());
   ASSERT_EQ(1U, s[0]->OutputCount());
   EXPECT_EQ(InstructionOperand::CONSTANT, s[0]->OutputAt(0)->kind());
   EXPECT_EQ(0, s.ToInt32(s[0]->OutputAt(0)));
   EXPECT_EQ(kArchRet, s[1]->arch_opcode());
   EXPECT_EQ(1U, s[1]->InputCount());
 }
 
 
 // -----------------------------------------------------------------------------
 // Conversions.
 
 
 TARGET_TEST_F(InstructionSelectorTest, TruncateFloat64ToInt32WithParameter) {
-  StreamBuilder m(this, kMachInt32, kMachFloat64);
+  StreamBuilder m(this, MachineType::Int32(), MachineType::Float64());
   m.Return(
       m.TruncateFloat64ToInt32(TruncationMode::kJavaScript, m.Parameter(0)));
   Stream s = m.Build(kAllInstructions);
   ASSERT_EQ(4U, s.size());
   EXPECT_EQ(kArchNop, s[0]->arch_opcode());
   EXPECT_EQ(kArchTruncateDoubleToI, s[1]->arch_opcode());
   EXPECT_EQ(1U, s[1]->InputCount());
   EXPECT_EQ(1U, s[1]->OutputCount());
   EXPECT_EQ(kArchRet, s[2]->arch_opcode());
 }
 
 
 // -----------------------------------------------------------------------------
 // Parameters.
 
 
 TARGET_TEST_F(InstructionSelectorTest, DoubleParameter) {
-  StreamBuilder m(this, kMachFloat64, kMachFloat64);
+  StreamBuilder m(this, MachineType::Float64(), MachineType::Float64());
   Node* param = m.Parameter(0);
   m.Return(param);
   Stream s = m.Build(kAllInstructions);
   EXPECT_TRUE(s.IsDouble(param));
 }
 
 
 TARGET_TEST_F(InstructionSelectorTest, ReferenceParameter) {
-  StreamBuilder m(this, kMachAnyTagged, kMachAnyTagged);
+  StreamBuilder m(this, MachineType::AnyTagged(), MachineType::AnyTagged());
   Node* param = m.Parameter(0);
   m.Return(param);
   Stream s = m.Build(kAllInstructions);
   EXPECT_TRUE(s.IsReference(param));
 }
 
 
 // -----------------------------------------------------------------------------
 // FinishRegion.
 
 
 TARGET_TEST_F(InstructionSelectorTest, FinishRegion) {
-  StreamBuilder m(this, kMachAnyTagged, kMachAnyTagged);
+  StreamBuilder m(this, MachineType::AnyTagged(), MachineType::AnyTagged());
   Node* param = m.Parameter(0);
   Node* finish =
       m.AddNode(m.common()->FinishRegion(), param, m.graph()->start());
   m.Return(finish);
   Stream s = m.Build(kAllInstructions);
   ASSERT_EQ(4U, s.size());
   EXPECT_EQ(kArchNop, s[0]->arch_opcode());
   ASSERT_EQ(1U, s[0]->OutputCount());
   ASSERT_TRUE(s[0]->Output()->IsUnallocated());
   EXPECT_EQ(s.ToVreg(param), s.ToVreg(s[0]->Output()));
@@ skipping 22 matching lines @@
   StreamBuilder m(this, type, type, type);
   Node* param0 = m.Parameter(0);
   Node* param1 = m.Parameter(1);
   RawMachineLabel a, b, c;
   m.Branch(m.Int32Constant(0), &a, &b);
   m.Bind(&a);
   m.Goto(&c);
   m.Bind(&b);
   m.Goto(&c);
   m.Bind(&c);
-  Node* phi = m.Phi(type, param0, param1);
+  Node* phi = m.Phi(type.representation(), param0, param1);
   m.Return(phi);
   Stream s = m.Build(kAllInstructions);
   EXPECT_EQ(s.IsDouble(phi), s.IsDouble(param0));
   EXPECT_EQ(s.IsDouble(phi), s.IsDouble(param1));
 }
 
 
 TARGET_TEST_P(InstructionSelectorPhiTest, Referenceness) {
   const MachineType type = GetParam();
   StreamBuilder m(this, type, type, type);
   Node* param0 = m.Parameter(0);
   Node* param1 = m.Parameter(1);
   RawMachineLabel a, b, c;
   m.Branch(m.Int32Constant(1), &a, &b);
   m.Bind(&a);
   m.Goto(&c);
   m.Bind(&b);
   m.Goto(&c);
   m.Bind(&c);
-  Node* phi = m.Phi(type, param0, param1);
+  Node* phi = m.Phi(type.representation(), param0, param1);
   m.Return(phi);
   Stream s = m.Build(kAllInstructions);
   EXPECT_EQ(s.IsReference(phi), s.IsReference(param0));
   EXPECT_EQ(s.IsReference(phi), s.IsReference(param1));
 }
 
 
-INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, InstructionSelectorPhiTest,
-                        ::testing::Values(kMachFloat64, kMachInt8, kMachUint8,
-                                          kMachInt16, kMachUint16, kMachInt32,
-                                          kMachUint32, kMachInt64, kMachUint64,
-                                          kMachPtr, kMachAnyTagged));
+INSTANTIATE_TEST_CASE_P(
+    InstructionSelectorTest, InstructionSelectorPhiTest,
+    ::testing::Values(MachineType::Float64(), MachineType::Int8(),
+                      MachineType::Uint8(), MachineType::Int16(),
+                      MachineType::Uint16(), MachineType::Int32(),
+                      MachineType::Uint32(), MachineType::Int64(),
+                      MachineType::Uint64(), MachineType::Pointer(),
+                      MachineType::AnyTagged()));
 
 
 // -----------------------------------------------------------------------------
 // ValueEffect.
 
 
 TARGET_TEST_F(InstructionSelectorTest, ValueEffect) {
-  StreamBuilder m1(this, kMachInt32, kMachPtr);
+  StreamBuilder m1(this, MachineType::Int32(), MachineType::Pointer());
   Node* p1 = m1.Parameter(0);
-  m1.Return(m1.Load(kMachInt32, p1, m1.Int32Constant(0)));
+  m1.Return(m1.Load(MachineType::Int32(), p1, m1.Int32Constant(0)));
   Stream s1 = m1.Build(kAllInstructions);
-  StreamBuilder m2(this, kMachInt32, kMachPtr);
+  StreamBuilder m2(this, MachineType::Int32(), MachineType::Pointer());
   Node* p2 = m2.Parameter(0);
-  m2.Return(
-      m2.AddNode(m2.machine()->Load(kMachInt32), p2, m2.Int32Constant(0),
-                 m2.AddNode(m2.common()->BeginRegion(), m2.graph()->start())));
+  m2.Return(m2.AddNode(
+      m2.machine()->Load(MachineType::Int32()), p2, m2.Int32Constant(0),
+      m2.AddNode(m2.common()->BeginRegion(), m2.graph()->start())));
   Stream s2 = m2.Build(kAllInstructions);
   EXPECT_LE(3U, s1.size());
   ASSERT_EQ(s1.size(), s2.size());
   TRACED_FORRANGE(size_t, i, 0, s1.size() - 1) {
     const Instruction* i1 = s1[i];
     const Instruction* i2 = s2[i];
     EXPECT_EQ(i1->arch_opcode(), i2->arch_opcode());
     EXPECT_EQ(i1->InputCount(), i2->InputCount());
     EXPECT_EQ(i1->OutputCount(), i2->OutputCount());
   }
 }
 
 
 // -----------------------------------------------------------------------------
 // Calls with deoptimization.
 
 
 TARGET_TEST_F(InstructionSelectorTest, CallJSFunctionWithDeopt) {
-  StreamBuilder m(this, kMachAnyTagged, kMachAnyTagged, kMachAnyTagged,
-                  kMachAnyTagged);
+  StreamBuilder m(this, MachineType::AnyTagged(), MachineType::AnyTagged(),
+                  MachineType::AnyTagged(), MachineType::AnyTagged());
 
   BailoutId bailout_id(42);
 
   Node* function_node = m.Parameter(0);
   Node* receiver = m.Parameter(1);
   Node* context = m.Parameter(2);
 
-  ZoneVector<MachineType> int32_type(1, kMachInt32, zone());
+  ZoneVector<MachineType> int32_type(1, MachineType::Int32(), zone());
   ZoneVector<MachineType> empty_types(zone());
 
   CallDescriptor* descriptor = Linkage::GetJSCallDescriptor(
       zone(), false, 1, CallDescriptor::kNeedsFrameState);
 
   // Build frame state for the state before the call.
   Node* parameters =
       m.AddNode(m.common()->TypedStateValues(&int32_type), m.Int32Constant(1));
   Node* locals = m.AddNode(m.common()->TypedStateValues(&empty_types));
   Node* stack = m.AddNode(m.common()->TypedStateValues(&empty_types));
@@ skipping 21 matching lines @@
   ASSERT_EQ(index + 2, s.size());
 
   EXPECT_EQ(kArchCallJSFunction, s[index++]->arch_opcode());
   EXPECT_EQ(kArchRet, s[index++]->arch_opcode());
 
   // TODO(jarin) Check deoptimization table.
 }
 
 
 TARGET_TEST_F(InstructionSelectorTest, CallStubWithDeopt) {
-  StreamBuilder m(this, kMachAnyTagged, kMachAnyTagged, kMachAnyTagged,
-                  kMachAnyTagged);
+  StreamBuilder m(this, MachineType::AnyTagged(), MachineType::AnyTagged(),
+                  MachineType::AnyTagged(), MachineType::AnyTagged());
 
   BailoutId bailout_id_before(42);
 
   // Some arguments for the call node.
   Node* function_node = m.Parameter(0);
   Node* receiver = m.Parameter(1);
   Node* context = m.Int32Constant(1);  // Context is ignored.
 
-  ZoneVector<MachineType> int32_type(1, kMachInt32, zone());
-  ZoneVector<MachineType> float64_type(1, kMachFloat64, zone());
-  ZoneVector<MachineType> tagged_type(1, kMachAnyTagged, zone());
+  ZoneVector<MachineType> int32_type(1, MachineType::Int32(), zone());
+  ZoneVector<MachineType> float64_type(1, MachineType::Float64(), zone());
+  ZoneVector<MachineType> tagged_type(1, MachineType::AnyTagged(), zone());
 
   Callable callable = CodeFactory::ToObject(isolate());
   CallDescriptor* descriptor = Linkage::GetStubCallDescriptor(
       isolate(), zone(), callable.descriptor(), 1,
       CallDescriptor::kNeedsFrameState, Operator::kNoProperties);
 
   // Build frame state for the state before the call.
   Node* parameters =
       m.AddNode(m.common()->TypedStateValues(&int32_type), m.Int32Constant(43));
   Node* locals = m.AddNode(m.common()->TypedStateValues(&float64_type),
@@ skipping 45 matching lines @@
   EXPECT_EQ(OutputFrameStateCombine::kPushOutput,
             desc_before->state_combine().kind());
   EXPECT_EQ(1u, desc_before->parameters_count());
   EXPECT_EQ(1u, desc_before->locals_count());
   EXPECT_EQ(1u, desc_before->stack_count());
   EXPECT_EQ(43, s.ToInt32(call_instr->InputAt(3)));
   EXPECT_EQ(0, s.ToInt32(call_instr->InputAt(4)));  // This should be a context.
                                                     // We inserted 0 here.
   EXPECT_EQ(0.5, s.ToFloat64(call_instr->InputAt(5)));
   EXPECT_TRUE(s.ToHeapObject(call_instr->InputAt(6))->IsUndefined());
-  EXPECT_EQ(kMachAnyTagged, desc_before->GetType(0));  // function is always
-                                                       // tagged/any.
-  EXPECT_EQ(kMachInt32, desc_before->GetType(1));
-  EXPECT_EQ(kMachAnyTagged, desc_before->GetType(2));  // context is always
-                                                       // tagged/any.
-  EXPECT_EQ(kMachFloat64, desc_before->GetType(3));
-  EXPECT_EQ(kMachAnyTagged, desc_before->GetType(4));
+  EXPECT_EQ(MachineType::AnyTagged(),
+            desc_before->GetType(0));  // function is always
+                                       // tagged/any.
+  EXPECT_EQ(MachineType::Int32(), desc_before->GetType(1));
+  EXPECT_EQ(MachineType::AnyTagged(),
+            desc_before->GetType(2));  // context is always
+                                       // tagged/any.
+  EXPECT_EQ(MachineType::Float64(), desc_before->GetType(3));
+  EXPECT_EQ(MachineType::AnyTagged(), desc_before->GetType(4));
 
   // Function.
   EXPECT_EQ(s.ToVreg(function_node), s.ToVreg(call_instr->InputAt(7)));
   // Context.
   EXPECT_EQ(s.ToVreg(context), s.ToVreg(call_instr->InputAt(8)));
 
   EXPECT_EQ(kArchRet, s[index++]->arch_opcode());
 
   EXPECT_EQ(index, s.size());
 }
 
 
 TARGET_TEST_F(InstructionSelectorTest, CallStubWithDeoptRecursiveFrameState) {
-  StreamBuilder m(this, kMachAnyTagged, kMachAnyTagged, kMachAnyTagged,
-                  kMachAnyTagged);
+  StreamBuilder m(this, MachineType::AnyTagged(), MachineType::AnyTagged(),
+                  MachineType::AnyTagged(), MachineType::AnyTagged());
 
   BailoutId bailout_id_before(42);
   BailoutId bailout_id_parent(62);
 
   // Some arguments for the call node.
   Node* function_node = m.Parameter(0);
   Node* receiver = m.Parameter(1);
   Node* context = m.Int32Constant(66);
   Node* context2 = m.Int32Constant(46);
 
-  ZoneVector<MachineType> int32_type(1, kMachInt32, zone());
-  ZoneVector<MachineType> int32x2_type(2, kMachInt32, zone());
-  ZoneVector<MachineType> float64_type(1, kMachFloat64, zone());
+  ZoneVector<MachineType> int32_type(1, MachineType::Int32(), zone());
+  ZoneVector<MachineType> int32x2_type(2, MachineType::Int32(), zone());
+  ZoneVector<MachineType> float64_type(1, MachineType::Float64(), zone());
 
   Callable callable = CodeFactory::ToObject(isolate());
   CallDescriptor* descriptor = Linkage::GetStubCallDescriptor(
       isolate(), zone(), callable.descriptor(), 1,
       CallDescriptor::kNeedsFrameState, Operator::kNoProperties);
 
   // Build frame state for the state before the call.
   Node* parameters =
       m.AddNode(m.common()->TypedStateValues(&int32_type), m.Int32Constant(63));
   Node* locals =
@@ skipping 51 matching lines @@
   // Deoptimization id.
   int32_t deopt_id_before = s.ToInt32(call_instr->InputAt(1));
   FrameStateDescriptor* desc_before =
       s.GetFrameStateDescriptor(deopt_id_before);
   FrameStateDescriptor* desc_before_outer = desc_before->outer_state();
   EXPECT_EQ(bailout_id_before, desc_before->bailout_id());
   EXPECT_EQ(1u, desc_before_outer->parameters_count());
   EXPECT_EQ(1u, desc_before_outer->locals_count());
   EXPECT_EQ(1u, desc_before_outer->stack_count());
   // Values from parent environment.
-  EXPECT_EQ(kMachAnyTagged, desc_before->GetType(0));
+  EXPECT_EQ(MachineType::AnyTagged(), desc_before->GetType(0));
   EXPECT_EQ(63, s.ToInt32(call_instr->InputAt(3)));
-  EXPECT_EQ(kMachInt32, desc_before_outer->GetType(1));
+  EXPECT_EQ(MachineType::Int32(), desc_before_outer->GetType(1));
   // Context:
   EXPECT_EQ(66, s.ToInt32(call_instr->InputAt(4)));
-  EXPECT_EQ(kMachAnyTagged, desc_before_outer->GetType(2));
+  EXPECT_EQ(MachineType::AnyTagged(), desc_before_outer->GetType(2));
   EXPECT_EQ(64, s.ToInt32(call_instr->InputAt(5)));
-  EXPECT_EQ(kMachInt32, desc_before_outer->GetType(3));
+  EXPECT_EQ(MachineType::Int32(), desc_before_outer->GetType(3));
   EXPECT_EQ(65, s.ToInt32(call_instr->InputAt(6)));
-  EXPECT_EQ(kMachInt32, desc_before_outer->GetType(4));
+  EXPECT_EQ(MachineType::Int32(), desc_before_outer->GetType(4));
   // Values from the nested frame.
   EXPECT_EQ(1u, desc_before->parameters_count());
   EXPECT_EQ(1u, desc_before->locals_count());
   EXPECT_EQ(2u, desc_before->stack_count());
-  EXPECT_EQ(kMachAnyTagged, desc_before->GetType(0));
+  EXPECT_EQ(MachineType::AnyTagged(), desc_before->GetType(0));
   EXPECT_EQ(43, s.ToInt32(call_instr->InputAt(8)));
-  EXPECT_EQ(kMachInt32, desc_before->GetType(1));
+  EXPECT_EQ(MachineType::Int32(), desc_before->GetType(1));
   EXPECT_EQ(46, s.ToInt32(call_instr->InputAt(9)));
-  EXPECT_EQ(kMachAnyTagged, desc_before->GetType(2));
+  EXPECT_EQ(MachineType::AnyTagged(), desc_before->GetType(2));
   EXPECT_EQ(0.25, s.ToFloat64(call_instr->InputAt(10)));
-  EXPECT_EQ(kMachFloat64, desc_before->GetType(3));
+  EXPECT_EQ(MachineType::Float64(), desc_before->GetType(3));
   EXPECT_EQ(44, s.ToInt32(call_instr->InputAt(11)));
-  EXPECT_EQ(kMachInt32, desc_before->GetType(4));
+  EXPECT_EQ(MachineType::Int32(), desc_before->GetType(4));
   EXPECT_EQ(45, s.ToInt32(call_instr->InputAt(12)));
-  EXPECT_EQ(kMachInt32, desc_before->GetType(5));
+  EXPECT_EQ(MachineType::Int32(), desc_before->GetType(5));
 
   // Function.
   EXPECT_EQ(s.ToVreg(function_node), s.ToVreg(call_instr->InputAt(13)));
   // Context.
   EXPECT_EQ(s.ToVreg(context2), s.ToVreg(call_instr->InputAt(14)));
   // Continuation.
 
   EXPECT_EQ(kArchRet, s[index++]->arch_opcode());
   EXPECT_EQ(index, s.size());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8