Unify MachineType and RepType.

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 "test/cctest/cctest.h"
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/value-helper.h"
 
 #if V8_TURBOFAN_TARGET
 
+#define CHECK_UINT32_EQ(x, y) \

[Michael Starzinger, 2014/08/13 15:40:05]

*sigh*

[Benedikt Meurer, 2014/08/13 19:42:07]

CheckEqualsHelper for unsigned.

[titzer, 2014/08/14 07:50:18]

I tried that. C++ doesn't like ambiguous overloads, but it can't resolve an
overload for unsigned integers. O_o

+  CHECK_EQ(static_cast<int32_t>(x), static_cast<int32_t>(y))
+
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
 typedef RawMachineAssembler::Label MLabel;
 
 TEST(RunInt32Add) {
   RawMachineAssemblerTester<int32_t> m;
   Node* add = m.Int32Add(m.Int32Constant(0), m.Int32Constant(1));
   m.Return(add);
   CHECK_EQ(1, m.Call());
@@ skipping 10 matching lines @@
       return m->Int32Constant(0);
     case 3:
       return m->Int32Constant(1);
     case 4:
       return m->Int32Constant(-1);
     case 5:
       return m->Int32Constant(0xff);
     case 6:
       return m->Int32Constant(0x01234567);
     case 7:
-      return m->Load(kMachineWord32, m->PointerConstant(NULL));
+      return m->Load(mInt32, m->PointerConstant(NULL));
     default:
       return NULL;
   }
 }
 
 
 TEST(CodeGenInt32Binop) {
   RawMachineAssemblerTester<void> m;
 
   Operator* ops[] = {
       m.machine()->Word32And(),      m.machine()->Word32Or(),
       m.machine()->Word32Xor(),      m.machine()->Word32Shl(),
       m.machine()->Word32Shr(),      m.machine()->Word32Sar(),
       m.machine()->Word32Equal(),    m.machine()->Int32Add(),
       m.machine()->Int32Sub(),       m.machine()->Int32Mul(),
       m.machine()->Int32Div(),       m.machine()->Int32UDiv(),
       m.machine()->Int32Mod(),       m.machine()->Int32UMod(),
       m.machine()->Int32LessThan(),  m.machine()->Int32LessThanOrEqual(),
       m.machine()->Uint32LessThan(), m.machine()->Uint32LessThanOrEqual(),
       NULL};
 
   for (int i = 0; ops[i] != NULL; i++) {
     for (int j = 0; j < 8; j++) {
       for (int k = 0; k < 8; k++) {
-        RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32);
+        RawMachineAssemblerTester<int32_t> m(mInt32, mInt32);
         Node* a = Int32Input(&m, j);
         Node* b = Int32Input(&m, k);
         m.Return(m.NewNode(ops[i], a, b));
         m.GenerateCode();
       }
     }
   }
 }
 
 
@@ skipping 131 matching lines @@
   m->Bind(&blockb);
   m->Goto(end);
 
   m->Bind(end);
   Node* phi = m->Phi(true_node, false_node);
   m->Return(phi);
 }
 
 
 TEST(RunDiamondPhiConst) {
-  RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+  RawMachineAssemblerTester<int32_t> m(mInt32);
   int false_val = 0xFF666;
   int true_val = 0x00DDD;
   Node* true_node = m.Int32Constant(true_val);
   Node* false_node = m.Int32Constant(false_val);
   BuildDiamondPhi(&m, m.Parameter(0), true_node, false_node);
   CHECK_EQ(false_val, m.Call(0));
   CHECK_EQ(true_val, m.Call(1));
 }
 
 
 TEST(RunDiamondPhiNumber) {
-  RawMachineAssemblerTester<Object*> m(kMachineWord32);
+  RawMachineAssemblerTester<Object*> m(mInt32);
   double false_val = -11.1;
   double true_val = 200.1;
   Node* true_node = m.NumberConstant(true_val);
   Node* false_node = m.NumberConstant(false_val);
   BuildDiamondPhi(&m, m.Parameter(0), true_node, false_node);
   m.CheckNumber(false_val, m.Call(0));
   m.CheckNumber(true_val, m.Call(1));
 }
 
 
 TEST(RunDiamondPhiString) {
-  RawMachineAssemblerTester<Object*> m(kMachineWord32);
+  RawMachineAssemblerTester<Object*> m(mInt32);
   const char* false_val = "false";
   const char* true_val = "true";
   Node* true_node = m.StringConstant(true_val);
   Node* false_node = m.StringConstant(false_val);
   BuildDiamondPhi(&m, m.Parameter(0), true_node, false_node);
   m.CheckString(false_val, m.Call(0));
   m.CheckString(true_val, m.Call(1));
 }
 
 
 TEST(RunDiamondPhiParam) {
-  RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                       kMachineWord32);
+  RawMachineAssemblerTester<int32_t> m(mInt32, mInt32, mInt32);
   BuildDiamondPhi(&m, m.Parameter(0), m.Parameter(1), m.Parameter(2));
   int32_t c1 = 0x260cb75a;
   int32_t c2 = 0xcd3e9c8b;
   int result = m.Call(0, c1, c2);
   CHECK_EQ(c2, result);
   result = m.Call(1, c1, c2);
   CHECK_EQ(c1, result);
 }
 
 
@@ skipping 17 matching lines @@
   m.Bind(&body);
   m.Goto(&header);
   m.Bind(end);
   m.Return(phi);
 
   CHECK_EQ(false_val, m.Call());
 }
 
 
 TEST(RunLoopPhiParam) {
-  RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                       kMachineWord32);
+  RawMachineAssemblerTester<int32_t> m(mInt32, mInt32, mInt32);
 
   MLabel blocka, blockb;
   MLabel* end = m.Exit();
 
   m.Goto(&blocka);
 
   m.Bind(&blocka);
   Node* phi = m.Phi(m.Parameter(1), m.Parameter(2));
   Node* cond = m.Phi(m.Parameter(0), m.Int32Constant(0));
   m.Branch(cond, &blockb, end);
@@ skipping 177 matching lines @@
   m.Return(m.ChangeFloat64ToInt32(phi));
 
   CHECK_EQ(10, m.Call());
 }
 
 
 TEST(RunLoadInt32) {
   RawMachineAssemblerTester<int32_t> m;
 
   int32_t p1 = 0;  // loads directly from this location.
-  m.Return(m.LoadFromPointer(&p1, kMachineWord32));
+  m.Return(m.LoadFromPointer(&p1, mInt32));
 
   FOR_INT32_INPUTS(i) {
     p1 = *i;
     CHECK_EQ(p1, m.Call());
   }
 }
 
 
 TEST(RunLoadInt32Offset) {
   int32_t p1 = 0;  // loads directly from this location.
 
   int32_t offsets[] = {-2000000, -100, -101, 1,          3,
                        7,        120,  2000, 2000000000, 0xff};
 
   for (size_t i = 0; i < ARRAY_SIZE(offsets); i++) {
     RawMachineAssemblerTester<int32_t> m;
     int32_t offset = offsets[i];
     byte* pointer = reinterpret_cast<byte*>(&p1) - offset;
     // generate load [#base + #index]
-    m.Return(m.LoadFromPointer(pointer, kMachineWord32, offset));
+    m.Return(m.LoadFromPointer(pointer, mInt32, offset));
 
     FOR_INT32_INPUTS(j) {
       p1 = *j;
       CHECK_EQ(p1, m.Call());
     }
   }
 }
 
 
 TEST(RunLoadStoreFloat64Offset) {
   double p1 = 0;  // loads directly from this location.
   double p2 = 0;  // and stores directly into this location.
 
   FOR_INT32_INPUTS(i) {
     int32_t magic = 0x2342aabb + *i * 3;
     RawMachineAssemblerTester<int32_t> m;
     int32_t offset = *i;
     byte* from = reinterpret_cast<byte*>(&p1) - offset;
     byte* to = reinterpret_cast<byte*>(&p2) - offset;
     // generate load [#base + #index]
-    Node* load = m.Load(kMachineFloat64, m.PointerConstant(from),
-                        m.Int32Constant(offset));
-    m.Store(kMachineFloat64, m.PointerConstant(to), m.Int32Constant(offset),
-            load);
+    Node* load =
+        m.Load(mFloat64, m.PointerConstant(from), m.Int32Constant(offset));
+    m.Store(mFloat64, m.PointerConstant(to), m.Int32Constant(offset), load);
     m.Return(m.Int32Constant(magic));
 
     FOR_FLOAT64_INPUTS(j) {
       p1 = *j;
       p2 = *j - 5;
       CHECK_EQ(magic, m.Call());
       CHECK_EQ(p1, p2);
     }
   }
 }
@@ skipping 10 matching lines @@
       // Use uint32_t because signed overflow is UB in C.
       int expected = static_cast<int32_t>(*i + *j);
       CHECK_EQ(expected, bt.call(*i, *j));
     }
   }
 }
 
 
 TEST(RunInt32AddAndWord32SarP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mUint32, mInt32, mUint32);
     m.Return(m.Int32Add(m.Parameter(0),
                         m.Word32Sar(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         FOR_UINT32_SHIFTS(shift) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = *i + (*j >> shift);
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mInt32, mUint32, mUint32);
     m.Return(m.Int32Add(m.Word32Sar(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
     FOR_INT32_INPUTS(i) {
       FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = (*i >> shift) + *k;
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32AddAndWord32ShlP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mUint32, mInt32, mUint32);
     m.Return(m.Int32Add(m.Parameter(0),
                         m.Word32Shl(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         FOR_UINT32_SHIFTS(shift) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = *i + (*j << shift);
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mInt32, mUint32, mUint32);
     m.Return(m.Int32Add(m.Word32Shl(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
     FOR_INT32_INPUTS(i) {
       FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = (*i << shift) + *k;
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32AddAndWord32ShrP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mUint32, mUint32, mUint32);
     m.Return(m.Int32Add(m.Parameter(0),
                         m.Word32Shr(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         FOR_UINT32_SHIFTS(shift) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = *i + (*j >> shift);
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mUint32, mUint32, mUint32);
     m.Return(m.Int32Add(m.Word32Shr(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = (*i >> shift) + *k;
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32AddInBranch) {
   static const int32_t constant = 987654321;
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     MLabel blocka, blockb;
     m.Branch(
         m.Word32Equal(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i + *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     MLabel blocka, blockb;
     m.Branch(
         m.Word32NotEqual(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i + *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       MLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i + *j) == 0 ? constant : 0 - constant;
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = (*i + *j) == 0 ? constant : 0 - constant;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       MLabel blocka, blockb;
       m.Branch(m.Word32NotEqual(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)),
                                 m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i + *j) != 0 ? constant : 0 - constant;
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = (*i + *j) != 0 ? constant : 0 - constant;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     Operator* shops[] = {m.machine()->Word32Sar(), m.machine()->Word32Shl(),
                          m.machine()->Word32Shr()};
     for (size_t n = 0; n < ARRAY_SIZE(shops); n++) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                           kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mUint32, mInt32, mUint32);
       MLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Int32Add(m.Parameter(0),
                                         m.NewNode(shops[n], m.Parameter(1),
                                                   m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
@@ skipping 20 matching lines @@
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32AddInComparison) {
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(
         m.Word32Equal(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i + *j) == 0;
-        CHECK_EQ(expected, bt.call(*i, *j));
+        uint32_t expected = (*i + *j) == 0;
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(
         m.Word32Equal(m.Int32Constant(0), m.Int32Add(bt.param0, bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i + *j) == 0;
-        CHECK_EQ(expected, bt.call(*i, *j));
+        uint32_t expected = (*i + *j) == 0;
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32Equal(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i + *j) == 0;
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = (*i + *j) == 0;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32Equal(m.Int32Add(m.Parameter(0), m.Int32Constant(*i)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*j + *i) == 0;
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = (*j + *i) == 0;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     Operator* shops[] = {m.machine()->Word32Sar(), m.machine()->Word32Shl(),
                          m.machine()->Word32Shr()};
     for (size_t n = 0; n < ARRAY_SIZE(shops); n++) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                           kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mUint32, mInt32, mUint32);
       m.Return(m.Word32Equal(
           m.Int32Add(m.Parameter(0),
                      m.NewNode(shops[n], m.Parameter(1), m.Parameter(2))),
           m.Int32Constant(0)));
       FOR_UINT32_INPUTS(i) {
         FOR_INT32_INPUTS(j) {
           FOR_UINT32_SHIFTS(shift) {
             int32_t right;
             switch (shops[n]->opcode()) {
               default:
@@ skipping 13 matching lines @@
           }
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32SubP) {
   RawMachineAssemblerTester<int32_t> m;
-  Int32BinopTester bt(&m);
+  Uint32BinopTester bt(&m);
 
   m.Return(m.Int32Sub(bt.param0, bt.param1));
 
   FOR_UINT32_INPUTS(i) {
     FOR_UINT32_INPUTS(j) {
-      // Use uint32_t because signed overflow is UB in C.
-      int expected = static_cast<int32_t>(*i - *j);
-      CHECK_EQ(expected, bt.call(*i, *j));
+      uint32_t expected = static_cast<int32_t>(*i - *j);
+      CHECK_UINT32_EQ(expected, bt.call(*i, *j));
     }
   }
 }
 
 
 TEST(RunInt32SubImm) {
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)));
       FOR_UINT32_INPUTS(j) {
-        // Use uint32_t because signed overflow is UB in C.
-        int32_t expected = static_cast<int32_t>(*i - *j);
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = *i - *j;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Int32Sub(m.Parameter(0), m.Int32Constant(*i)));
       FOR_UINT32_INPUTS(j) {
-        // Use uint32_t because signed overflow is UB in C.
-        int32_t expected = static_cast<int32_t>(*j - *i);
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = *j - *i;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
 }
 
 
 TEST(RunInt32SubAndWord32SarP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mUint32, mInt32, mUint32);
     m.Return(m.Int32Sub(m.Parameter(0),
                         m.Word32Sar(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         FOR_UINT32_SHIFTS(shift) {
-          // Use uint32_t because signed overflow is UB in C.
           int32_t expected = *i - (*j >> shift);
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mInt32, mUint32, mUint32);
     m.Return(m.Int32Sub(m.Word32Sar(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
     FOR_INT32_INPUTS(i) {
       FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
-          // Use uint32_t because signed overflow is UB in C.
           int32_t expected = (*i >> shift) - *k;
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32SubAndWord32ShlP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mUint32, mInt32, mUint32);
     m.Return(m.Int32Sub(m.Parameter(0),
                         m.Word32Shl(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         FOR_UINT32_SHIFTS(shift) {
-          // Use uint32_t because signed overflow is UB in C.
           int32_t expected = *i - (*j << shift);
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mInt32, mUint32, mUint32);
     m.Return(m.Int32Sub(m.Word32Shl(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
     FOR_INT32_INPUTS(i) {
       FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = (*i << shift) - *k;
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32SubAndWord32ShrP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<uint32_t> m(mUint32, mUint32, mUint32);
     m.Return(m.Int32Sub(m.Parameter(0),
                         m.Word32Shr(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         FOR_UINT32_SHIFTS(shift) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = *i - (*j >> shift);
-          CHECK_EQ(expected, m.Call(*i, *j, shift));
+          CHECK_UINT32_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<uint32_t> m(mUint32, mUint32, mUint32);
     m.Return(m.Int32Sub(m.Word32Shr(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = (*i >> shift) - *k;
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32SubInBranch) {
   static const int constant = 987654321;
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     MLabel blocka, blockb;
     m.Branch(
         m.Word32Equal(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i - *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     MLabel blocka, blockb;
     m.Branch(
         m.Word32NotEqual(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i - *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       MLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i - *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mUint32);
       MLabel blocka, blockb;
       m.Branch(m.Word32NotEqual(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)),
                                 m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i - *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     Operator* shops[] = {m.machine()->Word32Sar(), m.machine()->Word32Shl(),
                          m.machine()->Word32Shr()};
     for (size_t n = 0; n < ARRAY_SIZE(shops); n++) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                           kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mUint32, mInt32, mUint32);
       MLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Int32Sub(m.Parameter(0),
                                         m.NewNode(shops[n], m.Parameter(1),
                                                   m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
@@ skipping 20 matching lines @@
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32SubInComparison) {
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(
         m.Word32Equal(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i - *j) == 0;
-        CHECK_EQ(expected, bt.call(*i, *j));
+        uint32_t expected = (*i - *j) == 0;
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(
         m.Word32Equal(m.Int32Constant(0), m.Int32Sub(bt.param0, bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i - *j) == 0;
-        CHECK_EQ(expected, bt.call(*i, *j));
+        uint32_t expected = (*i - *j) == 0;
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32Equal(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i - *j) == 0;
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = (*i - *j) == 0;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32Equal(m.Int32Sub(m.Parameter(0), m.Int32Constant(*i)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*j - *i) == 0;
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = (*j - *i) == 0;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     Operator* shops[] = {m.machine()->Word32Sar(), m.machine()->Word32Shl(),
                          m.machine()->Word32Shr()};
     for (size_t n = 0; n < ARRAY_SIZE(shops); n++) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                           kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mUint32, mInt32, mUint32);
       m.Return(m.Word32Equal(
           m.Int32Sub(m.Parameter(0),
                      m.NewNode(shops[n], m.Parameter(1), m.Parameter(2))),
           m.Int32Constant(0)));
       FOR_UINT32_INPUTS(i) {
         FOR_INT32_INPUTS(j) {
           FOR_UINT32_SHIFTS(shift) {
             int32_t right;
             switch (shops[n]->opcode()) {
               default:
@@ skipping 25 matching lines @@
     bt.AddReturn(m.Int32Mul(bt.param0, bt.param1));
     FOR_INT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         int expected = static_cast<int32_t>(*i * *j);
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(m.Int32Mul(bt.param0, bt.param1));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
-        int expected = static_cast<int32_t>(*i * *j);
-        CHECK_EQ(expected, bt.call(*i, *j));
+        uint32_t expected = *i * *j;
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
 }
 
 
 TEST(RunInt32MulImm) {
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Int32Mul(m.Int32Constant(*i), m.Parameter(0)));
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = static_cast<int32_t>(*i * *j);
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = *i * *j;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Int32Mul(m.Parameter(0), m.Int32Constant(*i)));
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = static_cast<int32_t>(*j * *i);
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = *j * *i;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
 }
 
 
 TEST(RunInt32MulAndInt32AddP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mInt32, mInt32, mInt32);
     m.Return(
         m.Int32Add(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
     FOR_INT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         FOR_INT32_INPUTS(k) {
           int32_t p0 = *i;
           int32_t p1 = *j;
           int32_t p2 = *k;
           int expected = p0 + static_cast<int32_t>(p1 * p2);
           CHECK_EQ(expected, m.Call(p0, p1, p2));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mInt32, mInt32, mInt32);
     m.Return(
         m.Int32Add(m.Int32Mul(m.Parameter(0), m.Parameter(1)), m.Parameter(2)));
     FOR_INT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         FOR_INT32_INPUTS(k) {
           int32_t p0 = *i;
           int32_t p1 = *j;
           int32_t p2 = *k;
           int expected = static_cast<int32_t>(p0 * p1) + p2;
           CHECK_EQ(expected, m.Call(p0, p1, p2));
@@ skipping 15 matching lines @@
           CHECK_EQ(expected, bt.call(p0, p1));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32MulAndInt32SubP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mUint32, mInt32, mInt32);
     m.Return(
         m.Int32Sub(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         FOR_INT32_INPUTS(k) {
           uint32_t p0 = *i;
           int32_t p1 = *j;
           int32_t p2 = *k;
           // Use uint32_t because signed overflow is UB in C.
           int expected = p0 - static_cast<uint32_t>(p1 * p2);
@@ skipping 191 matching lines @@
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
 }
 
 
 TEST(RunWord32AndAndWord32ShlP) {
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(
         m.Word32Shl(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f))));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *i << (*j & 0x1f);
-        CHECK_EQ(expected, bt.call(*i, *j));
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(
         m.Word32Shl(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *i << (0x1f & *j);
-        CHECK_EQ(expected, bt.call(*i, *j));
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
 }
 
 
 TEST(RunWord32AndAndWord32ShrP) {
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(
         m.Word32Shr(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f))));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *i >> (*j & 0x1f);
-        CHECK_EQ(expected, bt.call(*i, *j));
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(
         m.Word32Shr(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *i >> (0x1f & *j);
-        CHECK_EQ(expected, bt.call(*i, *j));
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
 }
 
 
 TEST(RunWord32AndAndWord32SarP) {
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
     bt.AddReturn(
         m.Word32Sar(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f))));
     FOR_INT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
-        uint32_t expected = *i >> (*j & 0x1f);
+      FOR_INT32_INPUTS(j) {
+        int32_t expected = *i >> (*j & 0x1f);
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
     bt.AddReturn(
         m.Word32Sar(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1)));
     FOR_INT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
+      FOR_INT32_INPUTS(j) {
         uint32_t expected = *i >> (0x1f & *j);
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
 }
 
 
 TEST(RunWord32AndImm) {
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32And(m.Int32Constant(*i), m.Parameter(0)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *i & *j;
-        CHECK_EQ(expected, m.Call(*j));
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32And(m.Int32Constant(*i), m.Word32Not(m.Parameter(0))));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *i & ~(*j);
-        CHECK_EQ(expected, m.Call(*j));
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
 }
 
 
 TEST(RunWord32AndInBranch) {
   static const int constant = 987654321;
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     MLabel blocka, blockb;
     m.Branch(
         m.Word32Equal(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i & *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     MLabel blocka, blockb;
     m.Branch(
         m.Word32NotEqual(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i & *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mUint32);
       MLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32And(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i & *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mUint32);
       MLabel blocka, blockb;
       m.Branch(
           m.Word32NotEqual(m.Word32And(m.Int32Constant(*i), m.Parameter(0)),
                            m.Int32Constant(0)),
           &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i & *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     Operator* shops[] = {m.machine()->Word32Sar(), m.machine()->Word32Shl(),
                          m.machine()->Word32Shr()};
     for (size_t n = 0; n < ARRAY_SIZE(shops); n++) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                           kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mUint32, mInt32, mUint32);
       MLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32And(m.Parameter(0),
                                          m.NewNode(shops[n], m.Parameter(1),
                                                    m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
@@ skipping 20 matching lines @@
         }
       }
     }
   }
 }
 
 
 TEST(RunWord32AndInComparison) {
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(
         m.Word32Equal(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i & *j) == 0;
-        CHECK_EQ(expected, bt.call(*i, *j));
+        uint32_t expected = (*i & *j) == 0;
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(
         m.Word32Equal(m.Int32Constant(0), m.Word32And(bt.param0, bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i & *j) == 0;
-        CHECK_EQ(expected, bt.call(*i, *j));
+        uint32_t expected = (*i & *j) == 0;
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32Equal(m.Word32And(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i & *j) == 0;
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = (*i & *j) == 0;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32Equal(m.Word32And(m.Parameter(0), m.Int32Constant(*i)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*j & *i) == 0;
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = (*j & *i) == 0;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
 }
 
 
 TEST(RunWord32OrP) {
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(m.Word32Or(bt.param0, bt.param1));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *i | *j;
-        CHECK_EQ(expected, bt.call(*i, *j));
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(m.Word32Or(bt.param0, m.Word32Not(bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *i | ~(*j);
-        CHECK_EQ(expected, bt.call(*i, *j));
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(m.Word32Or(m.Word32Not(bt.param0), bt.param1));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = ~(*i) | *j;
-        CHECK_EQ(expected, bt.call(*i, *j));
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
 }
 
 
 TEST(RunWord32OrImm) {
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *i | *j;
-        CHECK_EQ(expected, m.Call(*j));
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32Or(m.Int32Constant(*i), m.Word32Not(m.Parameter(0))));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *i | ~(*j);
-        CHECK_EQ(expected, m.Call(*j));
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
 }
 
 
 TEST(RunWord32OrInBranch) {
   static const int constant = 987654321;
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
     MLabel blocka, blockb;
     m.Branch(
         m.Word32Equal(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
-    FOR_UINT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
+    FOR_INT32_INPUTS(i) {
+      FOR_INT32_INPUTS(j) {
         int32_t expected = (*i | *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
     MLabel blocka, blockb;
     m.Branch(
         m.Word32NotEqual(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
-    FOR_UINT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
+    FOR_INT32_INPUTS(i) {
+      FOR_INT32_INPUTS(j) {
         int32_t expected = (*i | *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
-    FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+    FOR_INT32_INPUTS(i) {
+      RawMachineAssemblerTester<int32_t> m(mInt32);
       MLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
-      FOR_UINT32_INPUTS(j) {
+      FOR_INT32_INPUTS(j) {
         int32_t expected = (*i | *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
-    FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+    FOR_INT32_INPUTS(i) {
+      RawMachineAssemblerTester<int32_t> m(mInt32);
       MLabel blocka, blockb;
       m.Branch(m.Word32NotEqual(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)),
                                 m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
-      FOR_UINT32_INPUTS(j) {
+      FOR_INT32_INPUTS(j) {
         int32_t expected = (*i | *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     Operator* shops[] = {m.machine()->Word32Sar(), m.machine()->Word32Shl(),
                          m.machine()->Word32Shr()};
     for (size_t n = 0; n < ARRAY_SIZE(shops); n++) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                           kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mUint32, mInt32, mUint32);
       MLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32Or(m.Parameter(0),
                                         m.NewNode(shops[n], m.Parameter(1),
                                                   m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
@@ skipping 20 matching lines @@
         }
       }
     }
   }
 }
 
 
 TEST(RunWord32OrInComparison) {
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(
         m.Word32Equal(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i | *j) == 0;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(
         m.Word32Equal(m.Int32Constant(0), m.Word32Or(bt.param0, bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i | *j) == 0;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32Equal(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i | *j) == 0;
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = (*i | *j) == 0;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32Equal(m.Word32Or(m.Parameter(0), m.Int32Constant(*i)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*j | *i) == 0;
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = (*j | *i) == 0;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
 }
 
 
 TEST(RunWord32XorP) {
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mUint32);
       m.Return(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *i ^ *j;
-        CHECK_EQ(expected, m.Call(*j));
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(m.Word32Xor(bt.param0, bt.param1));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
-        uint32_t expected = *i ^ *j;
-        CHECK_EQ(expected, bt.call(*i, *j));
+        int32_t expected = *i ^ *j;
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
     bt.AddReturn(m.Word32Xor(bt.param0, m.Word32Not(bt.param1)));
-    FOR_UINT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
-        uint32_t expected = *i ^ ~(*j);
+    FOR_INT32_INPUTS(i) {
+      FOR_INT32_INPUTS(j) {
+        int32_t expected = *i ^ ~(*j);
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
     bt.AddReturn(m.Word32Xor(m.Word32Not(bt.param0), bt.param1));
-    FOR_UINT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
-        uint32_t expected = ~(*i) ^ *j;
+    FOR_INT32_INPUTS(i) {
+      FOR_INT32_INPUTS(j) {
+        int32_t expected = ~(*i) ^ *j;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32Xor(m.Int32Constant(*i), m.Word32Not(m.Parameter(0))));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *i ^ ~(*j);
-        CHECK_EQ(expected, m.Call(*j));
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
 }
 
 
 TEST(RunWord32XorInBranch) {
-  static const int constant = 987654321;
+  static const uint32_t constant = 987654321;
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     MLabel blocka, blockb;
     m.Branch(
         m.Word32Equal(m.Word32Xor(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant;
-        CHECK_EQ(expected, bt.call(*i, *j));
+        uint32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant;
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     MLabel blocka, blockb;
     m.Branch(
         m.Word32NotEqual(m.Word32Xor(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant;
-        CHECK_EQ(expected, bt.call(*i, *j));
+        uint32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant;
+        CHECK_UINT32_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       MLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant;
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       MLabel blocka, blockb;
       m.Branch(
           m.Word32NotEqual(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0)),
                            m.Int32Constant(0)),
           &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
-        int32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant;
-        CHECK_EQ(expected, m.Call(*j));
+        uint32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant;
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     Operator* shops[] = {m.machine()->Word32Sar(), m.machine()->Word32Shl(),
                          m.machine()->Word32Shr()};
     for (size_t n = 0; n < ARRAY_SIZE(shops); n++) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                           kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mUint32, mInt32, mUint32);
       MLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32Xor(m.Parameter(0),
                                          m.NewNode(shops[n], m.Parameter(1),
                                                    m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
@@ skipping 20 matching lines @@
         }
       }
     }
   }
 }
 
 
 TEST(RunWord32ShlP) {
   {
     FOR_UINT32_SHIFTS(shift) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32Shl(m.Parameter(0), m.Int32Constant(shift)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *j << shift;
-        CHECK_EQ(expected, m.Call(*j));
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(m.Word32Shl(bt.param0, bt.param1));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_SHIFTS(shift) {
         uint32_t expected = *i << shift;
-        CHECK_EQ(expected, bt.call(*i, shift));
+        CHECK_UINT32_EQ(expected, bt.call(*i, shift));
       }
     }
   }
 }
 
 
 TEST(RunWord32ShrP) {
   {
     FOR_UINT32_SHIFTS(shift) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<uint32_t> m(mUint32);
       m.Return(m.Word32Shr(m.Parameter(0), m.Int32Constant(shift)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *j >> shift;
-        CHECK_EQ(expected, m.Call(*j));
+        CHECK_UINT32_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Int32BinopTester bt(&m);
+    Uint32BinopTester bt(&m);
     bt.AddReturn(m.Word32Shr(bt.param0, bt.param1));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_SHIFTS(shift) {
         uint32_t expected = *i >> shift;
-        CHECK_EQ(expected, bt.call(*i, shift));
+        CHECK_UINT32_EQ(expected, bt.call(*i, shift));
       }
     }
     CHECK_EQ(0x00010000, bt.call(0x80000000, 15));
   }
 }
 
 
 TEST(RunWord32SarP) {
   {
     FOR_INT32_SHIFTS(shift) {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mInt32);
       m.Return(m.Word32Sar(m.Parameter(0), m.Int32Constant(shift)));
       FOR_INT32_INPUTS(j) {
         int32_t expected = *j >> shift;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
     bt.AddReturn(m.Word32Sar(bt.param0, bt.param1));
     FOR_INT32_INPUTS(i) {
       FOR_INT32_SHIFTS(shift) {
         int32_t expected = *i >> shift;
         CHECK_EQ(expected, bt.call(*i, shift));
       }
     }
     CHECK_EQ(0xFFFF0000, bt.call(0x80000000, 15));
   }
 }
 
 
 TEST(RunWord32NotP) {
-  RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+  RawMachineAssemblerTester<int32_t> m(mInt32);
   m.Return(m.Word32Not(m.Parameter(0)));
-  FOR_UINT32_INPUTS(i) {
+  FOR_INT32_INPUTS(i) {
     int expected = ~(*i);
     CHECK_EQ(expected, m.Call(*i));
   }
 }
 
 
 TEST(RunInt32NegP) {
-  RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+  RawMachineAssemblerTester<int32_t> m(mInt32);
   m.Return(m.Int32Neg(m.Parameter(0)));
   FOR_INT32_INPUTS(i) {
     int expected = -*i;
     CHECK_EQ(expected, m.Call(*i));
   }
 }
 
 
 TEST(RunWord32EqualAndWord32SarP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mInt32, mInt32, mUint32);
     m.Return(m.Word32Equal(m.Parameter(0),
                            m.Word32Sar(m.Parameter(1), m.Parameter(2))));
     FOR_INT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         FOR_UINT32_SHIFTS(shift) {
           int32_t expected = (*i == (*j >> shift));
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mInt32, mUint32, mInt32);
     m.Return(m.Word32Equal(m.Word32Sar(m.Parameter(0), m.Parameter(1)),
                            m.Parameter(2)));
     FOR_INT32_INPUTS(i) {
       FOR_UINT32_SHIFTS(shift) {
         FOR_INT32_INPUTS(k) {
           int32_t expected = ((*i >> shift) == *k);
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunWord32EqualAndWord32ShlP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mUint32, mUint32, mUint32);
     m.Return(m.Word32Equal(m.Parameter(0),
                            m.Word32Shl(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         FOR_UINT32_SHIFTS(shift) {
           int32_t expected = (*i == (*j << shift));
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mUint32, mUint32, mUint32);
     m.Return(m.Word32Equal(m.Word32Shl(m.Parameter(0), m.Parameter(1)),
                            m.Parameter(2)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
           int32_t expected = ((*i << shift) == *k);
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunWord32EqualAndWord32ShrP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mUint32, mUint32, mUint32);
     m.Return(m.Word32Equal(m.Parameter(0),
                            m.Word32Shr(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         FOR_UINT32_SHIFTS(shift) {
           int32_t expected = (*i == (*j >> shift));
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
-                                         kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mUint32, mUint32, mUint32);
     m.Return(m.Word32Equal(m.Word32Shr(m.Parameter(0), m.Parameter(1)),
                            m.Parameter(2)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
           int32_t expected = ((*i >> shift) == *k);
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunDeadNodes) {
   for (int i = 0; true; i++) {
-    RawMachineAssemblerTester<int32_t> m(i == 5 ? kMachineWord32
-                                                : kMachineLast);
+    RawMachineAssemblerTester<int32_t> m(i == 5 ? mInt32 : mNone);
     int constant = 0x55 + i;
     switch (i) {
       case 0:
         m.Int32Constant(44);
         break;
       case 1:
         m.StringConstant("unused");
         break;
       case 2:
         m.NumberConstant(11.1);
         break;
       case 3:
         m.PointerConstant(&constant);
         break;
       case 4:
-        m.LoadFromPointer(&constant, kMachineWord32);
+        m.LoadFromPointer(&constant, mInt32);
         break;
       case 5:
         m.Parameter(0);
         break;
       default:
         return;
     }
     m.Return(m.Int32Constant(constant));
     if (i != 5) {
       CHECK_EQ(constant, m.Call());
@@ skipping 13 matching lines @@
       m.machine()->Word32Shr(),      m.machine()->Word32Sar(),
       m.machine()->Word32Equal(),    m.machine()->Int32Add(),
       m.machine()->Int32Sub(),       m.machine()->Int32Mul(),
       m.machine()->Int32Div(),       m.machine()->Int32UDiv(),
       m.machine()->Int32Mod(),       m.machine()->Int32UMod(),
       m.machine()->Int32LessThan(),  m.machine()->Int32LessThanOrEqual(),
       m.machine()->Uint32LessThan(), m.machine()->Uint32LessThanOrEqual(),
       NULL};
 
   for (int i = 0; ops[i] != NULL; i++) {
-    RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mInt32, mInt32);
     int constant = 0x55555 + i;
     m.NewNode(ops[i], m.Parameter(0), m.Parameter(1));
     m.Return(m.Int32Constant(constant));
 
     CHECK_EQ(constant, m.Call(1, 1));
   }
 }
 
 
 template <typename Type, typename CType>
@@ skipping 18 matching lines @@
       Type expected = buffer[i];
       Type actual = static_cast<CType>(m.Call());
       CHECK_EQ(expected, actual);
       printf("XXX\n");
     }
   }
 }
 
 
 TEST(RunLoadImmIndex) {
-  RunLoadImmIndex<int8_t, uint8_t>(kMachineWord8);
-  RunLoadImmIndex<int16_t, uint16_t>(kMachineWord16);
-  RunLoadImmIndex<int32_t, uint32_t>(kMachineWord32);
-  RunLoadImmIndex<int32_t*, int32_t*>(kMachineTagged);
+  RunLoadImmIndex<int8_t, uint8_t>(mInt8);
+  RunLoadImmIndex<int16_t, uint16_t>(mInt16);
+  RunLoadImmIndex<int32_t, uint32_t>(mInt32);
+  RunLoadImmIndex<int32_t*, int32_t*>(mAnyTagged);
 
-  // TODO(titzer): test kMachineFloat64 loads
+  // TODO(titzer): test rBit loads
+  // TODO(titzer): test mFloat64 loads
   // TODO(titzer): test various indexing modes.
 }
 
 
 template <typename CType>
 static void RunLoadStore(MachineType rep) {
   const int kNumElems = 4;
   CType buffer[kNumElems];
 
   for (int32_t x = 0; x < kNumElems; x++) {
@@ skipping 14 matching lines @@
     m.Return(m.Int32Constant(OK));
 
     CHECK_NE(buffer[x], buffer[y]);
     CHECK_EQ(OK, m.Call());
     CHECK_EQ(buffer[x], buffer[y]);
   }
 }
 
 
 TEST(RunLoadStore) {
-  RunLoadStore<int8_t>(kMachineWord8);
-  RunLoadStore<int16_t>(kMachineWord16);
-  RunLoadStore<int32_t>(kMachineWord32);
-  RunLoadStore<void*>(kMachineTagged);
-  RunLoadStore<double>(kMachineFloat64);
+  RunLoadStore<int8_t>(mInt8);
+  RunLoadStore<int16_t>(mInt16);
+  RunLoadStore<int32_t>(mInt32);
+  RunLoadStore<void*>(mAnyTagged);
+  RunLoadStore<double>(mFloat64);
 }
 
 
 TEST(RunFloat64Binop) {
   RawMachineAssemblerTester<int32_t> m;
   double result;
 
   Operator* ops[] = {m.machine()->Float64Add(), m.machine()->Float64Sub(),
                      m.machine()->Float64Mul(), m.machine()->Float64Div(),
                      m.machine()->Float64Mod(), NULL};
@@ skipping 11 matching lines @@
       NULL};
 
   for (int i = 0; ops[i] != NULL; i++) {
     for (int j = 0; inputs[j] != NULL; j += 2) {
       RawMachineAssemblerTester<int32_t> m;
       Node* a = m.NewNode(inputs[j]);
       Node* b = m.NewNode(inputs[j + 1]);
       Node* binop = m.NewNode(ops[i], a, b);
       Node* base = m.PointerConstant(&result);
       Node* zero = m.Int32Constant(0);
-      m.Store(kMachineFloat64, base, zero, binop);
+      m.Store(mFloat64, base, zero, binop);
       m.Return(m.Int32Constant(i + j));
       CHECK_EQ(i + j, m.Call());
     }
   }
 }
 
 
 TEST(RunDeadFloat64Binops) {
   RawMachineAssemblerTester<int32_t> m;
 
@@ skipping 40 matching lines @@
   }
 }
 
 
 TEST(RunFloat64SubImm1) {
   double input = 0.0;
   double output = 0.0;
 
   FOR_FLOAT64_INPUTS(i) {
     RawMachineAssemblerTester<int32_t> m;
-    Node* t0 = m.LoadFromPointer(&input, kMachineFloat64);
+    Node* t0 = m.LoadFromPointer(&input, mFloat64);
     Node* t1 = m.Float64Sub(m.Float64Constant(*i), t0);
-    m.StoreToPointer(&output, kMachineFloat64, t1);
+    m.StoreToPointer(&output, mFloat64, t1);
     m.Return(m.Int32Constant(0));
     FOR_FLOAT64_INPUTS(j) {
       input = *j;
       double expected = *i - input;
       CHECK_EQ(0, m.Call());
       CHECK_EQ(expected, output);
     }
   }
 }
 
 
 TEST(RunFloat64SubImm2) {
   double input = 0.0;
   double output = 0.0;
 
   FOR_FLOAT64_INPUTS(i) {
     RawMachineAssemblerTester<int32_t> m;
-    Node* t0 = m.LoadFromPointer(&input, kMachineFloat64);
+    Node* t0 = m.LoadFromPointer(&input, mFloat64);
     Node* t1 = m.Float64Sub(t0, m.Float64Constant(*i));
-    m.StoreToPointer(&output, kMachineFloat64, t1);
+    m.StoreToPointer(&output, mFloat64, t1);
     m.Return(m.Int32Constant(0));
     FOR_FLOAT64_INPUTS(j) {
       input = *j;
       double expected = input - *i;
       CHECK_EQ(0, m.Call());
       CHECK_EQ(expected, output);
     }
   }
 }
 
@@ skipping 14 matching lines @@
 
 
 TEST(RunFloat64MulAndFloat64AddP) {
   double input_a = 0.0;
   double input_b = 0.0;
   double input_c = 0.0;
   double output = 0.0;
 
   {
     RawMachineAssemblerTester<int32_t> m;
-    Node* a = m.LoadFromPointer(&input_a, kMachineFloat64);
-    Node* b = m.LoadFromPointer(&input_b, kMachineFloat64);
-    Node* c = m.LoadFromPointer(&input_c, kMachineFloat64);
-    m.StoreToPointer(&output, kMachineFloat64,
-                     m.Float64Add(m.Float64Mul(a, b), c));
+    Node* a = m.LoadFromPointer(&input_a, mFloat64);
+    Node* b = m.LoadFromPointer(&input_b, mFloat64);
+    Node* c = m.LoadFromPointer(&input_c, mFloat64);
+    m.StoreToPointer(&output, mFloat64, m.Float64Add(m.Float64Mul(a, b), c));
     m.Return(m.Int32Constant(0));
     FOR_FLOAT64_INPUTS(i) {
       FOR_FLOAT64_INPUTS(j) {
         FOR_FLOAT64_INPUTS(k) {
           input_a = *i;
           input_b = *j;
           input_c = *k;
           volatile double temp = input_a * input_b;
           volatile double expected = temp + input_c;
           CHECK_EQ(0, m.Call());
           CHECK_EQ(expected, output);
         }
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
-    Node* a = m.LoadFromPointer(&input_a, kMachineFloat64);
-    Node* b = m.LoadFromPointer(&input_b, kMachineFloat64);
-    Node* c = m.LoadFromPointer(&input_c, kMachineFloat64);
-    m.StoreToPointer(&output, kMachineFloat64,
-                     m.Float64Add(a, m.Float64Mul(b, c)));
+    Node* a = m.LoadFromPointer(&input_a, mFloat64);
+    Node* b = m.LoadFromPointer(&input_b, mFloat64);
+    Node* c = m.LoadFromPointer(&input_c, mFloat64);
+    m.StoreToPointer(&output, mFloat64, m.Float64Add(a, m.Float64Mul(b, c)));
     m.Return(m.Int32Constant(0));
     FOR_FLOAT64_INPUTS(i) {
       FOR_FLOAT64_INPUTS(j) {
         FOR_FLOAT64_INPUTS(k) {
           input_a = *i;
           input_b = *j;
           input_c = *k;
           volatile double temp = input_b * input_c;
           volatile double expected = input_a + temp;
           CHECK_EQ(0, m.Call());
           CHECK_EQ(expected, output);
         }
       }
     }
   }
 }
 
 
 TEST(RunFloat64MulAndFloat64SubP) {
   double input_a = 0.0;
   double input_b = 0.0;
   double input_c = 0.0;
   double output = 0.0;
 
   RawMachineAssemblerTester<int32_t> m;
-  Node* a = m.LoadFromPointer(&input_a, kMachineFloat64);
-  Node* b = m.LoadFromPointer(&input_b, kMachineFloat64);
-  Node* c = m.LoadFromPointer(&input_c, kMachineFloat64);
-  m.StoreToPointer(&output, kMachineFloat64,
-                   m.Float64Sub(a, m.Float64Mul(b, c)));
+  Node* a = m.LoadFromPointer(&input_a, mFloat64);
+  Node* b = m.LoadFromPointer(&input_b, mFloat64);
+  Node* c = m.LoadFromPointer(&input_c, mFloat64);
+  m.StoreToPointer(&output, mFloat64, m.Float64Sub(a, m.Float64Mul(b, c)));
   m.Return(m.Int32Constant(0));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) {
       FOR_FLOAT64_INPUTS(k) {
         input_a = *i;
         input_b = *j;
         input_c = *k;
         volatile double temp = input_b * input_c;
         volatile double expected = input_a - temp;
         CHECK_EQ(0, m.Call());
         CHECK_EQ(expected, output);
       }
     }
   }
 }
 
 
 TEST(RunFloat64MulImm) {
   double input = 0.0;
   double output = 0.0;
 
   {
     FOR_FLOAT64_INPUTS(i) {
       RawMachineAssemblerTester<int32_t> m;
-      Node* t0 = m.LoadFromPointer(&input, kMachineFloat64);
+      Node* t0 = m.LoadFromPointer(&input, mFloat64);
       Node* t1 = m.Float64Mul(m.Float64Constant(*i), t0);
-      m.StoreToPointer(&output, kMachineFloat64, t1);
+      m.StoreToPointer(&output, mFloat64, t1);
       m.Return(m.Int32Constant(0));
       FOR_FLOAT64_INPUTS(j) {
         input = *j;
         double expected = *i * input;
         CHECK_EQ(0, m.Call());
         CHECK_EQ(expected, output);
       }
     }
   }
   {
     FOR_FLOAT64_INPUTS(i) {
       RawMachineAssemblerTester<int32_t> m;
-      Node* t0 = m.LoadFromPointer(&input, kMachineFloat64);
+      Node* t0 = m.LoadFromPointer(&input, mFloat64);
       Node* t1 = m.Float64Mul(t0, m.Float64Constant(*i));
-      m.StoreToPointer(&output, kMachineFloat64, t1);
+      m.StoreToPointer(&output, mFloat64, t1);
       m.Return(m.Int32Constant(0));
       FOR_FLOAT64_INPUTS(j) {
         input = *j;
         double expected = input * *i;
         CHECK_EQ(0, m.Call());
         CHECK_EQ(expected, output);
       }
     }
   }
 }
@@ skipping 29 matching lines @@
   }
 }
 
 
 TEST(RunChangeInt32ToFloat64_A) {
   RawMachineAssemblerTester<int32_t> m;
   int32_t magic = 0x986234;
   double result = 0;
 
   Node* convert = m.ChangeInt32ToFloat64(m.Int32Constant(magic));
-  m.Store(kMachineFloat64, m.PointerConstant(&result), m.Int32Constant(0),
-          convert);
+  m.Store(mFloat64, m.PointerConstant(&result), m.Int32Constant(0), convert);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(static_cast<double>(magic), result);
 }
 
 
 TEST(RunChangeInt32ToFloat64_B) {
-  RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+  RawMachineAssemblerTester<int32_t> m(mInt32);
   double output = 0;
 
   Node* convert = m.ChangeInt32ToFloat64(m.Parameter(0));
-  m.Store(kMachineFloat64, m.PointerConstant(&output), m.Int32Constant(0),
-          convert);
+  m.Store(mFloat64, m.PointerConstant(&output), m.Int32Constant(0), convert);
   m.Return(m.Parameter(0));
 
   FOR_INT32_INPUTS(i) {
     int32_t expect = *i;
     CHECK_EQ(expect, m.Call(expect));
     CHECK_EQ(static_cast<double>(expect), output);
   }
 }
 
 
 TEST(RunChangeUint32ToFloat64_B) {
-  RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+  RawMachineAssemblerTester<int32_t> m(mUint32);
   double output = 0;
 
   Node* convert = m.ChangeUint32ToFloat64(m.Parameter(0));
-  m.Store(kMachineFloat64, m.PointerConstant(&output), m.Int32Constant(0),
-          convert);
+  m.Store(mFloat64, m.PointerConstant(&output), m.Int32Constant(0), convert);
   m.Return(m.Parameter(0));
 
   FOR_UINT32_INPUTS(i) {
     uint32_t expect = *i;
     CHECK_EQ(expect, m.Call(expect));
     CHECK_EQ(static_cast<double>(expect), output);
   }
 }
 
 
 TEST(RunChangeFloat64ToInt32_A) {
   RawMachineAssemblerTester<int32_t> m;
   int32_t magic = 0x786234;
   double input = 11.1;
   int32_t result = 0;
 
-  m.Store(kMachineWord32, m.PointerConstant(&result), m.Int32Constant(0),
+  m.Store(mInt32, m.PointerConstant(&result), m.Int32Constant(0),
           m.ChangeFloat64ToInt32(m.Float64Constant(input)));
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(static_cast<int32_t>(input), result);
 }
 
 
 TEST(RunChangeFloat64ToInt32_B) {
   RawMachineAssemblerTester<int32_t> m;
   double input = 0;
   int32_t output = 0;
 
-  Node* load =
-      m.Load(kMachineFloat64, m.PointerConstant(&input), m.Int32Constant(0));
+  Node* load = m.Load(mFloat64, m.PointerConstant(&input), m.Int32Constant(0));
   Node* convert = m.ChangeFloat64ToInt32(load);
-  m.Store(kMachineWord32, m.PointerConstant(&output), m.Int32Constant(0),
-          convert);
+  m.Store(mInt32, m.PointerConstant(&output), m.Int32Constant(0), convert);
   m.Return(convert);
 
   {
     FOR_INT32_INPUTS(i) {
       input = *i;
       int32_t expect = *i;
       CHECK_EQ(expect, m.Call());
       CHECK_EQ(expect, output);
     }
   }
@@ skipping 17 matching lines @@
   // Note we don't check fractional inputs, because these Convert operators
   // really should be Change operators.
 }
 
 
 TEST(RunChangeFloat64ToUint32_B) {
   RawMachineAssemblerTester<int32_t> m;
   double input = 0;
   int32_t output = 0;
 
-  Node* load =
-      m.Load(kMachineFloat64, m.PointerConstant(&input), m.Int32Constant(0));
+  Node* load = m.Load(mFloat64, m.PointerConstant(&input), m.Int32Constant(0));
   Node* convert = m.ChangeFloat64ToUint32(load);
-  m.Store(kMachineWord32, m.PointerConstant(&output), m.Int32Constant(0),
-          convert);
+  m.Store(mInt32, m.PointerConstant(&output), m.Int32Constant(0), convert);
   m.Return(convert);
 
   {
     FOR_UINT32_INPUTS(i) {
       input = *i;
       // TODO(titzer): add a CheckEqualsHelper overload for uint32_t.
       int32_t expect = static_cast<int32_t>(*i);
       CHECK_EQ(expect, m.Call());
       CHECK_EQ(expect, output);
     }
@@ skipping 22 matching lines @@
 
 TEST(RunChangeFloat64ToInt32_spilled) {
   RawMachineAssemblerTester<int32_t> m;
   const int kNumInputs = 32;
   int32_t magic = 0x786234;
   double input[kNumInputs];
   int32_t result[kNumInputs];
   Node* input_node[kNumInputs];
 
   for (int i = 0; i < kNumInputs; i++) {
-    input_node[i] = m.Load(kMachineFloat64, m.PointerConstant(&input),
-                           m.Int32Constant(i * 8));
+    input_node[i] =
+        m.Load(mFloat64, m.PointerConstant(&input), m.Int32Constant(i * 8));
   }
 
   for (int i = 0; i < kNumInputs; i++) {
-    m.Store(kMachineWord32, m.PointerConstant(&result), m.Int32Constant(i * 4),
+    m.Store(mInt32, m.PointerConstant(&result), m.Int32Constant(i * 4),
             m.ChangeFloat64ToInt32(input_node[i]));
   }
 
   m.Return(m.Int32Constant(magic));
 
   for (int i = 0; i < kNumInputs; i++) {
     input[i] = 100.9 + i;
   }
 
   CHECK_EQ(magic, m.Call());
@@ skipping 55 matching lines @@
   MLabel blocka, blockb, end;
   Node* k1 = m.Float64Constant(constant);
   Node* k2 = m.Float64Constant(0 - constant);
   m.Branch(m.Int32Constant(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&end);
   m.Bind(&blockb);
   m.Goto(&end);
   m.Bind(&end);
   Node* phi = m.Phi(k2, k1);
-  m.Store(kMachineFloat64, m.PointerConstant(&buffer), m.Int32Constant(0), phi);
+  m.Store(mFloat64, m.PointerConstant(&buffer), m.Int32Constant(0), phi);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(constant, buffer);
 }
 
 
 TEST(RunRefDiamond) {
   RawMachineAssemblerTester<int32_t> m;
 
   const int magic = 99644;
   Handle<String> rexpected =
       CcTest::i_isolate()->factory()->InternalizeUtf8String("A");
   String* buffer;
 
   MLabel blocka, blockb, end;
   Node* k1 = m.StringConstant("A");
   Node* k2 = m.StringConstant("B");
   m.Branch(m.Int32Constant(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&end);
   m.Bind(&blockb);
   m.Goto(&end);
   m.Bind(&end);
   Node* phi = m.Phi(k2, k1);
-  m.Store(kMachineTagged, m.PointerConstant(&buffer), m.Int32Constant(0), phi);
+  m.Store(mAnyTagged, m.PointerConstant(&buffer), m.Int32Constant(0), phi);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK(rexpected->SameValue(buffer));
 }
 
 
 TEST(RunDoubleRefDiamond) {
   RawMachineAssemblerTester<int32_t> m;
 
@@ skipping 10 matching lines @@
   Node* r1 = m.StringConstant("AX");
   Node* r2 = m.StringConstant("BX");
   m.Branch(m.Int32Constant(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&end);
   m.Bind(&blockb);
   m.Goto(&end);
   m.Bind(&end);
   Node* dphi = m.Phi(d2, d1);
   Node* rphi = m.Phi(r2, r1);
-  m.Store(kMachineFloat64, m.PointerConstant(&dbuffer), m.Int32Constant(0),
-          dphi);
-  m.Store(kMachineTagged, m.PointerConstant(&rbuffer), m.Int32Constant(0),
-          rphi);
+  m.Store(mFloat64, m.PointerConstant(&dbuffer), m.Int32Constant(0), dphi);
+  m.Store(mAnyTagged, m.PointerConstant(&rbuffer), m.Int32Constant(0), rphi);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(dconstant, dbuffer);
   CHECK(rexpected->SameValue(rbuffer));
 }
 
 
 TEST(RunDoubleRefDoubleDiamond) {
   RawMachineAssemblerTester<int32_t> m;
@@ skipping 21 matching lines @@
   m.Branch(m.Int32Constant(0), &blockd, &blocke);
 
   m.Bind(&blockd);
   m.Goto(&end);
   m.Bind(&blocke);
   m.Goto(&end);
   m.Bind(&end);
   Node* dphi2 = m.Phi(d1, dphi1);
   Node* rphi2 = m.Phi(r1, rphi1);
 
-  m.Store(kMachineFloat64, m.PointerConstant(&dbuffer), m.Int32Constant(0),
-          dphi2);
-  m.Store(kMachineTagged, m.PointerConstant(&rbuffer), m.Int32Constant(0),
-          rphi2);
+  m.Store(mFloat64, m.PointerConstant(&dbuffer), m.Int32Constant(0), dphi2);
+  m.Store(mAnyTagged, m.PointerConstant(&rbuffer), m.Int32Constant(0), rphi2);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(dconstant, dbuffer);
   CHECK(rexpected->SameValue(rbuffer));
 }
 
 
 TEST(RunDoubleLoopPhi) {
   RawMachineAssemblerTester<int32_t> m;
   MLabel header, body, end;
 
   int magic = 99773;
   double buffer = 0.99;
   double dconstant = 777.1;
 
   Node* zero = m.Int32Constant(0);
   Node* dk = m.Float64Constant(dconstant);
 
   m.Goto(&header);
   m.Bind(&header);
   Node* phi = m.Phi(dk, dk);
   phi->ReplaceInput(1, phi);
   m.Branch(zero, &body, &end);
   m.Bind(&body);
   m.Goto(&header);
   m.Bind(&end);
-  m.Store(kMachineFloat64, m.PointerConstant(&buffer), m.Int32Constant(0), phi);
+  m.Store(mFloat64, m.PointerConstant(&buffer), m.Int32Constant(0), phi);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
 }
 
 
 TEST(RunCountToTenAccRaw) {
   RawMachineAssemblerTester<int32_t> m;
 
   Node* zero = m.Int32Constant(0);
@@ skipping 60 matching lines @@
 
   CHECK_EQ(10, m.Call());
 }
 
 
 TEST(RunAddTree) {
   RawMachineAssemblerTester<int32_t> m;
   int32_t inputs[] = {11, 12, 13, 14, 15, 16, 17, 18};
 
   Node* base = m.PointerConstant(inputs);
-  Node* n0 = m.Load(kMachineWord32, base, m.Int32Constant(0 * sizeof(int32_t)));
-  Node* n1 = m.Load(kMachineWord32, base, m.Int32Constant(1 * sizeof(int32_t)));
-  Node* n2 = m.Load(kMachineWord32, base, m.Int32Constant(2 * sizeof(int32_t)));
-  Node* n3 = m.Load(kMachineWord32, base, m.Int32Constant(3 * sizeof(int32_t)));
-  Node* n4 = m.Load(kMachineWord32, base, m.Int32Constant(4 * sizeof(int32_t)));
-  Node* n5 = m.Load(kMachineWord32, base, m.Int32Constant(5 * sizeof(int32_t)));
-  Node* n6 = m.Load(kMachineWord32, base, m.Int32Constant(6 * sizeof(int32_t)));
-  Node* n7 = m.Load(kMachineWord32, base, m.Int32Constant(7 * sizeof(int32_t)));
+  Node* n0 = m.Load(mInt32, base, m.Int32Constant(0 * sizeof(int32_t)));
+  Node* n1 = m.Load(mInt32, base, m.Int32Constant(1 * sizeof(int32_t)));
+  Node* n2 = m.Load(mInt32, base, m.Int32Constant(2 * sizeof(int32_t)));
+  Node* n3 = m.Load(mInt32, base, m.Int32Constant(3 * sizeof(int32_t)));
+  Node* n4 = m.Load(mInt32, base, m.Int32Constant(4 * sizeof(int32_t)));
+  Node* n5 = m.Load(mInt32, base, m.Int32Constant(5 * sizeof(int32_t)));
+  Node* n6 = m.Load(mInt32, base, m.Int32Constant(6 * sizeof(int32_t)));
+  Node* n7 = m.Load(mInt32, base, m.Int32Constant(7 * sizeof(int32_t)));
 
   Node* i1 = m.Int32Add(n0, n1);
   Node* i2 = m.Int32Add(n2, n3);
   Node* i3 = m.Int32Add(n4, n5);
   Node* i4 = m.Int32Add(n6, n7);
 
   Node* i5 = m.Int32Add(i1, i2);
   Node* i6 = m.Int32Add(i3, i4);
 
   Node* i7 = m.Int32Add(i5, i6);
@@ skipping 17 matching lines @@
     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());
-    m.Return(m.CallC(function, kMachineWord32, arg_types, args, 0));
+    m.Return(m.CallC(function, mInt32, 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(kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mInt32);
     Node* args[] = {m.Parameter(0)};
-    MachineType arg_types[] = {kMachineWord32};
+    MachineType arg_types[] = {mInt32};
     Node* function =
         call_direct ? m.PointerConstant(function_address)
                     : m.LoadFromPointer(&function_address,
                                         MachineOperatorBuilder::pointer_rep());
-    m.Return(m.CallC(function, kMachineWord32, arg_types, args, 1));
+    m.Return(m.CallC(function, mInt32, 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(kMachineWord32, kMachineWord32);
+    RawMachineAssemblerTester<int32_t> m(mInt32, mInt32);
     Node* args[] = {m.Parameter(0), m.Parameter(1)};
-    MachineType arg_types[] = {kMachineWord32, kMachineWord32};
+    MachineType arg_types[] = {mInt32, mInt32};
     Node* function =
         call_direct ? m.PointerConstant(function_address)
                     : m.LoadFromPointer(&function_address,
                                         MachineOperatorBuilder::pointer_rep());
-    m.Return(m.CallC(function, kMachineWord32, arg_types, args, 2));
+    m.Return(m.CallC(function, mInt32, 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);
       }
     }
   }
 }
 
 #endif  // MACHINE_ASSEMBLER_SUPPORTS_CALL_C
 
 
 static const int kFloat64CompareHelperTestCases = 15;
 static const int kFloat64CompareHelperNodeType = 4;
 
 static int Float64CompareHelper(RawMachineAssemblerTester<int32_t>* m,
                                 int test_case, int node_type, double x,
                                 double y) {
   static double buffer[2];
   buffer[0] = x;
   buffer[1] = y;
   CHECK(0 <= test_case && test_case < kFloat64CompareHelperTestCases);
   CHECK(0 <= node_type && node_type < kFloat64CompareHelperNodeType);
   CHECK(x < y);
   bool load_a = node_type / 2 == 1;
   bool load_b = node_type % 2 == 1;
-  Node* a = load_a ? m->Load(kMachineFloat64, m->PointerConstant(&buffer[0]))
+  Node* a = load_a ? m->Load(mFloat64, m->PointerConstant(&buffer[0]))
                    : m->Float64Constant(x);
-  Node* b = load_b ? m->Load(kMachineFloat64, m->PointerConstant(&buffer[1]))
+  Node* b = load_b ? m->Load(mFloat64, m->PointerConstant(&buffer[1]))
                    : m->Float64Constant(y);
   Node* cmp = NULL;
   bool expected = false;
   switch (test_case) {
     // Equal tests.
     case 0:
       cmp = m->Float64Equal(a, b);
       expected = false;
       break;
     case 1:
@@ skipping 107 matching lines @@
     }
   }
 }
 
 
 TEST(RunFloat64Equal) {
   double input_a = 0.0;
   double input_b = 0.0;
 
   RawMachineAssemblerTester<int32_t> m;
-  Node* a = m.LoadFromPointer(&input_a, kMachineFloat64);
-  Node* b = m.LoadFromPointer(&input_b, kMachineFloat64);
+  Node* a = m.LoadFromPointer(&input_a, mFloat64);
+  Node* b = m.LoadFromPointer(&input_b, mFloat64);
   m.Return(m.Float64Equal(a, b));
 
   CompareWrapper cmp(IrOpcode::kFloat64Equal);
   FOR_FLOAT64_INPUTS(pl) {
     FOR_FLOAT64_INPUTS(pr) {
       input_a = *pl;
       input_b = *pr;
       int32_t expected = cmp.Float64Compare(input_a, input_b) ? 1 : 0;
       CHECK_EQ(expected, m.Call());
     }
   }
 }
 
 
 TEST(RunFloat64LessThan) {
   double input_a = 0.0;
   double input_b = 0.0;
 
   RawMachineAssemblerTester<int32_t> m;
-  Node* a = m.LoadFromPointer(&input_a, kMachineFloat64);
-  Node* b = m.LoadFromPointer(&input_b, kMachineFloat64);
+  Node* a = m.LoadFromPointer(&input_a, mFloat64);
+  Node* b = m.LoadFromPointer(&input_b, mFloat64);
   m.Return(m.Float64LessThan(a, b));
 
   CompareWrapper cmp(IrOpcode::kFloat64LessThan);
   FOR_FLOAT64_INPUTS(pl) {
     FOR_FLOAT64_INPUTS(pr) {
       input_a = *pl;
       input_b = *pr;
       int32_t expected = cmp.Float64Compare(input_a, input_b) ? 1 : 0;
       CHECK_EQ(expected, m.Call());
     }
@@ skipping 28 matching lines @@
   for (int i = -127; i < 127; i++) {
     input = i;
     int expected = i >= 0 ? i + 1 : max + (i - min) + 2;
     CHECK_EQ(expected, m.Call());
     CHECK_EQ(i + 1, input);
   }
 }
 
 
 TEST(RunLoadStoreTruncation) {
-  LoadStoreTruncation<int8_t, kMachineWord8>();
-  LoadStoreTruncation<int16_t, kMachineWord16>();
+  LoadStoreTruncation<int8_t, mInt8>();
+  LoadStoreTruncation<int16_t, mInt16>();
 }
 
 
 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());
     Node* p0 = m.Parameter(0);
     Node* p1 = m.Parameter(1);
     Node* res = NULL;
@@ skipping 55 matching lines @@
   int32_t outputs[kInputSize];
   for (int i = 0; i < kInputSize; i++) {
     inputs[i] = i;
     outputs[i] = -1;
   }
   RawMachineAssemblerTester<int32_t*> m;
   Node* input = m.PointerConstant(&inputs[0]);
   Node* output = m.PointerConstant(&outputs[kInputSize - 1]);
   Node* elem_size = m.ConvertInt32ToIntPtr(m.Int32Constant(sizeof(inputs[0])));
   for (int i = 0; i < kInputSize; i++) {
-    m.Store(kMachineWord32, output, m.Load(kMachineWord32, input));
+    m.Store(mInt32, output, m.Load(mInt32, input));
     input = m.IntPtrAdd(input, elem_size);
     output = m.IntPtrSub(output, elem_size);
   }
   m.Return(input);
   CHECK_EQ(&inputs[kInputSize], m.Call());
   for (int i = 0; i < kInputSize; i++) {
     CHECK_EQ(i, inputs[i]);
     CHECK_EQ(kInputSize - i - 1, outputs[i]);
   }
 }
@@ skipping 20 matching lines @@
         m.Word32Shl(bt.param0, m.Int32Sub(m.Int32Constant(32), bt.param1)),
         m.Word32Shr(bt.param0, bt.param1)));
     bt.Run(ValueHelper::uint32_vector(), ValueHelper::ror_vector(), rotr32);
   }
 }
 
 
 TEST(RunTestInt32RotateRightImm) {
   FOR_INPUTS(uint32_t, ror, i) {
     {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mUint32);
       Node* value = m.Parameter(0);
       m.Return(m.Word32Or(m.Word32Shr(value, m.Int32Constant(*i)),
                           m.Word32Shl(value, m.Int32Constant(32 - *i))));
       m.Run(ValueHelper::uint32_vector(),
             std::bind2nd(std::ptr_fun(&rotr32), *i));
     }
     {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mUint32);
       Node* value = m.Parameter(0);
       m.Return(m.Word32Or(m.Word32Shl(value, m.Int32Constant(32 - *i)),
                           m.Word32Shr(value, m.Int32Constant(*i))));
       m.Run(ValueHelper::uint32_vector(),
             std::bind2nd(std::ptr_fun(&rotr32), *i));
     }
   }
 }
 
 
 TEST(RunSpillLotsOfThings) {
   static const int kInputSize = 1000;
   RawMachineAssemblerTester<void> m;
   Node* accs[kInputSize];
   int32_t outputs[kInputSize];
   Node* one = m.Int32Constant(1);
   Node* acc = one;
   for (int i = 0; i < kInputSize; i++) {
     acc = m.Int32Add(acc, one);
     accs[i] = acc;
   }
   for (int i = 0; i < kInputSize; i++) {
-    m.StoreToPointer(&outputs[i], kMachineWord32, accs[i]);
+    m.StoreToPointer(&outputs[i], mInt32, accs[i]);
   }
   m.Return(one);
   m.Call();
   for (int i = 0; i < kInputSize; i++) {
     CHECK_EQ(outputs[i], i + 2);
   }
 }
 
 
 TEST(RunSpillConstantsAndParameters) {
   static const int kInputSize = 1000;
   static const int32_t kBase = 987;
-  RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32);
+  RawMachineAssemblerTester<int32_t> m(mInt32, mInt32);
   int32_t outputs[kInputSize];
   Node* csts[kInputSize];
   Node* accs[kInputSize];
   Node* acc = m.Int32Constant(0);
   for (int i = 0; i < kInputSize; i++) {
     csts[i] = m.Int32Constant(static_cast<int32_t>(kBase + i));
   }
   for (int i = 0; i < kInputSize; i++) {
     acc = m.Int32Add(acc, csts[i]);
     accs[i] = acc;
   }
   for (int i = 0; i < kInputSize; i++) {
-    m.StoreToPointer(&outputs[i], kMachineWord32, accs[i]);
+    m.StoreToPointer(&outputs[i], mInt32, accs[i]);
   }
   m.Return(m.Int32Add(acc, m.Int32Add(m.Parameter(0), m.Parameter(1))));
   FOR_INT32_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       int32_t expected = *i + *j;
       for (int k = 0; k < kInputSize; k++) {
         expected += kBase + k;
       }
       CHECK_EQ(expected, m.Call(*i, *j));
       expected = 0;
       for (int k = 0; k < kInputSize; k++) {
         expected += kBase + k;
         CHECK_EQ(expected, outputs[k]);
       }
     }
   }
 }
 
 
 TEST(RunNewSpaceConstantsInPhi) {
-  RawMachineAssemblerTester<Object*> m(kMachineWord32);
+  RawMachineAssemblerTester<Object*> m(mInt32);
 
   Isolate* isolate = CcTest::i_isolate();
   Handle<HeapNumber> true_val = isolate->factory()->NewHeapNumber(11.2);
   Handle<HeapNumber> false_val = isolate->factory()->NewHeapNumber(11.3);
   Node* true_node = m.HeapConstant(true_val);
   Node* false_node = m.HeapConstant(false_val);
 
   MLabel blocka, blockb, end;
   m.Branch(m.Parameter(0), &blocka, &blockb);
   m.Bind(&blocka);
@@ skipping 21 matching lines @@
   Node* acc = one;
   for (int i = 0; i < kInputSize; i++) {
     acc = m.Int32Add(acc, one);
     accs[i] = acc;
   }
   // If the spill slot computation is wrong, it might load from the c frame
   {
     void* func = reinterpret_cast<void*>(reinterpret_cast<intptr_t>(&Seven));
     Node** args = NULL;
     MachineType* arg_types = NULL;
-    m.CallC(m.PointerConstant(func), kMachineWord32, arg_types, args, 0);
+    m.CallC(m.PointerConstant(func), mInt32, arg_types, args, 0);
   }
   for (int i = 0; i < kInputSize; i++) {
-    m.StoreToPointer(&outputs[i], kMachineWord32, accs[i]);
+    m.StoreToPointer(&outputs[i], mInt32, accs[i]);
   }
   m.Return(one);
   m.Call();
   for (int i = 0; i < kInputSize; i++) {
     CHECK_EQ(outputs[i], i + 2);
   }
 }
 
 #endif  // MACHINE_ASSEMBLER_SUPPORTS_CALL_C
 
@@ skipping 14 matching lines @@
 }
 
 
 TEST(RunInt32AddWithOverflowP) {
   int32_t actual_val = -1;
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
   Node* add = m.Int32AddWithOverflow(bt.param0, bt.param1);
   Node* val = m.Projection(0, add);
   Node* ovf = m.Projection(1, add);
-  m.StoreToPointer(&actual_val, kMachineWord32, val);
+  m.StoreToPointer(&actual_val, mInt32, val);
   bt.AddReturn(ovf);
   FOR_INT32_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       int32_t expected_val;
       int expected_ovf = sadd_overflow(*i, *j, &expected_val);
       CHECK_EQ(expected_ovf, bt.call(*i, *j));
       CHECK_EQ(expected_val, actual_val);
     }
   }
 }
 
 
 TEST(RunInt32AddWithOverflowImm) {
   int32_t actual_val = -1, expected_val = 0;
   FOR_INT32_INPUTS(i) {
     {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mInt32);
       Node* add = m.Int32AddWithOverflow(m.Int32Constant(*i), m.Parameter(0));
       Node* val = m.Projection(0, add);
       Node* ovf = m.Projection(1, add);
-      m.StoreToPointer(&actual_val, kMachineWord32, val);
+      m.StoreToPointer(&actual_val, mInt32, val);
       m.Return(ovf);
       FOR_INT32_INPUTS(j) {
         int expected_ovf = sadd_overflow(*i, *j, &expected_val);
         CHECK_EQ(expected_ovf, m.Call(*j));
         CHECK_EQ(expected_val, actual_val);
       }
     }
     {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mInt32);
       Node* add = m.Int32AddWithOverflow(m.Parameter(0), m.Int32Constant(*i));
       Node* val = m.Projection(0, add);
       Node* ovf = m.Projection(1, add);
-      m.StoreToPointer(&actual_val, kMachineWord32, val);
+      m.StoreToPointer(&actual_val, mInt32, val);
       m.Return(ovf);
       FOR_INT32_INPUTS(j) {
         int expected_ovf = sadd_overflow(*i, *j, &expected_val);
         CHECK_EQ(expected_ovf, m.Call(*j));
         CHECK_EQ(expected_val, actual_val);
       }
     }
     FOR_INT32_INPUTS(j) {
       RawMachineAssemblerTester<int32_t> m;
       Node* add =
           m.Int32AddWithOverflow(m.Int32Constant(*i), m.Int32Constant(*j));
       Node* val = m.Projection(0, add);
       Node* ovf = m.Projection(1, add);
-      m.StoreToPointer(&actual_val, kMachineWord32, val);
+      m.StoreToPointer(&actual_val, mInt32, val);
       m.Return(ovf);
       int expected_ovf = sadd_overflow(*i, *j, &expected_val);
       CHECK_EQ(expected_ovf, m.Call());
       CHECK_EQ(expected_val, actual_val);
     }
   }
 }
 
 
 TEST(RunInt32AddWithOverflowInBranchP) {
   int constant = 911777;
   MLabel blocka, blockb;
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
   Node* add = m.Int32AddWithOverflow(bt.param0, bt.param1);
   Node* ovf = m.Projection(1, add);
   m.Branch(ovf, &blocka, &blockb);
   m.Bind(&blocka);
   bt.AddReturn(m.Int32Constant(constant));
   m.Bind(&blockb);
   Node* val = m.Projection(0, add);
   bt.AddReturn(val);
-  FOR_UINT32_INPUTS(i) {
-    FOR_UINT32_INPUTS(j) {
+  FOR_INT32_INPUTS(i) {
+    FOR_INT32_INPUTS(j) {
       int32_t expected;
       if (sadd_overflow(*i, *j, &expected)) expected = constant;
       CHECK_EQ(expected, bt.call(*i, *j));
     }
   }
 }
 
 
 TEST(RunInt32SubWithOverflowP) {
   int32_t actual_val = -1;
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
   Node* add = m.Int32SubWithOverflow(bt.param0, bt.param1);
   Node* val = m.Projection(0, add);
   Node* ovf = m.Projection(1, add);
-  m.StoreToPointer(&actual_val, kMachineWord32, val);
+  m.StoreToPointer(&actual_val, mInt32, val);
   bt.AddReturn(ovf);
   FOR_INT32_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       int32_t expected_val;
       int expected_ovf = ssub_overflow(*i, *j, &expected_val);
       CHECK_EQ(expected_ovf, bt.call(*i, *j));
       CHECK_EQ(expected_val, actual_val);
     }
   }
 }
 
 
 TEST(RunInt32SubWithOverflowImm) {
   int32_t actual_val = -1, expected_val = 0;
   FOR_INT32_INPUTS(i) {
     {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mInt32);
       Node* add = m.Int32SubWithOverflow(m.Int32Constant(*i), m.Parameter(0));
       Node* val = m.Projection(0, add);
       Node* ovf = m.Projection(1, add);
-      m.StoreToPointer(&actual_val, kMachineWord32, val);
+      m.StoreToPointer(&actual_val, mInt32, val);
       m.Return(ovf);
       FOR_INT32_INPUTS(j) {
         int expected_ovf = ssub_overflow(*i, *j, &expected_val);
         CHECK_EQ(expected_ovf, m.Call(*j));
         CHECK_EQ(expected_val, actual_val);
       }
     }
     {
-      RawMachineAssemblerTester<int32_t> m(kMachineWord32);
+      RawMachineAssemblerTester<int32_t> m(mInt32);
       Node* add = m.Int32SubWithOverflow(m.Parameter(0), m.Int32Constant(*i));
       Node* val = m.Projection(0, add);
       Node* ovf = m.Projection(1, add);
-      m.StoreToPointer(&actual_val, kMachineWord32, val);
+      m.StoreToPointer(&actual_val, mInt32, val);
       m.Return(ovf);
       FOR_INT32_INPUTS(j) {
         int expected_ovf = ssub_overflow(*j, *i, &expected_val);
         CHECK_EQ(expected_ovf, m.Call(*j));
         CHECK_EQ(expected_val, actual_val);
       }
     }
     FOR_INT32_INPUTS(j) {
       RawMachineAssemblerTester<int32_t> m;
       Node* add =
           m.Int32SubWithOverflow(m.Int32Constant(*i), m.Int32Constant(*j));
       Node* val = m.Projection(0, add);
       Node* ovf = m.Projection(1, add);
-      m.StoreToPointer(&actual_val, kMachineWord32, val);
+      m.StoreToPointer(&actual_val, mInt32, val);
       m.Return(ovf);
       int expected_ovf = ssub_overflow(*i, *j, &expected_val);
       CHECK_EQ(expected_ovf, m.Call());
       CHECK_EQ(expected_val, actual_val);
     }
   }
 }
 
 
 TEST(RunInt32SubWithOverflowInBranchP) {
   int constant = 911999;
   MLabel blocka, blockb;
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
   Node* sub = m.Int32SubWithOverflow(bt.param0, bt.param1);
   Node* ovf = m.Projection(1, sub);
   m.Branch(ovf, &blocka, &blockb);
   m.Bind(&blocka);
   bt.AddReturn(m.Int32Constant(constant));
   m.Bind(&blockb);
   Node* val = m.Projection(0, sub);
   bt.AddReturn(val);
-  FOR_UINT32_INPUTS(i) {
-    FOR_UINT32_INPUTS(j) {
+  FOR_INT32_INPUTS(i) {
+    FOR_INT32_INPUTS(j) {
       int32_t expected;
       if (ssub_overflow(*i, *j, &expected)) expected = constant;
       CHECK_EQ(expected, bt.call(*i, *j));
     }
   }
 }
 
 #endif  // V8_TURBOFAN_TARGET