Unify MachineType and RepType.

test/cctest/compiler/test-structured-machine-assembler.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 "src/v8.h"
 #include "test/cctest/cctest.h"
 
 #include "src/base/utils/random-number-generator.h"
 #include "src/compiler/structured-machine-assembler.h"
 #include "test/cctest/compiler/codegen-tester.h"
@@ skipping 32 matching lines @@
 
   Variable v1 = m.NewVariable(m.Int32Constant(constant));
   Variable v2 = m.NewVariable(v1.Get());
   m.Return(v2.Get());
 
   CHECK_EQ(constant, m.Call());
 }
 
 
 TEST(RunSimpleIf) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   int32_t constant = 0xc4a3e3a6;
   {
     IfBuilder cond(&m);
     cond.If(m.Parameter(0)).Then();
     m.Return(m.Int32Constant(constant));
   }
   m.Return(m.Word32Not(m.Int32Constant(constant)));
 
   CHECK_EQ(~constant, m.Call(0));
   CHECK_EQ(constant, m.Call(1));
 }
 
 
 TEST(RunSimpleIfVariable) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   int32_t constant = 0xdb6f20c2;
   Variable var = m.NewVariable(m.Int32Constant(constant));
   {
     IfBuilder cond(&m);
     cond.If(m.Parameter(0)).Then();
     var.Set(m.Word32Not(var.Get()));
   }
   m.Return(var.Get());
 
   CHECK_EQ(constant, m.Call(0));
   CHECK_EQ(~constant, m.Call(1));
 }
 
 
 TEST(RunSimpleElse) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   int32_t constant = 0xfc5eadf4;
   {
     IfBuilder cond(&m);
     cond.If(m.Parameter(0)).Else();
     m.Return(m.Int32Constant(constant));
   }
   m.Return(m.Word32Not(m.Int32Constant(constant)));
 
   CHECK_EQ(constant, m.Call(0));
   CHECK_EQ(~constant, m.Call(1));
 }
 
 
 TEST(RunSimpleIfElse) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   int32_t constant = 0xaa9c8cd3;
   {
     IfBuilder cond(&m);
     cond.If(m.Parameter(0)).Then();
     m.Return(m.Int32Constant(constant));
     cond.Else();
     m.Return(m.Word32Not(m.Int32Constant(constant)));
   }
 
   CHECK_EQ(~constant, m.Call(0));
   CHECK_EQ(constant, m.Call(1));
 }
 
 
 TEST(RunSimpleIfElseVariable) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   int32_t constant = 0x67b6f39c;
   Variable var = m.NewVariable(m.Int32Constant(constant));
   {
     IfBuilder cond(&m);
     cond.If(m.Parameter(0)).Then();
     var.Set(m.Word32Not(m.Word32Not(var.Get())));
     cond.Else();
     var.Set(m.Word32Not(var.Get()));
   }
   m.Return(var.Get());
 
   CHECK_EQ(~constant, m.Call(0));
   CHECK_EQ(constant, m.Call(1));
 }
 
 
 TEST(RunSimpleIfNoThenElse) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   int32_t constant = 0xd5e550ed;
   {
     IfBuilder cond(&m);
     cond.If(m.Parameter(0));
   }
   m.Return(m.Int32Constant(constant));
 
   CHECK_EQ(constant, m.Call(0));
   CHECK_EQ(constant, m.Call(1));
 }
 
 
 TEST(RunSimpleConjunctionVariable) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   int32_t constant = 0xf8fb9ec6;
   Variable var = m.NewVariable(m.Int32Constant(constant));
   {
     IfBuilder cond(&m);
     cond.If(m.Int32Constant(1)).And();
     var.Set(m.Word32Not(var.Get()));
     cond.If(m.Parameter(0)).Then();
     var.Set(m.Word32Not(m.Word32Not(var.Get())));
     cond.Else();
     var.Set(m.Word32Not(var.Get()));
   }
   m.Return(var.Get());
 
   CHECK_EQ(constant, m.Call(0));
   CHECK_EQ(~constant, m.Call(1));
 }
 
 
 TEST(RunSimpleDisjunctionVariable) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   int32_t constant = 0x118f6ffc;
   Variable var = m.NewVariable(m.Int32Constant(constant));
   {
     IfBuilder cond(&m);
     cond.If(m.Int32Constant(0)).Or();
     var.Set(m.Word32Not(var.Get()));
     cond.If(m.Parameter(0)).Then();
     var.Set(m.Word32Not(m.Word32Not(var.Get())));
     cond.Else();
     var.Set(m.Word32Not(var.Get()));
   }
   m.Return(var.Get());
 
   CHECK_EQ(constant, m.Call(0));
   CHECK_EQ(~constant, m.Call(1));
 }
 
 
 TEST(RunIfElse) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   {
     IfBuilder cond(&m);
     bool first = true;
     FOR_INT32_INPUTS(i) {
       Node* c = m.Int32Constant(*i);
       if (first) {
         cond.If(m.Word32Equal(m.Parameter(0), c)).Then();
         m.Return(c);
         first = false;
@@ skipping 12 matching lines @@
 
 enum IfBuilderBranchType { kSkipBranch, kBranchFallsThrough, kBranchReturns };
 
 
 static IfBuilderBranchType all_branch_types[] = {
     kSkipBranch, kBranchFallsThrough, kBranchReturns};
 
 
 static void RunIfBuilderDisjunction(size_t max, IfBuilderBranchType then_type,
                                     IfBuilderBranchType else_type) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   std::vector<int32_t> inputs = ValueHelper::int32_vector();
   std::vector<int32_t>::const_iterator i = inputs.begin();
   int32_t hit = 0x8c723c9a;
   int32_t miss = 0x88a6b9f3;
   {
     Node* p0 = m.Parameter(0);
     IfBuilder cond(&m);
     for (size_t j = 0; j < max; j++, ++i) {
       CHECK(i != inputs.end());  // Thank you STL.
@@ skipping 46 matching lines @@
         RunIfBuilderDisjunction(size, all_branch_types[i], all_branch_types[j]);
       }
       RunIfBuilderDisjunction(len, all_branch_types[i], all_branch_types[j]);
     }
   }
 }
 
 
 static void RunIfBuilderConjunction(size_t max, IfBuilderBranchType then_type,
                                     IfBuilderBranchType else_type) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   std::vector<int32_t> inputs = ValueHelper::int32_vector();
   std::vector<int32_t>::const_iterator i = inputs.begin();
   int32_t hit = 0xa0ceb9ca;
   int32_t miss = 0x226cafaa;
   {
     IfBuilder cond(&m);
     Node* p0 = m.Parameter(0);
     for (size_t j = 0; j < max; j++, ++i) {
       if (j > 0) cond.And();
@@ skipping 45 matching lines @@
         RunIfBuilderConjunction(size, all_branch_types[i], all_branch_types[j]);
       }
       RunIfBuilderConjunction(len, all_branch_types[i], all_branch_types[j]);
     }
   }
 }
 
 
 static void RunDisjunctionVariables(int disjunctions, bool explicit_then,
                                     bool explicit_else) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   int32_t constant = 0x65a09535;
 
   Node* cmp_val = m.Int32Constant(constant);
   Node* one = m.Int32Constant(1);
   Variable var = m.NewVariable(m.Parameter(0));
   {
     IfBuilder cond(&m);
     cond.If(m.Word32Equal(var.Get(), cmp_val));
     for (int i = 0; i < disjunctions; i++) {
@@ skipping 33 matching lines @@
     RunDisjunctionVariables(disjunctions, false, false);
     RunDisjunctionVariables(disjunctions, false, true);
     RunDisjunctionVariables(disjunctions, true, false);
     RunDisjunctionVariables(disjunctions, true, true);
   }
 }
 
 
 static void RunConjunctionVariables(int conjunctions, bool explicit_then,
                                     bool explicit_else) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   int32_t constant = 0x2c7f4b45;
   Node* cmp_val = m.Int32Constant(constant);
   Node* one = m.Int32Constant(1);
   Variable var = m.NewVariable(m.Parameter(0));
   {
     IfBuilder cond(&m);
     cond.If(m.Word32NotEqual(var.Get(), cmp_val));
     for (int i = 0; i < conjunctions; i++) {
       cond.And();
@@ skipping 31 matching lines @@
   for (int conjunctions = 0; conjunctions < 10; conjunctions++) {
     RunConjunctionVariables(conjunctions, false, false);
     RunConjunctionVariables(conjunctions, false, true);
     RunConjunctionVariables(conjunctions, true, false);
     RunConjunctionVariables(conjunctions, true, true);
   }
 }
 
 
 TEST(RunSimpleNestedIf) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32, mInt32);
   const size_t NUM_VALUES = 7;
   std::vector<int32_t> inputs = ValueHelper::int32_vector();
   CHECK(inputs.size() >= NUM_VALUES);
   Node* values[NUM_VALUES];
   for (size_t j = 0; j < NUM_VALUES; j++) {
     values[j] = m.Int32Constant(inputs[j]);
   }
   {
     IfBuilder if_0(&m);
     if_0.If(m.Word32Equal(m.Parameter(0), values[0])).Then();
@@ skipping 114 matching lines @@
     i.Set(m.Int32Add(i.Get(), one));
     var.Set(m.Int32Add(var.Get(), i.Get()));
   }
   m.Return(var.Get());
 
   CHECK_EQ(constant + 10 + 9 * 5, m.Call());
 }
 
 
 TEST(RunSimpleNestedLoop) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   Node* zero = m.Int32Constant(0);
   Node* one = m.Int32Constant(1);
   Node* two = m.Int32Constant(2);
   Node* three = m.Int32Constant(3);
   {
     Loop l1(&m);
     {
       Loop l2(&m);
       {
@@ skipping 20 matching lines @@
   m.Return(zero);
 
   CHECK_EQ(0, m.Call(1));
   CHECK_EQ(1, m.Call(2));
   CHECK_EQ(2, m.Call(3));
   CHECK_EQ(3, m.Call(4));
 }
 
 
 TEST(RunFib) {
-  StructuredMachineAssemblerTester<int32_t> m(kMachineWord32);
+  StructuredMachineAssemblerTester<int32_t> m(mInt32);
 
   // Constants.
   Node* zero = m.Int32Constant(0);
   Node* one = m.Int32Constant(1);
   Node* two = m.Int32Constant(2);
   // Variables.
   // cnt = input
   Variable cnt = m.NewVariable(m.Parameter(0));
   // if (cnt < 2) return i
   {
@@ skipping 218 matching lines @@
   m.Return(var.Get());
 
   CHECK_EQ(constant + 4, m.Call());
 }
 
 
 class QuicksortHelper : public StructuredMachineAssemblerTester<int32_t> {
  public:
   QuicksortHelper()
       : StructuredMachineAssemblerTester<int32_t>(
-            MachineOperatorBuilder::pointer_rep(), kMachineWord32,
-            MachineOperatorBuilder::pointer_rep(), kMachineWord32),
+            MachineOperatorBuilder::pointer_rep(), mInt32,
+            MachineOperatorBuilder::pointer_rep(), mInt32),
         input_(NULL),
         stack_limit_(NULL),
         one_(Int32Constant(1)),
         stack_frame_size_(Int32Constant(kFrameVariables * 4)),
         left_offset_(Int32Constant(0 * 4)),
         right_offset_(Int32Constant(1 * 4)) {
     Build();
   }
 
   int32_t DoCall(int32_t* input, int32_t input_length) {
     int32_t stack_space[20];
     // Do call.
     int32_t return_val = Call(input, input_length, stack_space,
                               static_cast<int32_t>(ARRAY_SIZE(stack_space)));
     // Ran out of stack space.
     if (return_val != 0) return return_val;
     // Check sorted.
     int32_t last = input[0];
     for (int32_t i = 0; i < input_length; i++) {
       CHECK(last <= input[i]);
       last = input[i];
     }
     return return_val;
   }
 
  private:
   void Inc32(const Variable& var) { var.Set(Int32Add(var.Get(), one_)); }
   Node* Index(Node* index) { return Word32Shl(index, Int32Constant(2)); }
-  Node* ArrayLoad(Node* index) {
-    return Load(kMachineWord32, input_, Index(index));
-  }
+  Node* ArrayLoad(Node* index) { return Load(mInt32, input_, Index(index)); }
   void Swap(Node* a_index, Node* b_index) {
     Node* a = ArrayLoad(a_index);
     Node* b = ArrayLoad(b_index);
-    Store(kMachineWord32, input_, Index(a_index), b);
-    Store(kMachineWord32, input_, Index(b_index), a);
+    Store(mInt32, input_, Index(a_index), b);
+    Store(mInt32, input_, Index(b_index), a);
   }
   void AddToCallStack(const Variable& fp, Node* left, Node* right) {
     {
       // Stack limit check.
       IfBuilder cond(this);
       cond.If(IntPtrLessThanOrEqual(fp.Get(), stack_limit_)).Then();
       Return(Int32Constant(-1));
     }
-    Store(kMachineWord32, fp.Get(), left_offset_, left);
-    Store(kMachineWord32, fp.Get(), right_offset_, right);
+    Store(mInt32, fp.Get(), left_offset_, left);
+    Store(mInt32, fp.Get(), right_offset_, right);
     fp.Set(IntPtrAdd(fp.Get(), ConvertInt32ToIntPtr(stack_frame_size_)));
   }
   void Build() {
     Variable left = NewVariable(Int32Constant(0));
     Variable right =
         NewVariable(Int32Sub(Parameter(kInputLengthParameter), one_));
     input_ = Parameter(kInputParameter);
     Node* top_of_stack = Parameter(kStackParameter);
     stack_limit_ = IntPtrSub(
         top_of_stack, ConvertInt32ToIntPtr(Parameter(kStackLengthParameter)));
@@ skipping 13 matching lines @@
         // Algorithm complete condition.
         cond.If(WordEqual(top_of_stack, fp.Get())).And();
         cond.If(Int32LessThanOrEqual(Int32Sub(right.Get(), one_), left.Get()))
             .Then();
         outermost.Break();
         // 'Recursion' exit condition. Pop frame and continue.
         cond.Else();
         cond.If(Int32LessThanOrEqual(Int32Sub(right.Get(), one_), left.Get()))
             .Then();
         fp.Set(IntPtrSub(fp.Get(), ConvertInt32ToIntPtr(stack_frame_size_)));
-        left.Set(Load(kMachineWord32, fp.Get(), left_offset_));
-        right.Set(Load(kMachineWord32, fp.Get(), right_offset_));
+        left.Set(Load(mInt32, fp.Get(), left_offset_));
+        right.Set(Load(mInt32, fp.Get(), right_offset_));
         outermost.Continue();
       }
       // Partition.
       Variable store_index = NewVariable(left.Get());
       {
         Node* pivot_index =
             Int32Div(Int32Add(left.Get(), right.Get()), Int32Constant(2));
         Node* pivot = ArrayLoad(pivot_index);
         Swap(pivot_index, right.Get());
         Variable i = NewVariable(left.Get());
@@ skipping 71 matching lines @@
   for (int i = 0; i < 10; i++) {
     IfBuilder b(&m);
     b.If(m.Int32Constant(0)).Then();
     m.NewVariable(m.Int32Constant(0));
   }
   m.Return(m.Int32Constant(0));
   CHECK_EQ(0, m.Call());
 }
 
 #endif