[turbofan] Make MachineType a pair of enums.

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 <cmath>
 #include <functional>
 #include <limits>
 
 #include "src/base/bits.h"
 #include "src/base/utils/random-number-generator.h"
@@ skipping 12 matching lines @@
 
 TEST(RunInt32Add) {
   RawMachineAssemblerTester<int32_t> m;
   Node* add = m.Int32Add(m.Int32Constant(0), m.Int32Constant(1));
   m.Return(add);
   CHECK_EQ(1, m.Call());
 }
 
 
 TEST(RunWord32Ctz) {
-  BufferedRawMachineAssemblerTester<int32_t> m(kMachUint32);
+  BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
   if (!m.machine()->Word32Ctz().IsSupported()) {
     // We can only test the operator if it exists on the testing platform.
     return;
   }
   m.Return(m.AddNode(m.machine()->Word32Ctz().op(), m.Parameter(0)));
 
   CHECK_EQ(32, m.Call(uint32_t(0x00000000)));
   CHECK_EQ(31, m.Call(uint32_t(0x80000000)));
   CHECK_EQ(30, m.Call(uint32_t(0x40000000)));
   CHECK_EQ(29, m.Call(uint32_t(0x20000000)));
@@ skipping 23 matching lines @@
   CHECK_EQ(5, m.Call(uint32_t(0xde3bcb20)));
   CHECK_EQ(4, m.Call(uint32_t(0xd7e8a610)));
   CHECK_EQ(3, m.Call(uint32_t(0x9afdbc88)));
   CHECK_EQ(2, m.Call(uint32_t(0x9afdbc84)));
   CHECK_EQ(1, m.Call(uint32_t(0x9afdbc82)));
   CHECK_EQ(0, m.Call(uint32_t(0x9afdbc81)));
 }
 
 
 TEST(RunWord32Clz) {
-  BufferedRawMachineAssemblerTester<int32_t> m(kMachUint32);
+  BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
   m.Return(m.Word32Clz(m.Parameter(0)));
 
   CHECK_EQ(0, m.Call(uint32_t(0x80001000)));
   CHECK_EQ(1, m.Call(uint32_t(0x40000500)));
   CHECK_EQ(2, m.Call(uint32_t(0x20000300)));
   CHECK_EQ(3, m.Call(uint32_t(0x10000003)));
   CHECK_EQ(4, m.Call(uint32_t(0x08050000)));
   CHECK_EQ(5, m.Call(uint32_t(0x04006000)));
   CHECK_EQ(6, m.Call(uint32_t(0x02000000)));
   CHECK_EQ(7, m.Call(uint32_t(0x010000a0)));
@@ skipping 19 matching lines @@
   CHECK_EQ(27, m.Call(uint32_t(0x00000013)));
   CHECK_EQ(28, m.Call(uint32_t(0x00000008)));
   CHECK_EQ(29, m.Call(uint32_t(0x00000004)));
   CHECK_EQ(30, m.Call(uint32_t(0x00000002)));
   CHECK_EQ(31, m.Call(uint32_t(0x00000001)));
   CHECK_EQ(32, m.Call(uint32_t(0x00000000)));
 }
 
 
 TEST(RunWord32Popcnt) {
-  BufferedRawMachineAssemblerTester<int32_t> m(kMachUint32);
+  BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
   if (!m.machine()->Word32Popcnt().IsSupported()) {
     // We can only test the operator if it exists on the testing platform.
     return;
   }
   m.Return(m.AddNode(m.machine()->Word32Popcnt().op(), m.Parameter(0)));
 
   CHECK_EQ(0, m.Call(uint32_t(0x00000000)));
   CHECK_EQ(1, m.Call(uint32_t(0x00000001)));
   CHECK_EQ(1, m.Call(uint32_t(0x80000000)));
   CHECK_EQ(32, m.Call(uint32_t(0xffffffff)));
   CHECK_EQ(6, m.Call(uint32_t(0x000dc100)));
   CHECK_EQ(9, m.Call(uint32_t(0xe00dc100)));
   CHECK_EQ(11, m.Call(uint32_t(0xe00dc103)));
   CHECK_EQ(9, m.Call(uint32_t(0x000dc107)));
 }
 
 
 #if V8_TARGET_ARCH_64_BIT
 TEST(RunWord64Clz) {
-  BufferedRawMachineAssemblerTester<int32_t> m(kMachUint64);
+  BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint64());
   m.Return(m.Word64Clz(m.Parameter(0)));
 
   CHECK_EQ(0, m.Call(uint64_t(0x8000100000000000)));
   CHECK_EQ(1, m.Call(uint64_t(0x4000050000000000)));
   CHECK_EQ(2, m.Call(uint64_t(0x2000030000000000)));
   CHECK_EQ(3, m.Call(uint64_t(0x1000000300000000)));
   CHECK_EQ(4, m.Call(uint64_t(0x0805000000000000)));
   CHECK_EQ(5, m.Call(uint64_t(0x0400600000000000)));
   CHECK_EQ(6, m.Call(uint64_t(0x0200000000000000)));
   CHECK_EQ(7, m.Call(uint64_t(0x010000a000000000)));
@@ skipping 51 matching lines @@
   CHECK_EQ(59, m.Call(uint64_t(0x0000000000000013)));
   CHECK_EQ(60, m.Call(uint64_t(0x0000000000000008)));
   CHECK_EQ(61, m.Call(uint64_t(0x0000000000000004)));
   CHECK_EQ(62, m.Call(uint64_t(0x0000000000000002)));
   CHECK_EQ(63, m.Call(uint64_t(0x0000000000000001)));
   CHECK_EQ(64, m.Call(uint64_t(0x0000000000000000)));
 }
 
 
 TEST(RunWord64Ctz) {
-  RawMachineAssemblerTester<int32_t> m(kMachUint64);
+  RawMachineAssemblerTester<int32_t> m(MachineType::Uint64());
   if (!m.machine()->Word64Ctz().IsSupported()) {
     return;
   }
 
   m.Return(m.AddNode(m.machine()->Word64Ctz().op(), m.Parameter(0)));
 
   CHECK_EQ(64, m.Call(uint64_t(0x0000000000000000)));
   CHECK_EQ(63, m.Call(uint64_t(0x8000000000000000)));
   CHECK_EQ(62, m.Call(uint64_t(0x4000000000000000)));
   CHECK_EQ(61, m.Call(uint64_t(0x2000000000000000)));
@@ skipping 55 matching lines @@
   CHECK_EQ(5, m.Call(uint64_t(0x00000000de3bcb20)));
   CHECK_EQ(4, m.Call(uint64_t(0x00000000d7e8a610)));
   CHECK_EQ(3, m.Call(uint64_t(0x000000009afdbc88)));
   CHECK_EQ(2, m.Call(uint64_t(0x000000009afdbc84)));
   CHECK_EQ(1, m.Call(uint64_t(0x000000009afdbc82)));
   CHECK_EQ(0, m.Call(uint64_t(0x000000009afdbc81)));
 }
 
 
 TEST(RunWord64Popcnt) {
-  BufferedRawMachineAssemblerTester<int32_t> m(kMachUint64);
+  BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint64());
   if (!m.machine()->Word64Popcnt().IsSupported()) {
     return;
   }
 
   m.Return(m.AddNode(m.machine()->Word64Popcnt().op(), m.Parameter(0)));
 
   CHECK_EQ(0, m.Call(uint64_t(0x0000000000000000)));
   CHECK_EQ(1, m.Call(uint64_t(0x0000000000000001)));
   CHECK_EQ(1, m.Call(uint64_t(0x8000000000000000)));
   CHECK_EQ(64, m.Call(uint64_t(0xffffffffffffffff)));
@@ skipping 15 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(kMachInt32, m->PointerConstant(NULL));
+      return m->Load(MachineType::Int32(), m->PointerConstant(NULL));
     default:
       return NULL;
   }
 }
 
 
 TEST(CodeGenInt32Binop) {
   RawMachineAssemblerTester<void> m;
 
   const Operator* kOps[] = {
       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()->Int32MulHigh(),   m.machine()->Int32Div(),
       m.machine()->Uint32Div(),      m.machine()->Int32Mod(),
       m.machine()->Uint32Mod(),      m.machine()->Uint32MulHigh(),
       m.machine()->Int32LessThan(),  m.machine()->Int32LessThanOrEqual(),
       m.machine()->Uint32LessThan(), m.machine()->Uint32LessThanOrEqual()};
 
   for (size_t i = 0; i < arraysize(kOps); ++i) {
     for (int j = 0; j < 8; j++) {
       for (int k = 0; k < 8; k++) {
-        RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
+        RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
+                                             MachineType::Int32());
         Node* a = Int32Input(&m, j);
         Node* b = Int32Input(&m, k);
         m.Return(m.AddNode(kOps[i], a, b));
         m.GenerateCode();
       }
     }
   }
 }
 
 
@@ skipping 15 matching lines @@
       return m->Int64Constant(0);
     case 3:
       return m->Int64Constant(1);
     case 4:
       return m->Int64Constant(-1);
     case 5:
       return m->Int64Constant(0xff);
     case 6:
       return m->Int64Constant(0x0123456789abcdefLL);
     case 7:
-      return m->Load(kMachInt64, m->PointerConstant(NULL));
+      return m->Load(MachineType::Int64(), m->PointerConstant(NULL));
     default:
       return NULL;
   }
 }
 
 
 TEST(CodeGenInt64Binop) {
   RawMachineAssemblerTester<void> m;
 
   const Operator* kOps[] = {
       m.machine()->Word64And(), m.machine()->Word64Or(),
       m.machine()->Word64Xor(), m.machine()->Word64Shl(),
       m.machine()->Word64Shr(), m.machine()->Word64Sar(),
       m.machine()->Word64Equal(), m.machine()->Int64Add(),
       m.machine()->Int64Sub(), m.machine()->Int64Mul(), m.machine()->Int64Div(),
       m.machine()->Uint64Div(), m.machine()->Int64Mod(),
       m.machine()->Uint64Mod(), m.machine()->Int64LessThan(),
       m.machine()->Int64LessThanOrEqual(), m.machine()->Uint64LessThan(),
       m.machine()->Uint64LessThanOrEqual()};
 
   for (size_t i = 0; i < arraysize(kOps); ++i) {
     for (int j = 0; j < 8; j++) {
       for (int k = 0; k < 8; k++) {
-        RawMachineAssemblerTester<int64_t> m(kMachInt64, kMachInt64);
+        RawMachineAssemblerTester<int64_t> m(MachineType::Int64(),
+                                             MachineType::Int64());
         Node* a = Int64Input(&m, j);
         Node* b = Int64Input(&m, k);
         m.Return(m.AddNode(kOps[i], a, b));
         m.GenerateCode();
       }
     }
   }
 }
 
 
@@ skipping 74 matching lines @@
   m.Goto(&header);
   m.Bind(&exit);
   m.Return(m.Int32Constant(constant));
 
   CHECK_EQ(constant, m.Call());
 }
 
 
 template <typename R>
 static void BuildDiamondPhi(RawMachineAssemblerTester<R>* m, Node* cond_node,
-                            MachineType type, Node* true_node,
+                            MachineRepresentation rep, Node* true_node,
                             Node* false_node) {
   RawMachineLabel blocka, blockb, end;
   m->Branch(cond_node, &blocka, &blockb);
   m->Bind(&blocka);
   m->Goto(&end);
   m->Bind(&blockb);
   m->Goto(&end);
 
   m->Bind(&end);
-  Node* phi = m->Phi(type, true_node, false_node);
+  Node* phi = m->Phi(rep, true_node, false_node);
   m->Return(phi);
 }
 
 
 TEST(RunDiamondPhiConst) {
-  RawMachineAssemblerTester<int32_t> m(kMachInt32);
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
   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), kMachInt32, true_node, false_node);
+  BuildDiamondPhi(&m, m.Parameter(0), MachineRepresentation::kWord32, true_node,
+                  false_node);
   CHECK_EQ(false_val, m.Call(0));
   CHECK_EQ(true_val, m.Call(1));
 }
 
 
 TEST(RunDiamondPhiNumber) {
-  RawMachineAssemblerTester<Object*> m(kMachInt32);
+  RawMachineAssemblerTester<Object*> m(MachineType::Int32());
   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), kMachAnyTagged, true_node, false_node);
+  BuildDiamondPhi(&m, m.Parameter(0), MachineRepresentation::kTagged, true_node,
+                  false_node);
   m.CheckNumber(false_val, m.Call(0));
   m.CheckNumber(true_val, m.Call(1));
 }
 
 
 TEST(RunDiamondPhiString) {
-  RawMachineAssemblerTester<Object*> m(kMachInt32);
+  RawMachineAssemblerTester<Object*> m(MachineType::Int32());
   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), kMachAnyTagged, true_node, false_node);
+  BuildDiamondPhi(&m, m.Parameter(0), MachineRepresentation::kTagged, true_node,
+                  false_node);
   m.CheckString(false_val, m.Call(0));
   m.CheckString(true_val, m.Call(1));
 }
 
 
 TEST(RunDiamondPhiParam) {
-  RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
-  BuildDiamondPhi(&m, m.Parameter(0), kMachInt32, m.Parameter(1),
-                  m.Parameter(2));
+  RawMachineAssemblerTester<int32_t> m(
+      MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
+  BuildDiamondPhi(&m, m.Parameter(0), MachineRepresentation::kWord32,
+                  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);
 }
 
 
 TEST(RunLoopPhiConst) {
   RawMachineAssemblerTester<int32_t> m;
   int true_val = 0x44000;
   int false_val = 0x00888;
 
   Node* cond_node = m.Int32Constant(0);
   Node* true_node = m.Int32Constant(true_val);
   Node* false_node = m.Int32Constant(false_val);
 
   // x = false_val; while(false) { x = true_val; } return x;
   RawMachineLabel body, header, end;
 
   m.Goto(&header);
   m.Bind(&header);
-  Node* phi = m.Phi(kMachInt32, false_node, true_node);
+  Node* phi = m.Phi(MachineRepresentation::kWord32, false_node, true_node);
   m.Branch(cond_node, &body, &end);
   m.Bind(&body);
   m.Goto(&header);
   m.Bind(&end);
   m.Return(phi);
 
   CHECK_EQ(false_val, m.Call());
 }
 
 
 TEST(RunLoopPhiParam) {
-  RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
+  RawMachineAssemblerTester<int32_t> m(
+      MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
 
   RawMachineLabel blocka, blockb, end;
 
   m.Goto(&blocka);
 
   m.Bind(&blocka);
-  Node* phi = m.Phi(kMachInt32, m.Parameter(1), m.Parameter(2));
-  Node* cond = m.Phi(kMachInt32, m.Parameter(0), m.Int32Constant(0));
+  Node* phi =
+      m.Phi(MachineRepresentation::kWord32, m.Parameter(1), m.Parameter(2));
+  Node* cond =
+      m.Phi(MachineRepresentation::kWord32, m.Parameter(0), m.Int32Constant(0));
   m.Branch(cond, &blockb, &end);
 
   m.Bind(&blockb);
   m.Goto(&blocka);
 
   m.Bind(&end);
   m.Return(phi);
 
   int32_t c1 = 0xa81903b4;
   int32_t c2 = 0x5a1207da;
   int result = m.Call(0, c1, c2);
   CHECK_EQ(c1, result);
   result = m.Call(1, c1, c2);
   CHECK_EQ(c2, result);
 }
 
 
 TEST(RunLoopPhiInduction) {
   RawMachineAssemblerTester<int32_t> m;
 
   int false_val = 0x10777;
 
   // x = false_val; while(false) { x++; } return x;
   RawMachineLabel header, body, end;
   Node* false_node = m.Int32Constant(false_val);
 
   m.Goto(&header);
 
   m.Bind(&header);
-  Node* phi = m.Phi(kMachInt32, false_node, false_node);
+  Node* phi = m.Phi(MachineRepresentation::kWord32, false_node, false_node);
   m.Branch(m.Int32Constant(0), &body, &end);
 
   m.Bind(&body);
   Node* add = m.Int32Add(phi, m.Int32Constant(1));
   phi->ReplaceInput(1, add);
   m.Goto(&header);
 
   m.Bind(&end);
   m.Return(phi);
 
   CHECK_EQ(false_val, m.Call());
 }
 
 
 TEST(RunLoopIncrement) {
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
 
   // x = 0; while(x ^ param) { x++; } return x;
   RawMachineLabel header, body, end;
   Node* zero = m.Int32Constant(0);
 
   m.Goto(&header);
 
   m.Bind(&header);
-  Node* phi = m.Phi(kMachInt32, zero, zero);
+  Node* phi = m.Phi(MachineRepresentation::kWord32, zero, zero);
   m.Branch(m.WordXor(phi, bt.param0), &body, &end);
 
   m.Bind(&body);
   phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1)));
   m.Goto(&header);
 
   m.Bind(&end);
   bt.AddReturn(phi);
 
   CHECK_EQ(11, bt.call(11, 0));
   CHECK_EQ(110, bt.call(110, 0));
   CHECK_EQ(176, bt.call(176, 0));
 }
 
 
 TEST(RunLoopIncrement2) {
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
 
   // x = 0; while(x < param) { x++; } return x;
   RawMachineLabel header, body, end;
   Node* zero = m.Int32Constant(0);
 
   m.Goto(&header);
 
   m.Bind(&header);
-  Node* phi = m.Phi(kMachInt32, zero, zero);
+  Node* phi = m.Phi(MachineRepresentation::kWord32, zero, zero);
   m.Branch(m.Int32LessThan(phi, bt.param0), &body, &end);
 
   m.Bind(&body);
   phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1)));
   m.Goto(&header);
 
   m.Bind(&end);
   bt.AddReturn(phi);
 
   CHECK_EQ(11, bt.call(11, 0));
   CHECK_EQ(110, bt.call(110, 0));
   CHECK_EQ(176, bt.call(176, 0));
   CHECK_EQ(0, bt.call(-200, 0));
 }
 
 
 TEST(RunLoopIncrement3) {
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
 
   // x = 0; while(x < param) { x++; } return x;
   RawMachineLabel header, body, end;
   Node* zero = m.Int32Constant(0);
 
   m.Goto(&header);
 
   m.Bind(&header);
-  Node* phi = m.Phi(kMachInt32, zero, zero);
+  Node* phi = m.Phi(MachineRepresentation::kWord32, zero, zero);
   m.Branch(m.Uint32LessThan(phi, bt.param0), &body, &end);
 
   m.Bind(&body);
   phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1)));
   m.Goto(&header);
 
   m.Bind(&end);
   bt.AddReturn(phi);
 
   CHECK_EQ(11, bt.call(11, 0));
   CHECK_EQ(110, bt.call(110, 0));
   CHECK_EQ(176, bt.call(176, 0));
   CHECK_EQ(200, bt.call(200, 0));
 }
 
 
 TEST(RunLoopDecrement) {
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
 
   // x = param; while(x) { x--; } return x;
   RawMachineLabel header, body, end;
 
   m.Goto(&header);
 
   m.Bind(&header);
-  Node* phi = m.Phi(kMachInt32, bt.param0, m.Int32Constant(0));
+  Node* phi =
+      m.Phi(MachineRepresentation::kWord32, bt.param0, m.Int32Constant(0));
   m.Branch(phi, &body, &end);
 
   m.Bind(&body);
   phi->ReplaceInput(1, m.Int32Sub(phi, m.Int32Constant(1)));
   m.Goto(&header);
 
   m.Bind(&end);
   bt.AddReturn(phi);
 
   CHECK_EQ(0, bt.call(11, 0));
   CHECK_EQ(0, bt.call(110, 0));
   CHECK_EQ(0, bt.call(197, 0));
 }
 
 
 TEST(RunLoopIncrementFloat32) {
   RawMachineAssemblerTester<int32_t> m;
 
   // x = -3.0f; while(x < 10f) { x = x + 0.5f; } return (int) (double) x;
   RawMachineLabel header, body, end;
   Node* minus_3 = m.Float32Constant(-3.0f);
   Node* ten = m.Float32Constant(10.0f);
 
   m.Goto(&header);
 
   m.Bind(&header);
-  Node* phi = m.Phi(kMachFloat32, minus_3, ten);
+  Node* phi = m.Phi(MachineRepresentation::kFloat32, minus_3, ten);
   m.Branch(m.Float32LessThan(phi, ten), &body, &end);
 
   m.Bind(&body);
   phi->ReplaceInput(1, m.Float32Add(phi, m.Float32Constant(0.5f)));
   m.Goto(&header);
 
   m.Bind(&end);
   m.Return(m.ChangeFloat64ToInt32(m.ChangeFloat32ToFloat64(phi)));
 
   CHECK_EQ(10, m.Call());
 }
 
 
 TEST(RunLoopIncrementFloat64) {
   RawMachineAssemblerTester<int32_t> m;
 
   // x = -3.0; while(x < 10) { x = x + 0.5; } return (int) x;
   RawMachineLabel header, body, end;
   Node* minus_3 = m.Float64Constant(-3.0);
   Node* ten = m.Float64Constant(10.0);
 
   m.Goto(&header);
 
   m.Bind(&header);
-  Node* phi = m.Phi(kMachFloat64, minus_3, ten);
+  Node* phi = m.Phi(MachineRepresentation::kFloat64, minus_3, ten);
   m.Branch(m.Float64LessThan(phi, ten), &body, &end);
 
   m.Bind(&body);
   phi->ReplaceInput(1, m.Float64Add(phi, m.Float64Constant(0.5)));
   m.Goto(&header);
 
   m.Bind(&end);
   m.Return(m.ChangeFloat64ToInt32(phi));
 
   CHECK_EQ(10, m.Call());
@@ skipping 17 matching lines @@
   m.Bind(&def);
   m.Goto(&end);
   m.Bind(&end);
   m.Return(m.Int32Constant(constant));
 
   CHECK_EQ(constant, m.Call());
 }
 
 
 TEST(RunSwitch2) {
-  RawMachineAssemblerTester<int32_t> m(kMachInt32);
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
 
   RawMachineLabel blocka, blockb, blockc;
   RawMachineLabel* case_labels[] = {&blocka, &blockb};
   int32_t case_values[] = {std::numeric_limits<int32_t>::min(),
                            std::numeric_limits<int32_t>::max()};
   m.Switch(m.Parameter(0), &blockc, case_values, case_labels,
            arraysize(case_labels));
   m.Bind(&blocka);
   m.Return(m.Int32Constant(-1));
   m.Bind(&blockb);
   m.Return(m.Int32Constant(1));
   m.Bind(&blockc);
   m.Return(m.Int32Constant(0));
 
   CHECK_EQ(1, m.Call(std::numeric_limits<int32_t>::max()));
   CHECK_EQ(-1, m.Call(std::numeric_limits<int32_t>::min()));
   for (int i = -100; i < 100; i += 25) {
     CHECK_EQ(0, m.Call(i));
   }
 }
 
 
 TEST(RunSwitch3) {
-  RawMachineAssemblerTester<int32_t> m(kMachInt32);
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
 
   RawMachineLabel blocka, blockb, blockc;
   RawMachineLabel* case_labels[] = {&blocka, &blockb};
   int32_t case_values[] = {std::numeric_limits<int32_t>::min() + 0,
                            std::numeric_limits<int32_t>::min() + 1};
   m.Switch(m.Parameter(0), &blockc, case_values, case_labels,
            arraysize(case_labels));
   m.Bind(&blocka);
   m.Return(m.Int32Constant(0));
   m.Bind(&blockb);
   m.Return(m.Int32Constant(1));
   m.Bind(&blockc);
   m.Return(m.Int32Constant(2));
 
   CHECK_EQ(0, m.Call(std::numeric_limits<int32_t>::min() + 0));
   CHECK_EQ(1, m.Call(std::numeric_limits<int32_t>::min() + 1));
   for (int i = -100; i < 100; i += 25) {
     CHECK_EQ(2, m.Call(i));
   }
 }
 
 
 TEST(RunSwitch4) {
-  RawMachineAssemblerTester<int32_t> m(kMachInt32);
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
 
   const size_t kNumCases = 512;
   const size_t kNumValues = kNumCases + 1;
   int32_t values[kNumValues];
   m.main_isolate()->random_number_generator()->NextBytes(values,
                                                          sizeof(values));
   RawMachineLabel end, def;
   int32_t case_values[kNumCases];
   RawMachineLabel* case_labels[kNumCases];
   Node* results[kNumValues];
   for (size_t i = 0; i < kNumCases; ++i) {
     case_values[i] = static_cast<int32_t>(i);
     case_labels[i] =
         new (m.main_zone()->New(sizeof(RawMachineLabel))) RawMachineLabel;
   }
   m.Switch(m.Parameter(0), &def, case_values, case_labels,
            arraysize(case_labels));
   for (size_t i = 0; i < kNumCases; ++i) {
     m.Bind(case_labels[i]);
     results[i] = m.Int32Constant(values[i]);
     m.Goto(&end);
   }
   m.Bind(&def);
   results[kNumCases] = m.Int32Constant(values[kNumCases]);
   m.Goto(&end);
   m.Bind(&end);
   const int num_results = static_cast<int>(arraysize(results));
   Node* phi =
-      m.AddNode(m.common()->Phi(kMachInt32, num_results), num_results, results);
+      m.AddNode(m.common()->Phi(MachineRepresentation::kWord32, num_results),
+                num_results, results);
   m.Return(phi);
 
   for (size_t i = 0; i < kNumValues; ++i) {
     CHECK_EQ(values[i], m.Call(static_cast<int>(i)));
   }
 }
 
 
 TEST(RunLoadInt32) {
   RawMachineAssemblerTester<int32_t> m;
 
   int32_t p1 = 0;  // loads directly from this location.
-  m.Return(m.LoadFromPointer(&p1, kMachInt32));
+  m.Return(m.LoadFromPointer(&p1, MachineType::Int32()));
 
   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 < arraysize(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, kMachInt32, offset));
+    m.Return(m.LoadFromPointer(pointer, MachineType::Int32(), offset));
 
     FOR_INT32_INPUTS(j) {
       p1 = *j;
       CHECK_EQ(p1, m.Call());
     }
   }
 }
 
 
 TEST(RunLoadStoreFloat32Offset) {
   float p1 = 0.0f;  // loads directly from this location.
   float p2 = 0.0f;  // 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(kMachFloat32, m.PointerConstant(from), m.IntPtrConstant(offset));
-    m.Store(kMachFloat32, m.PointerConstant(to), m.IntPtrConstant(offset), load,
-            kNoWriteBarrier);
+    Node* load = m.Load(MachineType::Float32(), m.PointerConstant(from),
+                        m.IntPtrConstant(offset));
+    m.Store(MachineType::Float32(), m.PointerConstant(to),
+            m.IntPtrConstant(offset), load, kNoWriteBarrier);
     m.Return(m.Int32Constant(magic));
 
     FOR_FLOAT32_INPUTS(j) {
       p1 = *j;
       p2 = *j - 5;
       CHECK_EQ(magic, m.Call());
       CheckDoubleEq(p1, p2);
     }
   }
 }
 
 
 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(kMachFloat64, m.PointerConstant(from), m.IntPtrConstant(offset));
-    m.Store(kMachFloat64, m.PointerConstant(to), m.IntPtrConstant(offset), load,
-            kNoWriteBarrier);
+    Node* load = m.Load(MachineType::Float64(), m.PointerConstant(from),
+                        m.IntPtrConstant(offset));
+    m.Store(MachineType::Float64(), m.PointerConstant(to),
+            m.IntPtrConstant(offset), load, kNoWriteBarrier);
     m.Return(m.Int32Constant(magic));
 
     FOR_FLOAT64_INPUTS(j) {
       p1 = *j;
       p2 = *j - 5;
       CHECK_EQ(magic, m.Call());
       CheckDoubleEq(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(RunInt32AddAndWord32EqualP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
     m.Return(m.Int32Add(m.Parameter(0),
                         m.Word32Equal(m.Parameter(1), m.Parameter(2))));
     FOR_INT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         FOR_INT32_INPUTS(k) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t const expected =
               bit_cast<int32_t>(bit_cast<uint32_t>(*i) + (*j == *k));
           CHECK_EQ(expected, m.Call(*i, *j, *k));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
     m.Return(m.Int32Add(m.Word32Equal(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
     FOR_INT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         FOR_INT32_INPUTS(k) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t const expected =
               bit_cast<int32_t>((*i == *j) + bit_cast<uint32_t>(*k));
           CHECK_EQ(expected, m.Call(*i, *j, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32AddAndWord32EqualImm) {
   {
     FOR_INT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
+                                           MachineType::Int32());
       m.Return(m.Int32Add(m.Int32Constant(*i),
                           m.Word32Equal(m.Parameter(0), m.Parameter(1))));
       FOR_INT32_INPUTS(j) {
         FOR_INT32_INPUTS(k) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t const expected =
               bit_cast<int32_t>(bit_cast<uint32_t>(*i) + (*j == *k));
           CHECK_EQ(expected, m.Call(*j, *k));
         }
       }
     }
   }
   {
     FOR_INT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
+                                           MachineType::Int32());
       m.Return(m.Int32Add(m.Word32Equal(m.Int32Constant(*i), m.Parameter(0)),
                           m.Parameter(1)));
       FOR_INT32_INPUTS(j) {
         FOR_INT32_INPUTS(k) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t const expected =
               bit_cast<int32_t>((*i == *j) + bit_cast<uint32_t>(*k));
           CHECK_EQ(expected, m.Call(*j, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32AddAndWord32NotEqualP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
     m.Return(m.Int32Add(m.Parameter(0),
                         m.Word32NotEqual(m.Parameter(1), m.Parameter(2))));
     FOR_INT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         FOR_INT32_INPUTS(k) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t const expected =
               bit_cast<int32_t>(bit_cast<uint32_t>(*i) + (*j != *k));
           CHECK_EQ(expected, m.Call(*i, *j, *k));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
     m.Return(m.Int32Add(m.Word32NotEqual(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
     FOR_INT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         FOR_INT32_INPUTS(k) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t const expected =
               bit_cast<int32_t>((*i != *j) + bit_cast<uint32_t>(*k));
           CHECK_EQ(expected, m.Call(*i, *j, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32AddAndWord32NotEqualImm) {
   {
     FOR_INT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
+                                           MachineType::Int32());
       m.Return(m.Int32Add(m.Int32Constant(*i),
                           m.Word32NotEqual(m.Parameter(0), m.Parameter(1))));
       FOR_INT32_INPUTS(j) {
         FOR_INT32_INPUTS(k) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t const expected =
               bit_cast<int32_t>(bit_cast<uint32_t>(*i) + (*j != *k));
           CHECK_EQ(expected, m.Call(*j, *k));
         }
       }
     }
   }
   {
     FOR_INT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
+                                           MachineType::Int32());
       m.Return(m.Int32Add(m.Word32NotEqual(m.Int32Constant(*i), m.Parameter(0)),
                           m.Parameter(1)));
       FOR_INT32_INPUTS(j) {
         FOR_INT32_INPUTS(k) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t const expected =
               bit_cast<int32_t>((*i != *j) + bit_cast<uint32_t>(*k));
           CHECK_EQ(expected, m.Call(*j, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32AddAndWord32SarP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
     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(kMachInt32, kMachUint32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Int32(), MachineType::Uint32(), MachineType::Uint32());
     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(kMachUint32, kMachInt32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
     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(kMachInt32, kMachUint32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Int32(), MachineType::Uint32(), MachineType::Uint32());
     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(kMachUint32, kMachUint32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
     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(kMachUint32, kMachUint32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
     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));
         }
       }
@@ skipping 35 matching lines @@
     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<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       RawMachineLabel 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) {
         uint32_t expected = (*i + *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       RawMachineLabel 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) {
         uint32_t expected = (*i + *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     const Operator* shops[] = {m.machine()->Word32Sar(),
                                m.machine()->Word32Shl(),
                                m.machine()->Word32Shr()};
     for (size_t n = 0; n < arraysize(shops); n++) {
-      RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
-                                           kMachUint32);
+      RawMachineAssemblerTester<int32_t> m(
+          MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
       RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Int32Add(m.Parameter(0),
                                         m.AddNode(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 44 matching lines @@
         m.Word32Equal(m.Int32Constant(0), m.Int32Add(bt.param0, bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i + *j) == 0;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(m.Word32Equal(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i + *j) == 0;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(m.Word32Equal(m.Int32Add(m.Parameter(0), m.Int32Constant(*i)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*j + *i) == 0;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     const Operator* shops[] = {m.machine()->Word32Sar(),
                                m.machine()->Word32Shl(),
                                m.machine()->Word32Shr()};
     for (size_t n = 0; n < arraysize(shops); n++) {
-      RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
-                                           kMachUint32);
+      RawMachineAssemblerTester<int32_t> m(
+          MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
       m.Return(m.Word32Equal(
           m.Int32Add(m.Parameter(0),
                      m.AddNode(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 29 matching lines @@
       uint32_t expected = static_cast<int32_t>(*i - *j);
       CHECK_EQ(expected, bt.call(*i, *j));
     }
   }
 }
 
 
 TEST(RunInt32SubImm) {
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *i - *j;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(m.Int32Sub(m.Parameter(0), m.Int32Constant(*i)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *j - *i;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
 }
 
 
 TEST(RunInt32SubAndWord32SarP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
     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) {
           int32_t expected = *i - (*j >> shift);
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachUint32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Int32(), MachineType::Uint32(), MachineType::Uint32());
     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) {
           int32_t expected = (*i >> shift) - *k;
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32SubAndWord32ShlP) {
   {
-    RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
     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) {
           int32_t expected = *i - (*j << shift);
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachUint32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Int32(), MachineType::Uint32(), MachineType::Uint32());
     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<uint32_t> m(kMachUint32, kMachUint32,
-                                          kMachUint32);
+    RawMachineAssemblerTester<uint32_t> m(
+        MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
     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.
           uint32_t expected = *i - (*j >> shift);
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<uint32_t> m(kMachUint32, kMachUint32,
-                                          kMachUint32);
+    RawMachineAssemblerTester<uint32_t> m(
+        MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
     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.
           uint32_t expected = (*i >> shift) - *k;
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
@@ skipping 35 matching lines @@
     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<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       RawMachineLabel 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) {
         uint32_t expected = (*i - *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachUint32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
       RawMachineLabel 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;
     const Operator* shops[] = {m.machine()->Word32Sar(),
                                m.machine()->Word32Shl(),
                                m.machine()->Word32Shr()};
     for (size_t n = 0; n < arraysize(shops); n++) {
-      RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
-                                           kMachUint32);
+      RawMachineAssemblerTester<int32_t> m(
+          MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
       RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Int32Sub(m.Parameter(0),
                                         m.AddNode(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 44 matching lines @@
         m.Word32Equal(m.Int32Constant(0), m.Int32Sub(bt.param0, bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i - *j) == 0;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(m.Word32Equal(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i - *j) == 0;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(m.Word32Equal(m.Int32Sub(m.Parameter(0), m.Int32Constant(*i)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*j - *i) == 0;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     const Operator* shops[] = {m.machine()->Word32Sar(),
                                m.machine()->Word32Shl(),
                                m.machine()->Word32Shr()};
     for (size_t n = 0; n < arraysize(shops); n++) {
-      RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
-                                           kMachUint32);
+      RawMachineAssemblerTester<int32_t> m(
+          MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
       m.Return(m.Word32Equal(
           m.Int32Sub(m.Parameter(0),
                      m.AddNode(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 54 matching lines @@
           (static_cast<int64_t>(*i) * static_cast<int64_t>(*j)) >> 32);
       CHECK_EQ(expected, bt.call(*i, *j));
     }
   }
 }
 
 
 TEST(RunInt32MulImm) {
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(m.Int32Mul(m.Int32Constant(*i), m.Parameter(0)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *i * *j;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(m.Int32Mul(m.Parameter(0), m.Int32Constant(*i)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *j * *i;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
 }
 
 
 TEST(RunInt32MulAndInt32AddP) {
   {
     FOR_INT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
-        RawMachineAssemblerTester<int32_t> m(kMachInt32);
+        RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
         int32_t p0 = *i;
         int32_t p1 = *j;
         m.Return(m.Int32Add(m.Int32Constant(p0),
                             m.Int32Mul(m.Parameter(0), m.Int32Constant(p1))));
         FOR_INT32_INPUTS(k) {
           int32_t p2 = *k;
           int expected = p0 + static_cast<int32_t>(p1 * p2);
           CHECK_EQ(expected, m.Call(p2));
         }
       }
     }
   }
   {
-    RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
     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(kMachInt32, kMachInt32, kMachInt32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
     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(kMachUint32, kMachInt32, kMachInt32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Uint32(), MachineType::Int32(), MachineType::Int32());
     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 289 matching lines @@
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
 }
 
 
 TEST(RunWord32AndImm) {
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       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));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       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));
       }
     }
   }
 }
 
 
@@ skipping 30 matching lines @@
     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(kMachUint32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
       RawMachineLabel 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(kMachUint32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
       RawMachineLabel 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;
     const Operator* shops[] = {m.machine()->Word32Sar(),
                                m.machine()->Word32Shl(),
                                m.machine()->Word32Shr()};
     for (size_t n = 0; n < arraysize(shops); n++) {
-      RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
-                                           kMachUint32);
+      RawMachineAssemblerTester<int32_t> m(
+          MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
       RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32And(m.Parameter(0),
                                          m.AddNode(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 44 matching lines @@
         m.Word32Equal(m.Int32Constant(0), m.Word32And(bt.param0, bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i & *j) == 0;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(m.Word32Equal(m.Word32And(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i & *j) == 0;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(m.Word32Equal(m.Word32And(m.Parameter(0), m.Int32Constant(*i)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*j & *i) == 0;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
 }
 
@@ skipping 31 matching lines @@
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
 }
 
 
 TEST(RunWord32OrImm) {
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       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));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       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));
       }
     }
   }
 }
 
 
@@ skipping 30 matching lines @@
     bt.AddReturn(m.Int32Constant(0 - constant));
     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_INT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachInt32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
       RawMachineLabel 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_INT32_INPUTS(j) {
         int32_t expected = (*i | *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_INT32_INPUTS(i) {
-      RawMachineAssemblerTester<int32_t> m(kMachInt32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
       RawMachineLabel 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_INT32_INPUTS(j) {
         int32_t expected = (*i | *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     const Operator* shops[] = {m.machine()->Word32Sar(),
                                m.machine()->Word32Shl(),
                                m.machine()->Word32Shr()};
     for (size_t n = 0; n < arraysize(shops); n++) {
-      RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
-                                           kMachUint32);
+      RawMachineAssemblerTester<int32_t> m(
+          MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
       RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32Or(m.Parameter(0),
                                         m.AddNode(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 44 matching lines @@
         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<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(m.Word32Equal(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i | *j) == 0;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(m.Word32Equal(m.Word32Or(m.Parameter(0), m.Int32Constant(*i)),
                              m.Int32Constant(0)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*j | *i) == 0;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
 }
 
 
 TEST(RunWord32XorP) {
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       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));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Uint32BinopTester bt(&m);
@@ skipping 22 matching lines @@
     bt.AddReturn(m.Word32Xor(m.Word32Not(bt.param0), bt.param1));
     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<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       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));
       }
     }
   }
 }
 
 
@@ skipping 30 matching lines @@
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       RawMachineLabel 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) {
         uint32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       RawMachineLabel 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) {
         uint32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     const Operator* shops[] = {m.machine()->Word32Sar(),
                                m.machine()->Word32Shl(),
                                m.machine()->Word32Shr()};
     for (size_t n = 0; n < arraysize(shops); n++) {
-      RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
-                                           kMachUint32);
+      RawMachineAssemblerTester<int32_t> m(
+          MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32());
       RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32Xor(m.Parameter(0),
                                          m.AddNode(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<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       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));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Uint32BinopTester bt(&m);
@@ skipping 28 matching lines @@
         m.Word32Equal(m.Int32Constant(0), m.Word32Shl(bt.param0, bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_SHIFTS(shift) {
         uint32_t expected = 0 == (*i << shift);
         CHECK_EQ(expected, bt.call(*i, shift));
       }
     }
   }
   {
     FOR_UINT32_SHIFTS(shift) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(
           m.Word32Equal(m.Int32Constant(0),
                         m.Word32Shl(m.Parameter(0), m.Int32Constant(shift))));
       FOR_UINT32_INPUTS(i) {
         uint32_t expected = 0 == (*i << shift);
         CHECK_EQ(expected, m.Call(*i));
       }
     }
   }
   {
     FOR_UINT32_SHIFTS(shift) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(
           m.Word32Equal(m.Word32Shl(m.Parameter(0), m.Int32Constant(shift)),
                         m.Int32Constant(0)));
       FOR_UINT32_INPUTS(i) {
         uint32_t expected = 0 == (*i << shift);
         CHECK_EQ(expected, m.Call(*i));
       }
     }
   }
 }
 
 
 TEST(RunWord32ShrP) {
   {
     FOR_UINT32_SHIFTS(shift) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       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));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Uint32BinopTester bt(&m);
@@ skipping 29 matching lines @@
         m.Word32Equal(m.Int32Constant(0), m.Word32Shr(bt.param0, bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_SHIFTS(shift) {
         uint32_t expected = 0 == (*i >> shift);
         CHECK_EQ(expected, bt.call(*i, shift));
       }
     }
   }
   {
     FOR_UINT32_SHIFTS(shift) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(
           m.Word32Equal(m.Int32Constant(0),
                         m.Word32Shr(m.Parameter(0), m.Int32Constant(shift))));
       FOR_UINT32_INPUTS(i) {
         uint32_t expected = 0 == (*i >> shift);
         CHECK_EQ(expected, m.Call(*i));
       }
     }
   }
   {
     FOR_UINT32_SHIFTS(shift) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(
           m.Word32Equal(m.Word32Shr(m.Parameter(0), m.Int32Constant(shift)),
                         m.Int32Constant(0)));
       FOR_UINT32_INPUTS(i) {
         uint32_t expected = 0 == (*i >> shift);
         CHECK_EQ(expected, m.Call(*i));
       }
     }
   }
 }
 
 
 TEST(RunWord32SarP) {
   {
     FOR_INT32_SHIFTS(shift) {
-      RawMachineAssemblerTester<int32_t> m(kMachInt32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
       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);
@@ skipping 29 matching lines @@
         m.Word32Equal(m.Int32Constant(0), m.Word32Sar(bt.param0, bt.param1)));
     FOR_INT32_INPUTS(i) {
       FOR_INT32_SHIFTS(shift) {
         int32_t expected = 0 == (*i >> shift);
         CHECK_EQ(expected, bt.call(*i, shift));
       }
     }
   }
   {
     FOR_INT32_SHIFTS(shift) {
-      RawMachineAssemblerTester<int32_t> m(kMachInt32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
       m.Return(
           m.Word32Equal(m.Int32Constant(0),
                         m.Word32Sar(m.Parameter(0), m.Int32Constant(shift))));
       FOR_INT32_INPUTS(i) {
         int32_t expected = 0 == (*i >> shift);
         CHECK_EQ(expected, m.Call(*i));
       }
     }
   }
   {
     FOR_INT32_SHIFTS(shift) {
-      RawMachineAssemblerTester<int32_t> m(kMachInt32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
       m.Return(
           m.Word32Equal(m.Word32Sar(m.Parameter(0), m.Int32Constant(shift)),
                         m.Int32Constant(0)));
       FOR_INT32_INPUTS(i) {
         int32_t expected = 0 == (*i >> shift);
         CHECK_EQ(expected, m.Call(*i));
       }
     }
   }
 }
 
 
 TEST(RunWord32RorP) {
   {
     FOR_UINT32_SHIFTS(shift) {
-      RawMachineAssemblerTester<int32_t> m(kMachUint32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
       m.Return(m.Word32Ror(m.Parameter(0), m.Int32Constant(shift)));
       FOR_UINT32_INPUTS(j) {
         int32_t expected = bits::RotateRight32(*j, shift);
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Uint32BinopTester bt(&m);
@@ skipping 28 matching lines @@
         m.Word32Equal(m.Int32Constant(0), m.Word32Ror(bt.param0, bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_SHIFTS(shift) {
         uint32_t expected = 0 == bits::RotateRight32(*i, shift);
         CHECK_EQ(expected, bt.call(*i, shift));
       }
     }
   }
   {
     FOR_UINT32_SHIFTS(shift) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(
           m.Word32Equal(m.Int32Constant(0),
                         m.Word32Ror(m.Parameter(0), m.Int32Constant(shift))));
       FOR_UINT32_INPUTS(i) {
         uint32_t expected = 0 == bits::RotateRight32(*i, shift);
         CHECK_EQ(expected, m.Call(*i));
       }
     }
   }
   {
     FOR_UINT32_SHIFTS(shift) {
-      RawMachineAssemblerTester<uint32_t> m(kMachUint32);
+      RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
       m.Return(
           m.Word32Equal(m.Word32Ror(m.Parameter(0), m.Int32Constant(shift)),
                         m.Int32Constant(0)));
       FOR_UINT32_INPUTS(i) {
         uint32_t expected = 0 == bits::RotateRight32(*i, shift);
         CHECK_EQ(expected, m.Call(*i));
       }
     }
   }
 }
 
 
 TEST(RunWord32NotP) {
-  RawMachineAssemblerTester<int32_t> m(kMachInt32);
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
   m.Return(m.Word32Not(m.Parameter(0)));
   FOR_INT32_INPUTS(i) {
     int expected = ~(*i);
     CHECK_EQ(expected, m.Call(*i));
   }
 }
 
 
 TEST(RunInt32NegP) {
-  RawMachineAssemblerTester<int32_t> m(kMachInt32);
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
   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(kMachInt32, kMachInt32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Int32(), MachineType::Int32(), MachineType::Uint32());
     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(kMachInt32, kMachUint32, kMachInt32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Int32(), MachineType::Uint32(), MachineType::Int32());
     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(kMachUint32, kMachUint32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
     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(kMachUint32, kMachUint32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
     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(kMachUint32, kMachUint32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
     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(kMachUint32, kMachUint32, kMachUint32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
     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 ? kMachInt32 : kMachNone);
+    RawMachineAssemblerTester<int32_t> m(i == 5 ? MachineType::Int32()
+                                                : MachineType::None());
     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, kMachInt32);
+        m.LoadFromPointer(&constant, MachineType::Int32());
         break;
       case 5:
         m.Parameter(0);
         break;
       default:
         return;
     }
     m.Return(m.Int32Constant(constant));
     if (i != 5) {
       CHECK_EQ(constant, m.Call());
@@ skipping 14 matching lines @@
       m.machine()->Word32Ror(),            m.machine()->Word32Equal(),
       m.machine()->Int32Add(),             m.machine()->Int32Sub(),
       m.machine()->Int32Mul(),             m.machine()->Int32MulHigh(),
       m.machine()->Int32Div(),             m.machine()->Uint32Div(),
       m.machine()->Int32Mod(),             m.machine()->Uint32Mod(),
       m.machine()->Uint32MulHigh(),        m.machine()->Int32LessThan(),
       m.machine()->Int32LessThanOrEqual(), m.machine()->Uint32LessThan(),
       m.machine()->Uint32LessThanOrEqual()};
 
   for (size_t i = 0; i < arraysize(kOps); ++i) {
-    RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
+    RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
+                                         MachineType::Int32());
     int32_t constant = static_cast<int32_t>(0x55555 + i);
     m.AddNode(kOps[i], m.Parameter(0), m.Parameter(1));
     m.Return(m.Int32Constant(constant));
 
     CHECK_EQ(constant, m.Call(1, 1));
   }
 }
 
 
 template <typename Type>
@@ skipping 17 matching lines @@
 
       Type expected = buffer[i];
       Type actual = m.Call();
       CHECK(expected == actual);
     }
   }
 }
 
 
 TEST(RunLoadImmIndex) {
-  RunLoadImmIndex<int8_t>(kMachInt8);
-  RunLoadImmIndex<uint8_t>(kMachUint8);
-  RunLoadImmIndex<int16_t>(kMachInt16);
-  RunLoadImmIndex<uint16_t>(kMachUint16);
-  RunLoadImmIndex<int32_t>(kMachInt32);
-  RunLoadImmIndex<uint32_t>(kMachUint32);
-  RunLoadImmIndex<int32_t*>(kMachAnyTagged);
+  RunLoadImmIndex<int8_t>(MachineType::Int8());
+  RunLoadImmIndex<uint8_t>(MachineType::Uint8());
+  RunLoadImmIndex<int16_t>(MachineType::Int16());
+  RunLoadImmIndex<uint16_t>(MachineType::Uint16());
+  RunLoadImmIndex<int32_t>(MachineType::Int32());
+  RunLoadImmIndex<uint32_t>(MachineType::Uint32());
+  RunLoadImmIndex<int32_t*>(MachineType::AnyTagged());
 
   // TODO(titzer): test kRepBit loads
-  // TODO(titzer): test kMachFloat64 loads
+  // TODO(titzer): test MachineType::Float64() 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(buffer[x] != buffer[y]);
     CHECK_EQ(OK, m.Call());
     CHECK(buffer[x] == buffer[y]);
   }
 }
 
 
 TEST(RunLoadStore) {
-  RunLoadStore<int8_t>(kMachInt8);
-  RunLoadStore<uint8_t>(kMachUint8);
-  RunLoadStore<int16_t>(kMachInt16);
-  RunLoadStore<uint16_t>(kMachUint16);
-  RunLoadStore<int32_t>(kMachInt32);
-  RunLoadStore<uint32_t>(kMachUint32);
-  RunLoadStore<void*>(kMachAnyTagged);
-  RunLoadStore<float>(kMachFloat32);
-  RunLoadStore<double>(kMachFloat64);
+  RunLoadStore<int8_t>(MachineType::Int8());
+  RunLoadStore<uint8_t>(MachineType::Uint8());
+  RunLoadStore<int16_t>(MachineType::Int16());
+  RunLoadStore<uint16_t>(MachineType::Uint16());
+  RunLoadStore<int32_t>(MachineType::Int32());
+  RunLoadStore<uint32_t>(MachineType::Uint32());
+  RunLoadStore<void*>(MachineType::AnyTagged());
+  RunLoadStore<float>(MachineType::Float32());
+  RunLoadStore<double>(MachineType::Float64());
 }
 
 
 TEST(RunFloat32Add) {
-  BufferedRawMachineAssemblerTester<float> m(kMachFloat32, kMachFloat32);
+  BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
+                                             MachineType::Float32());
   m.Return(m.Float32Add(m.Parameter(0), m.Parameter(1)));
 
   FOR_FLOAT32_INPUTS(i) {
     FOR_FLOAT32_INPUTS(j) {
       volatile float expected = *i + *j;
       CheckFloatEq(expected, m.Call(*i, *j));
     }
   }
 }
 
 
 TEST(RunFloat32Sub) {
-  BufferedRawMachineAssemblerTester<float> m(kMachFloat32, kMachFloat32);
+  BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
+                                             MachineType::Float32());
   m.Return(m.Float32Sub(m.Parameter(0), m.Parameter(1)));
 
   FOR_FLOAT32_INPUTS(i) {
     FOR_FLOAT32_INPUTS(j) {
       volatile float expected = *i - *j;
       CheckFloatEq(expected, m.Call(*i, *j));
     }
   }
 }
 
 
 TEST(RunFloat32Mul) {
-  BufferedRawMachineAssemblerTester<float> m(kMachFloat32, kMachFloat32);
+  BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
+                                             MachineType::Float32());
   m.Return(m.Float32Mul(m.Parameter(0), m.Parameter(1)));
 
   FOR_FLOAT32_INPUTS(i) {
     FOR_FLOAT32_INPUTS(j) {
       volatile float expected = *i * *j;
       CheckFloatEq(expected, m.Call(*i, *j));
     }
   }
 }
 
 
 TEST(RunFloat32Div) {
-  BufferedRawMachineAssemblerTester<float> m(kMachFloat32, kMachFloat32);
+  BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
+                                             MachineType::Float32());
   m.Return(m.Float32Div(m.Parameter(0), m.Parameter(1)));
 
   FOR_FLOAT32_INPUTS(i) {
     FOR_FLOAT32_INPUTS(j) {
       volatile float expected = *i / *j;
       CheckFloatEq(expected, m.Call(*i, *j));
     }
   }
 }
 
 
 TEST(RunFloat64Add) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64, kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
+                                              MachineType::Float64());
   m.Return(m.Float64Add(m.Parameter(0), m.Parameter(1)));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) { CheckDoubleEq(*i + *j, m.Call(*i, *j)); }
   }
 }
 
 
 TEST(RunFloat64Sub) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64, kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
+                                              MachineType::Float64());
   m.Return(m.Float64Sub(m.Parameter(0), m.Parameter(1)));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) { CheckDoubleEq(*i - *j, m.Call(*i, *j)); }
   }
 }
 
 
 TEST(RunFloat64Mul) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64, kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
+                                              MachineType::Float64());
   m.Return(m.Float64Mul(m.Parameter(0), m.Parameter(1)));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) {
       volatile double expected = *i * *j;
       CheckDoubleEq(expected, m.Call(*i, *j));
     }
   }
 }
 
 
 TEST(RunFloat64Div) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64, kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
+                                              MachineType::Float64());
   m.Return(m.Float64Div(m.Parameter(0), m.Parameter(1)));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) {
       volatile double expected = *i / *j;
       CheckDoubleEq(expected, m.Call(*i, *j));
     }
   }
 }
 
 
 TEST(RunFloat64Mod) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64, kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
+                                              MachineType::Float64());
   m.Return(m.Float64Mod(m.Parameter(0), m.Parameter(1)));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) { CheckDoubleEq(modulo(*i, *j), m.Call(*i, *j)); }
   }
 }
 
 
 TEST(RunDeadFloat32Binops) {
   RawMachineAssemblerTester<int32_t> m;
@@ skipping 133 matching lines @@
     FOR_FLOAT32_INPUTS(pr) {
       float expected = *pl - *pr;
       CheckFloatEq(expected, bt.call(*pl, *pr));
     }
   }
 }
 
 
 TEST(RunFloat32SubImm1) {
   FOR_FLOAT32_INPUTS(i) {
-    BufferedRawMachineAssemblerTester<float> m(kMachFloat32);
+    BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
     m.Return(m.Float32Sub(m.Float32Constant(*i), m.Parameter(0)));
 
     FOR_FLOAT32_INPUTS(j) {
       volatile float expected = *i - *j;
       CheckFloatEq(expected, m.Call(*j));
     }
   }
 }
 
 
 TEST(RunFloat32SubImm2) {
   FOR_FLOAT32_INPUTS(i) {
-    BufferedRawMachineAssemblerTester<float> m(kMachFloat32);
+    BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
     m.Return(m.Float32Sub(m.Parameter(0), m.Float32Constant(*i)));
 
     FOR_FLOAT32_INPUTS(j) {
       volatile float expected = *j - *i;
       CheckFloatEq(expected, m.Call(*j));
     }
   }
 }
 
 
 TEST(RunFloat64SubImm1) {
   FOR_FLOAT64_INPUTS(i) {
-    BufferedRawMachineAssemblerTester<double> m(kMachFloat64);
+    BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
     m.Return(m.Float64Sub(m.Float64Constant(*i), m.Parameter(0)));
 
     FOR_FLOAT64_INPUTS(j) { CheckFloatEq(*i - *j, m.Call(*j)); }
   }
 }
 
 
 TEST(RunFloat64SubImm2) {
   FOR_FLOAT64_INPUTS(i) {
-    BufferedRawMachineAssemblerTester<double> m(kMachFloat64);
+    BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
     m.Return(m.Float64Sub(m.Parameter(0), m.Float64Constant(*i)));
 
     FOR_FLOAT64_INPUTS(j) { CheckFloatEq(*j - *i, m.Call(*j)); }
   }
 }
 
 
 TEST(RunFloat64SubP) {
   RawMachineAssemblerTester<int32_t> m;
   Float64BinopTester bt(&m);
@@ skipping 33 matching lines @@
   FOR_FLOAT64_INPUTS(pl) {
     FOR_FLOAT64_INPUTS(pr) {
       double expected = *pl * *pr;
       CheckDoubleEq(expected, bt.call(*pl, *pr));
     }
   }
 }
 
 
 TEST(RunFloat64MulAndFloat64Add1) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64, kMachFloat64,
-                                              kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(
+      MachineType::Float64(), MachineType::Float64(), MachineType::Float64());
   m.Return(m.Float64Add(m.Float64Mul(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) {
       FOR_FLOAT64_INPUTS(k) {
         CheckDoubleEq((*i * *j) + *k, m.Call(*i, *j, *k));
       }
     }
   }
 }
 
 
 TEST(RunFloat64MulAndFloat64Add2) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64, kMachFloat64,
-                                              kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(
+      MachineType::Float64(), MachineType::Float64(), MachineType::Float64());
   m.Return(m.Float64Add(m.Parameter(0),
                         m.Float64Mul(m.Parameter(1), m.Parameter(2))));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) {
       FOR_FLOAT64_INPUTS(k) {
         CheckDoubleEq(*i + (*j * *k), m.Call(*i, *j, *k));
       }
     }
   }
 }
 
 
 TEST(RunFloat64MulAndFloat64Sub1) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64, kMachFloat64,
-                                              kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(
+      MachineType::Float64(), MachineType::Float64(), MachineType::Float64());
   m.Return(m.Float64Sub(m.Float64Mul(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) {
       FOR_FLOAT64_INPUTS(k) {
         CheckDoubleEq((*i * *j) - *k, m.Call(*i, *j, *k));
       }
     }
   }
 }
 
 
 TEST(RunFloat64MulAndFloat64Sub2) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64, kMachFloat64,
-                                              kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(
+      MachineType::Float64(), MachineType::Float64(), MachineType::Float64());
   m.Return(m.Float64Sub(m.Parameter(0),
                         m.Float64Mul(m.Parameter(1), m.Parameter(2))));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) {
       FOR_FLOAT64_INPUTS(k) {
         CheckDoubleEq(*i - (*j * *k), m.Call(*i, *j, *k));
       }
     }
   }
 }
 
 
 TEST(RunFloat64MulImm1) {
   FOR_FLOAT64_INPUTS(i) {
-    BufferedRawMachineAssemblerTester<double> m(kMachFloat64);
+    BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
     m.Return(m.Float64Mul(m.Float64Constant(*i), m.Parameter(0)));
 
     FOR_FLOAT64_INPUTS(j) { CheckFloatEq(*i * *j, m.Call(*j)); }
   }
 }
 
 
 TEST(RunFloat64MulImm2) {
   FOR_FLOAT64_INPUTS(i) {
-    BufferedRawMachineAssemblerTester<double> m(kMachFloat64);
+    BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
     m.Return(m.Float64Mul(m.Parameter(0), m.Float64Constant(*i)));
 
     FOR_FLOAT64_INPUTS(j) { CheckFloatEq(*j * *i, m.Call(*j)); }
   }
 }
 
 
 TEST(RunFloat32DivP) {
   RawMachineAssemblerTester<int32_t> m;
   Float32BinopTester bt(&m);
@@ skipping 42 matching lines @@
 
 TEST(RunChangeInt32ToFloat64_A) {
   int32_t magic = 0x986234;
   BufferedRawMachineAssemblerTester<double> m;
   m.Return(m.ChangeInt32ToFloat64(m.Int32Constant(magic)));
   CheckDoubleEq(static_cast<double>(magic), m.Call());
 }
 
 
 TEST(RunChangeInt32ToFloat64_B) {
-  BufferedRawMachineAssemblerTester<double> m(kMachInt32);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Int32());
   m.Return(m.ChangeInt32ToFloat64(m.Parameter(0)));
 
   FOR_INT32_INPUTS(i) { CheckDoubleEq(static_cast<double>(*i), m.Call(*i)); }
 }
 
 
 TEST(RunChangeUint32ToFloat64) {
-  BufferedRawMachineAssemblerTester<double> m(kMachUint32);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Uint32());
   m.Return(m.ChangeUint32ToFloat64(m.Parameter(0)));
 
   FOR_UINT32_INPUTS(i) { CheckDoubleEq(static_cast<double>(*i), m.Call(*i)); }
 }
 
 
 TEST(RunChangeFloat64ToInt32_A) {
   BufferedRawMachineAssemblerTester<int32_t> m;
   double magic = 11.1;
   m.Return(m.ChangeFloat64ToInt32(m.Float64Constant(magic)));
   CHECK_EQ(static_cast<int32_t>(magic), m.Call());
 }
 
 
 TEST(RunChangeFloat64ToInt32_B) {
-  BufferedRawMachineAssemblerTester<int32_t> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Float64());
   m.Return(m.ChangeFloat64ToInt32(m.Parameter(0)));
 
   // Note we don't check fractional inputs, or inputs outside the range of
   // int32, because these Convert operators really should be Change operators.
   FOR_INT32_INPUTS(i) { CHECK_EQ(*i, m.Call(static_cast<double>(*i))); }
 
   for (int32_t n = 1; n < 31; ++n) {
     CHECK_EQ(1 << n, m.Call(static_cast<double>(1 << n)));
   }
 
   for (int32_t n = 1; n < 31; ++n) {
     CHECK_EQ(3 << n, m.Call(static_cast<double>(3 << n)));
   }
 }
 
 
 TEST(RunChangeFloat64ToUint32) {
-  BufferedRawMachineAssemblerTester<uint32_t> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Float64());
   m.Return(m.ChangeFloat64ToUint32(m.Parameter(0)));
 
   {
     FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, m.Call(static_cast<double>(*i))); }
   }
 
   // Check various powers of 2.
   for (int32_t n = 1; n < 31; ++n) {
     { CHECK_EQ(1u << n, m.Call(static_cast<double>(1u << n))); }
 
     { CHECK_EQ(3u << n, m.Call(static_cast<double>(3u << n))); }
   }
   // Note we don't check fractional inputs, because these Convert operators
   // really should be Change operators.
 }
 
 
 TEST(RunTruncateFloat64ToFloat32) {
-  BufferedRawMachineAssemblerTester<float> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<float> m(MachineType::Float64());
 
   m.Return(m.TruncateFloat64ToFloat32(m.Parameter(0)));
 
   FOR_FLOAT64_INPUTS(i) { CheckFloatEq(DoubleToFloat32(*i), m.Call(*i)); }
 }
 
 
 TEST(RunDeadChangeFloat64ToInt32) {
   RawMachineAssemblerTester<int32_t> m;
   const int magic = 0x88abcda4;
@@ skipping 15 matching lines @@
 TEST(RunLoopPhiInduction2) {
   RawMachineAssemblerTester<int32_t> m;
 
   int false_val = 0x10777;
 
   // x = false_val; while(false) { x++; } return x;
   RawMachineLabel header, body, end;
   Node* false_node = m.Int32Constant(false_val);
   m.Goto(&header);
   m.Bind(&header);
-  Node* phi = m.Phi(kMachInt32, false_node, false_node);
+  Node* phi = m.Phi(MachineRepresentation::kWord32, false_node, false_node);
   m.Branch(m.Int32Constant(0), &body, &end);
   m.Bind(&body);
   Node* add = m.Int32Add(phi, m.Int32Constant(1));
   phi->ReplaceInput(1, add);
   m.Goto(&header);
   m.Bind(&end);
   m.Return(phi);
 
   CHECK_EQ(false_val, m.Call());
 }
 
 
 TEST(RunFloatDiamond) {
   RawMachineAssemblerTester<int32_t> m;
 
   const int magic = 99645;
   float buffer = 0.1f;
   float constant = 99.99f;
 
   RawMachineLabel blocka, blockb, end;
   Node* k1 = m.Float32Constant(constant);
   Node* k2 = m.Float32Constant(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(kMachFloat32, k2, k1);
-  m.Store(kMachFloat32, m.PointerConstant(&buffer), m.IntPtrConstant(0), phi,
-          kNoWriteBarrier);
+  Node* phi = m.Phi(MachineRepresentation::kFloat32, k2, k1);
+  m.Store(MachineType::Float32(), m.PointerConstant(&buffer),
+          m.IntPtrConstant(0), phi, kNoWriteBarrier);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK(constant == buffer);
 }
 
 
 TEST(RunDoubleDiamond) {
   RawMachineAssemblerTester<int32_t> m;
 
   const int magic = 99645;
   double buffer = 0.1;
   double constant = 99.99;
 
   RawMachineLabel 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(kMachFloat64, k2, k1);
-  m.Store(kMachFloat64, m.PointerConstant(&buffer), m.Int32Constant(0), phi,
-          kNoWriteBarrier);
+  Node* phi = m.Phi(MachineRepresentation::kFloat64, k2, k1);
+  m.Store(MachineType::Float64(), m.PointerConstant(&buffer),
+          m.Int32Constant(0), phi, kNoWriteBarrier);
   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;
 
   RawMachineLabel 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(kMachAnyTagged, k2, k1);
-  m.Store(kMachAnyTagged, m.PointerConstant(&buffer), m.Int32Constant(0), phi,
-          kNoWriteBarrier);
+  Node* phi = m.Phi(MachineRepresentation::kTagged, k2, k1);
+  m.Store(MachineType::AnyTagged(), m.PointerConstant(&buffer),
+          m.Int32Constant(0), phi, kNoWriteBarrier);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK(rexpected->SameValue(buffer));
 }
 
 
 TEST(RunDoubleRefDiamond) {
   RawMachineAssemblerTester<int32_t> m;
 
   const int magic = 99648;
   double dbuffer = 0.1;
   double dconstant = 99.99;
   Handle<String> rexpected =
       CcTest::i_isolate()->factory()->InternalizeUtf8String("AX");
   String* rbuffer;
 
   RawMachineLabel blocka, blockb, end;
   Node* d1 = m.Float64Constant(dconstant);
   Node* d2 = m.Float64Constant(0 - dconstant);
   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(kMachFloat64, d2, d1);
-  Node* rphi = m.Phi(kMachAnyTagged, r2, r1);
-  m.Store(kMachFloat64, m.PointerConstant(&dbuffer), m.Int32Constant(0), dphi,
-          kNoWriteBarrier);
-  m.Store(kMachAnyTagged, m.PointerConstant(&rbuffer), m.Int32Constant(0), rphi,
-          kNoWriteBarrier);
+  Node* dphi = m.Phi(MachineRepresentation::kFloat64, d2, d1);
+  Node* rphi = m.Phi(MachineRepresentation::kTagged, r2, r1);
+  m.Store(MachineType::Float64(), m.PointerConstant(&dbuffer),
+          m.Int32Constant(0), dphi, kNoWriteBarrier);
+  m.Store(MachineType::AnyTagged(), m.PointerConstant(&rbuffer),
+          m.Int32Constant(0), rphi, kNoWriteBarrier);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(dconstant, dbuffer);
   CHECK(rexpected->SameValue(rbuffer));
 }
 
 
 TEST(RunDoubleRefDoubleDiamond) {
   RawMachineAssemblerTester<int32_t> m;
 
   const int magic = 99649;
   double dbuffer = 0.1;
   double dconstant = 99.997;
   Handle<String> rexpected =
       CcTest::i_isolate()->factory()->InternalizeUtf8String("AD");
   String* rbuffer;
 
   RawMachineLabel blocka, blockb, mid, blockd, blocke, end;
   Node* d1 = m.Float64Constant(dconstant);
   Node* d2 = m.Float64Constant(0 - dconstant);
   Node* r1 = m.StringConstant("AD");
   Node* r2 = m.StringConstant("BD");
   m.Branch(m.Int32Constant(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&mid);
   m.Bind(&blockb);
   m.Goto(&mid);
   m.Bind(&mid);
-  Node* dphi1 = m.Phi(kMachFloat64, d2, d1);
-  Node* rphi1 = m.Phi(kMachAnyTagged, r2, r1);
+  Node* dphi1 = m.Phi(MachineRepresentation::kFloat64, d2, d1);
+  Node* rphi1 = m.Phi(MachineRepresentation::kTagged, r2, r1);
   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(kMachFloat64, d1, dphi1);
-  Node* rphi2 = m.Phi(kMachAnyTagged, r1, rphi1);
+  Node* dphi2 = m.Phi(MachineRepresentation::kFloat64, d1, dphi1);
+  Node* rphi2 = m.Phi(MachineRepresentation::kTagged, r1, rphi1);
 
-  m.Store(kMachFloat64, m.PointerConstant(&dbuffer), m.Int32Constant(0), dphi2,
-          kNoWriteBarrier);
-  m.Store(kMachAnyTagged, m.PointerConstant(&rbuffer), m.Int32Constant(0),
-          rphi2, kNoWriteBarrier);
+  m.Store(MachineType::Float64(), m.PointerConstant(&dbuffer),
+          m.Int32Constant(0), dphi2, kNoWriteBarrier);
+  m.Store(MachineType::AnyTagged(), m.PointerConstant(&rbuffer),
+          m.Int32Constant(0), rphi2, kNoWriteBarrier);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(dconstant, dbuffer);
   CHECK(rexpected->SameValue(rbuffer));
 }
 
 
 TEST(RunDoubleLoopPhi) {
   RawMachineAssemblerTester<int32_t> m;
   RawMachineLabel 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(kMachFloat64, dk, dk);
+  Node* phi = m.Phi(MachineRepresentation::kFloat64, dk, dk);
   phi->ReplaceInput(1, phi);
   m.Branch(zero, &body, &end);
   m.Bind(&body);
   m.Goto(&header);
   m.Bind(&end);
-  m.Store(kMachFloat64, m.PointerConstant(&buffer), m.Int32Constant(0), phi,
-          kNoWriteBarrier);
+  m.Store(MachineType::Float64(), m.PointerConstant(&buffer),
+          m.Int32Constant(0), phi, kNoWriteBarrier);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
 }
 
 
 TEST(RunCountToTenAccRaw) {
   RawMachineAssemblerTester<int32_t> m;
 
   Node* zero = m.Int32Constant(0);
   Node* ten = m.Int32Constant(10);
   Node* one = m.Int32Constant(1);
 
   RawMachineLabel header, body, body_cont, end;
 
   m.Goto(&header);
 
   m.Bind(&header);
-  Node* i = m.Phi(kMachInt32, zero, zero);
-  Node* j = m.Phi(kMachInt32, zero, zero);
+  Node* i = m.Phi(MachineRepresentation::kWord32, zero, zero);
+  Node* j = m.Phi(MachineRepresentation::kWord32, zero, zero);
   m.Goto(&body);
 
   m.Bind(&body);
   Node* next_i = m.Int32Add(i, one);
   Node* next_j = m.Int32Add(j, one);
   m.Branch(m.Word32Equal(next_i, ten), &end, &body_cont);
 
   m.Bind(&body_cont);
   i->ReplaceInput(1, next_i);
   j->ReplaceInput(1, next_j);
@@ skipping 11 matching lines @@
 
   Node* zero = m.Int32Constant(0);
   Node* ten = m.Int32Constant(10);
   Node* one = m.Int32Constant(1);
 
   RawMachineLabel header, body, body_cont, end;
 
   m.Goto(&header);
 
   m.Bind(&header);
-  Node* i = m.Phi(kMachInt32, zero, zero);
-  Node* j = m.Phi(kMachInt32, zero, zero);
-  Node* k = m.Phi(kMachInt32, zero, zero);
+  Node* i = m.Phi(MachineRepresentation::kWord32, zero, zero);
+  Node* j = m.Phi(MachineRepresentation::kWord32, zero, zero);
+  Node* k = m.Phi(MachineRepresentation::kWord32, zero, zero);
   m.Goto(&body);
 
   m.Bind(&body);
   Node* next_i = m.Int32Add(i, one);
   Node* next_j = m.Int32Add(j, one);
   Node* next_k = m.Int32Add(j, one);
   m.Branch(m.Word32Equal(next_i, ten), &end, &body_cont);
 
   m.Bind(&body_cont);
   i->ReplaceInput(1, next_i);
   j->ReplaceInput(1, next_j);
   k->ReplaceInput(1, next_k);
   m.Goto(&header);
 
   m.Bind(&end);
   m.Return(ten);
 
   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(kMachInt32, base, m.Int32Constant(0 * sizeof(int32_t)));
-  Node* n1 = m.Load(kMachInt32, base, m.Int32Constant(1 * sizeof(int32_t)));
-  Node* n2 = m.Load(kMachInt32, base, m.Int32Constant(2 * sizeof(int32_t)));
-  Node* n3 = m.Load(kMachInt32, base, m.Int32Constant(3 * sizeof(int32_t)));
-  Node* n4 = m.Load(kMachInt32, base, m.Int32Constant(4 * sizeof(int32_t)));
-  Node* n5 = m.Load(kMachInt32, base, m.Int32Constant(5 * sizeof(int32_t)));
-  Node* n6 = m.Load(kMachInt32, base, m.Int32Constant(6 * sizeof(int32_t)));
-  Node* n7 = m.Load(kMachInt32, base, m.Int32Constant(7 * sizeof(int32_t)));
+  Node* n0 =
+      m.Load(MachineType::Int32(), base, m.Int32Constant(0 * sizeof(int32_t)));
+  Node* n1 =
+      m.Load(MachineType::Int32(), base, m.Int32Constant(1 * sizeof(int32_t)));
+  Node* n2 =
+      m.Load(MachineType::Int32(), base, m.Int32Constant(2 * sizeof(int32_t)));
+  Node* n3 =
+      m.Load(MachineType::Int32(), base, m.Int32Constant(3 * sizeof(int32_t)));
+  Node* n4 =
+      m.Load(MachineType::Int32(), base, m.Int32Constant(4 * sizeof(int32_t)));
+  Node* n5 =
+      m.Load(MachineType::Int32(), base, m.Int32Constant(5 * sizeof(int32_t)));
+  Node* n6 =
+      m.Load(MachineType::Int32(), base, m.Int32Constant(6 * sizeof(int32_t)));
+  Node* n7 =
+      m.Load(MachineType::Int32(), 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 11 matching lines @@
                                 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(kMachFloat64, m->PointerConstant(&buffer[0]))
-                   : m->Float64Constant(x);
-  Node* b = load_b ? m->Load(kMachFloat64, m->PointerConstant(&buffer[1]))
-                   : m->Float64Constant(y);
+  Node* a =
+      load_a ? m->Load(MachineType::Float64(), m->PointerConstant(&buffer[0]))
+             : m->Float64Constant(x);
+  Node* b =
+      load_b ? m->Load(MachineType::Float64(), 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:
       cmp = m->Float64Equal(a, a);
@@ skipping 106 matching lines @@
     }
   }
 }
 
 
 TEST(RunFloat64Equal) {
   double input_a = 0.0;
   double input_b = 0.0;
 
   RawMachineAssemblerTester<int32_t> m;
-  Node* a = m.LoadFromPointer(&input_a, kMachFloat64);
-  Node* b = m.LoadFromPointer(&input_b, kMachFloat64);
+  Node* a = m.LoadFromPointer(&input_a, MachineType::Float64());
+  Node* b = m.LoadFromPointer(&input_b, MachineType::Float64());
   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, kMachFloat64);
-  Node* b = m.LoadFromPointer(&input_b, kMachFloat64);
+  Node* a = m.LoadFromPointer(&input_a, MachineType::Float64());
+  Node* b = m.LoadFromPointer(&input_b, MachineType::Float64());
   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());
     }
   }
 }
 
 
-template <typename IntType, MachineType kRepresentation>
-static void LoadStoreTruncation() {
+template <typename IntType>
+static void LoadStoreTruncation(MachineType kRepresentation) {
   IntType input;
 
   RawMachineAssemblerTester<int32_t> m;
   Node* a = m.LoadFromPointer(&input, kRepresentation);
   Node* ap1 = m.Int32Add(a, m.Int32Constant(1));
   m.StoreToPointer(&input, kRepresentation, ap1);
   m.Return(ap1);
 
   const IntType max = std::numeric_limits<IntType>::max();
   const IntType min = std::numeric_limits<IntType>::min();
@@ skipping 12 matching lines @@
   for (int i = -127; i < 127; i++) {
     input = i;
     int expected = i >= 0 ? i + 1 : max + (i - min) + 2;
     CHECK_EQ(static_cast<IntType>(expected), m.Call());
     CHECK_EQ(static_cast<IntType>(i + 1), input);
   }
 }
 
 
 TEST(RunLoadStoreTruncation) {
-  LoadStoreTruncation<int8_t, kMachInt8>();
-  LoadStoreTruncation<int16_t, kMachInt16>();
+  LoadStoreTruncation<int8_t>(MachineType::Int8());
+  LoadStoreTruncation<int16_t>(MachineType::Int16());
 }
 
 
 static void IntPtrCompare(intptr_t left, intptr_t right) {
   for (int test = 0; test < 7; test++) {
-    RawMachineAssemblerTester<bool> m(kMachPtr, kMachPtr);
+    RawMachineAssemblerTester<bool> m(MachineType::Pointer(),
+                                      MachineType::Pointer());
     Node* p0 = m.Parameter(0);
     Node* p1 = m.Parameter(1);
     Node* res = NULL;
     bool expected = false;
     switch (test) {
       case 0:
         res = m.IntPtrLessThan(p0, p1);
         expected = true;
         break;
       case 1:
@@ skipping 48 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.IntPtrConstant(sizeof(inputs[0]));
   for (int i = 0; i < kInputSize; i++) {
-    m.Store(kMachInt32, output, m.Load(kMachInt32, input), kNoWriteBarrier);
+    m.Store(MachineType::Int32(), output, m.Load(MachineType::Int32(), input),
+            kNoWriteBarrier);
     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]);
   }
 }
 
 
 TEST(RunSpillLotsOfThings) {
   static const int kInputSize = 1000;
   RawMachineAssemblerTester<int32_t> 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], kMachInt32, accs[i]);
+    m.StoreToPointer(&outputs[i], MachineType::Int32(), 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(kMachInt32, kMachInt32);
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
+                                       MachineType::Int32());
   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], kMachInt32, accs[i]);
+    m.StoreToPointer(&outputs[i], MachineType::Int32(), 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(kMachInt32);
+  RawMachineAssemblerTester<Object*> m(MachineType::Int32());
 
   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);
 
   RawMachineLabel blocka, blockb, end;
   m.Branch(m.Parameter(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&end);
   m.Bind(&blockb);
   m.Goto(&end);
 
   m.Bind(&end);
-  Node* phi = m.Phi(kMachAnyTagged, true_node, false_node);
+  Node* phi = m.Phi(MachineRepresentation::kTagged, true_node, false_node);
   m.Return(phi);
 
   CHECK_EQ(*false_val, m.Call(0));
   CHECK_EQ(*true_val, m.Call(1));
 }
 
 
 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, kMachInt32, val);
+  m.StoreToPointer(&actual_val, MachineType::Int32(), val);
   bt.AddReturn(ovf);
   FOR_INT32_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       int32_t expected_val;
       int expected_ovf = bits::SignedAddOverflow32(*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(kMachInt32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
       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, kMachInt32, val);
+      m.StoreToPointer(&actual_val, MachineType::Int32(), val);
       m.Return(ovf);
       FOR_INT32_INPUTS(j) {
         int expected_ovf = bits::SignedAddOverflow32(*i, *j, &expected_val);
         CHECK_EQ(expected_ovf, m.Call(*j));
         CHECK_EQ(expected_val, actual_val);
       }
     }
     {
-      RawMachineAssemblerTester<int32_t> m(kMachInt32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
       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, kMachInt32, val);
+      m.StoreToPointer(&actual_val, MachineType::Int32(), val);
       m.Return(ovf);
       FOR_INT32_INPUTS(j) {
         int expected_ovf = bits::SignedAddOverflow32(*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, kMachInt32, val);
+      m.StoreToPointer(&actual_val, MachineType::Int32(), val);
       m.Return(ovf);
       int expected_ovf = bits::SignedAddOverflow32(*i, *j, &expected_val);
       CHECK_EQ(expected_ovf, m.Call());
       CHECK_EQ(expected_val, actual_val);
     }
   }
 }
 
 
 TEST(RunInt32AddWithOverflowInBranchP) {
@@ skipping 19 matching lines @@
 }
 
 
 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, kMachInt32, val);
+  m.StoreToPointer(&actual_val, MachineType::Int32(), val);
   bt.AddReturn(ovf);
   FOR_INT32_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       int32_t expected_val;
       int expected_ovf = bits::SignedSubOverflow32(*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(kMachInt32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
       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, kMachInt32, val);
+      m.StoreToPointer(&actual_val, MachineType::Int32(), val);
       m.Return(ovf);
       FOR_INT32_INPUTS(j) {
         int expected_ovf = bits::SignedSubOverflow32(*i, *j, &expected_val);
         CHECK_EQ(expected_ovf, m.Call(*j));
         CHECK_EQ(expected_val, actual_val);
       }
     }
     {
-      RawMachineAssemblerTester<int32_t> m(kMachInt32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
       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, kMachInt32, val);
+      m.StoreToPointer(&actual_val, MachineType::Int32(), val);
       m.Return(ovf);
       FOR_INT32_INPUTS(j) {
         int expected_ovf = bits::SignedSubOverflow32(*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, kMachInt32, val);
+      m.StoreToPointer(&actual_val, MachineType::Int32(), val);
       m.Return(ovf);
       int expected_ovf = bits::SignedSubOverflow32(*i, *j, &expected_val);
       CHECK_EQ(expected_ovf, m.Call());
       CHECK_EQ(expected_val, actual_val);
     }
   }
 }
 
 
 TEST(RunInt32SubWithOverflowInBranchP) {
@@ skipping 17 matching lines @@
     }
   }
 }
 
 
 TEST(RunWord64EqualInBranchP) {
   int64_t input;
   RawMachineLabel blocka, blockb;
   RawMachineAssemblerTester<int64_t> m;
   if (!m.machine()->Is64()) return;
-  Node* value = m.LoadFromPointer(&input, kMachInt64);
+  Node* value = m.LoadFromPointer(&input, MachineType::Int64());
   m.Branch(m.Word64Equal(value, m.Int64Constant(0)), &blocka, &blockb);
   m.Bind(&blocka);
   m.Return(m.Int32Constant(1));
   m.Bind(&blockb);
   m.Return(m.Int32Constant(2));
   input = V8_INT64_C(0);
   CHECK_EQ(1, m.Call());
   input = V8_INT64_C(1);
   CHECK_EQ(2, m.Call());
   input = V8_INT64_C(0x100000000);
   CHECK_EQ(2, m.Call());
 }
 
 
 TEST(RunChangeInt32ToInt64P) {
   if (kPointerSize < 8) return;
   int64_t actual = -1;
-  RawMachineAssemblerTester<int32_t> m(kMachInt32);
-  m.StoreToPointer(&actual, kMachInt64, m.ChangeInt32ToInt64(m.Parameter(0)));
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
+  m.StoreToPointer(&actual, MachineType::Int64(),
+                   m.ChangeInt32ToInt64(m.Parameter(0)));
   m.Return(m.Int32Constant(0));
   FOR_INT32_INPUTS(i) {
     int64_t expected = *i;
     CHECK_EQ(0, m.Call(*i));
     CHECK_EQ(expected, actual);
   }
 }
 
 
 TEST(RunChangeUint32ToUint64P) {
   if (kPointerSize < 8) return;
   int64_t actual = -1;
-  RawMachineAssemblerTester<int32_t> m(kMachUint32);
-  m.StoreToPointer(&actual, kMachUint64,
+  RawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
+  m.StoreToPointer(&actual, MachineType::Uint64(),
                    m.ChangeUint32ToUint64(m.Parameter(0)));
   m.Return(m.Int32Constant(0));
   FOR_UINT32_INPUTS(i) {
     int64_t expected = static_cast<uint64_t>(*i);
     CHECK_EQ(0, m.Call(*i));
     CHECK_EQ(expected, actual);
   }
 }
 
 
 TEST(RunTruncateInt64ToInt32P) {
   if (kPointerSize < 8) return;
   int64_t expected = -1;
   RawMachineAssemblerTester<int32_t> m;
-  m.Return(m.TruncateInt64ToInt32(m.LoadFromPointer(&expected, kMachInt64)));
+  m.Return(m.TruncateInt64ToInt32(
+      m.LoadFromPointer(&expected, MachineType::Int64())));
   FOR_UINT32_INPUTS(i) {
     FOR_UINT32_INPUTS(j) {
       expected = (static_cast<uint64_t>(*j) << 32) | *i;
       CHECK_EQ(static_cast<int32_t>(expected), m.Call());
     }
   }
 }
 
 
 TEST(RunTruncateFloat64ToInt32P) {
@@ skipping 50 matching lines @@
                  {9.6714157802890681e+24, -2147483648.0},
                  {-9.6714157802890681e+24, -2147483648.0},
                  {1.9342813113834065e+25, 2147483648.0},
                  {-1.9342813113834065e+25, 2147483648.0},
                  {3.868562622766813e+25, 0},
                  {-3.868562622766813e+25, 0},
                  {1.7976931348623157e+308, 0},
                  {-1.7976931348623157e+308, 0}};
   double input = -1.0;
   RawMachineAssemblerTester<int32_t> m;
-  m.Return(m.TruncateFloat64ToInt32(TruncationMode::kJavaScript,
-                                    m.LoadFromPointer(&input, kMachFloat64)));
+  m.Return(m.TruncateFloat64ToInt32(
+      TruncationMode::kJavaScript,
+      m.LoadFromPointer(&input, MachineType::Float64())));
   for (size_t i = 0; i < arraysize(kValues); ++i) {
     input = kValues[i].from;
     uint64_t expected = static_cast<int64_t>(kValues[i].raw);
     CHECK_EQ(static_cast<int>(expected), m.Call());
   }
 }
 
 
 TEST(RunChangeFloat32ToFloat64) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat32);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float32());
 
   m.Return(m.ChangeFloat32ToFloat64(m.Parameter(0)));
 
   FOR_FLOAT32_INPUTS(i) { CheckDoubleEq(static_cast<double>(*i), m.Call(*i)); }
 }
 
 
 TEST(RunFloat32Constant) {
   FOR_FLOAT32_INPUTS(i) {
     BufferedRawMachineAssemblerTester<float> m;
     m.Return(m.Float32Constant(*i));
     CheckFloatEq(*i, m.Call());
   }
 }
 
 
 TEST(RunFloat64ExtractLowWord32) {
-  BufferedRawMachineAssemblerTester<uint32_t> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Float64());
   m.Return(m.Float64ExtractLowWord32(m.Parameter(0)));
   FOR_FLOAT64_INPUTS(i) {
     uint32_t expected = static_cast<uint32_t>(bit_cast<uint64_t>(*i));
     CHECK_EQ(expected, m.Call(*i));
   }
 }
 
 
 TEST(RunFloat64ExtractHighWord32) {
-  BufferedRawMachineAssemblerTester<uint32_t> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Float64());
   m.Return(m.Float64ExtractHighWord32(m.Parameter(0)));
   FOR_FLOAT64_INPUTS(i) {
     uint32_t expected = static_cast<uint32_t>(bit_cast<uint64_t>(*i) >> 32);
     CHECK_EQ(expected, m.Call(*i));
   }
 }
 
 
 TEST(RunFloat64InsertLowWord32) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64, kMachInt32);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
+                                              MachineType::Int32());
   m.Return(m.Float64InsertLowWord32(m.Parameter(0), m.Parameter(1)));
   FOR_FLOAT64_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       double expected = bit_cast<double>(
           (bit_cast<uint64_t>(*i) & ~(V8_UINT64_C(0xFFFFFFFF))) |
           (static_cast<uint64_t>(bit_cast<uint32_t>(*j))));
       CheckDoubleEq(expected, m.Call(*i, *j));
     }
   }
 }
 
 
 TEST(RunFloat64InsertHighWord32) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64, kMachUint32);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
+                                              MachineType::Uint32());
   m.Return(m.Float64InsertHighWord32(m.Parameter(0), m.Parameter(1)));
   FOR_FLOAT64_INPUTS(i) {
     FOR_UINT32_INPUTS(j) {
       uint64_t expected = (bit_cast<uint64_t>(*i) & 0xFFFFFFFF) |
                           (static_cast<uint64_t>(*j) << 32);
 
       CheckDoubleEq(bit_cast<double>(expected), m.Call(*i, *j));
     }
   }
 }
 
 
 TEST(RunFloat32Abs) {
-  BufferedRawMachineAssemblerTester<float> m(kMachFloat32);
+  BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
   m.Return(m.Float32Abs(m.Parameter(0)));
   FOR_FLOAT32_INPUTS(i) { CheckFloatEq(std::abs(*i), m.Call(*i)); }
 }
 
 
 TEST(RunFloat64Abs) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
   m.Return(m.Float64Abs(m.Parameter(0)));
   FOR_FLOAT64_INPUTS(i) { CheckDoubleEq(std::abs(*i), m.Call(*i)); }
 }
 
 
 static double two_30 = 1 << 30;             // 2^30 is a smi boundary.
 static double two_52 = two_30 * (1 << 22);  // 2^52 is a precision boundary.
 static double kValues[] = {0.1,
                            0.2,
                            0.49999999999999994,
@@ skipping 84 matching lines @@
                            -two_52 - 0.1,
                            -two_52 - 0.5,
                            -two_52 - 0.7,
                            -two_52 + 1,
                            -two_52 + 1 - 0.1,
                            -two_52 + 1 - 0.5,
                            -two_52 + 1 - 0.7};
 
 
 TEST(RunFloat32RoundDown) {
-  BufferedRawMachineAssemblerTester<float> m(kMachFloat32);
+  BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
   if (!m.machine()->Float32RoundDown().IsSupported()) return;
 
   m.Return(m.Float32RoundDown(m.Parameter(0)));
 
   FOR_FLOAT32_INPUTS(i) { CheckFloatEq(floorf(*i), m.Call(*i)); }
 }
 
 
 TEST(RunFloat64RoundDown1) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
   if (!m.machine()->Float64RoundDown().IsSupported()) return;
 
   m.Return(m.Float64RoundDown(m.Parameter(0)));
 
   FOR_FLOAT64_INPUTS(i) { CheckDoubleEq(floor(*i), m.Call(*i)); }
 }
 
 
 TEST(RunFloat64RoundDown2) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
   if (!m.machine()->Float64RoundDown().IsSupported()) return;
   m.Return(m.Float64Sub(m.Float64Constant(-0.0),
                         m.Float64RoundDown(m.Float64Sub(m.Float64Constant(-0.0),
                                                         m.Parameter(0)))));
 
   for (size_t i = 0; i < arraysize(kValues); ++i) {
     CHECK_EQ(ceil(kValues[i]), m.Call(kValues[i]));
   }
 }
 
 
 TEST(RunFloat32RoundUp) {
-  BufferedRawMachineAssemblerTester<float> m(kMachFloat32);
+  BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
   if (!m.machine()->Float32RoundUp().IsSupported()) return;
   m.Return(m.Float32RoundUp(m.Parameter(0)));
 
   FOR_FLOAT32_INPUTS(i) { CheckFloatEq(ceilf(*i), m.Call(*i)); }
 }
 
 
 TEST(RunFloat64RoundUp) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
   if (!m.machine()->Float64RoundUp().IsSupported()) return;
   m.Return(m.Float64RoundUp(m.Parameter(0)));
 
   FOR_FLOAT64_INPUTS(i) { CheckDoubleEq(ceil(*i), m.Call(*i)); }
 }
 
 
 TEST(RunFloat32RoundTiesEven) {
-  BufferedRawMachineAssemblerTester<float> m(kMachFloat32);
+  BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
   if (!m.machine()->Float32RoundTiesEven().IsSupported()) return;
   m.Return(m.Float32RoundTiesEven(m.Parameter(0)));
 
   FOR_FLOAT32_INPUTS(i) { CheckFloatEq(nearbyint(*i), m.Call(*i)); }
 }
 
 
 TEST(RunFloat64RoundTiesEven) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
   if (!m.machine()->Float64RoundTiesEven().IsSupported()) return;
   m.Return(m.Float64RoundTiesEven(m.Parameter(0)));
 
   FOR_FLOAT64_INPUTS(i) { CheckDoubleEq(nearbyint(*i), m.Call(*i)); }
 }
 
 
 TEST(RunFloat32RoundTruncate) {
-  BufferedRawMachineAssemblerTester<float> m(kMachFloat32);
+  BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
   if (!m.machine()->Float32RoundTruncate().IsSupported()) return;
 
   m.Return(m.Float32RoundTruncate(m.Parameter(0)));
 
   FOR_FLOAT32_INPUTS(i) { CheckFloatEq(truncf(*i), m.Call(*i)); }
 }
 
 
 TEST(RunFloat64RoundTruncate) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
   if (!m.machine()->Float64RoundTruncate().IsSupported()) return;
   m.Return(m.Float64RoundTruncate(m.Parameter(0)));
   for (size_t i = 0; i < arraysize(kValues); ++i) {
     CHECK_EQ(trunc(kValues[i]), m.Call(kValues[i]));
   }
 }
 
 
 TEST(RunFloat64RoundTiesAway) {
-  BufferedRawMachineAssemblerTester<double> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
   if (!m.machine()->Float64RoundTiesAway().IsSupported()) return;
   m.Return(m.Float64RoundTiesAway(m.Parameter(0)));
   for (size_t i = 0; i < arraysize(kValues); ++i) {
     CHECK_EQ(round(kValues[i]), m.Call(kValues[i]));
   }
 }
 
 
 #if !USE_SIMULATOR
 
@@ skipping 15 matching lines @@
              int32_t g, int32_t h) {
   return a + b + c + d + e + f + g + h;
 }
 
 }  // namespace
 
 
 TEST(RunCallCFunction0) {
   auto* foo0_ptr = &foo0;
   RawMachineAssemblerTester<int32_t> m;
-  Node* function = m.LoadFromPointer(&foo0_ptr, kMachPtr);
-  m.Return(m.CallCFunction0(kMachInt32, function));
+  Node* function = m.LoadFromPointer(&foo0_ptr, MachineType::Pointer());
+  m.Return(m.CallCFunction0(MachineType::Int32(), function));
   CHECK_EQ(kMagicFoo0, m.Call());
 }
 
 
 TEST(RunCallCFunction1) {
   auto* foo1_ptr = &foo1;
-  RawMachineAssemblerTester<int32_t> m(kMachInt32);
-  Node* function = m.LoadFromPointer(&foo1_ptr, kMachPtr);
-  m.Return(m.CallCFunction1(kMachInt32, kMachInt32, function, m.Parameter(0)));
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
+  Node* function = m.LoadFromPointer(&foo1_ptr, MachineType::Pointer());
+  m.Return(m.CallCFunction1(MachineType::Int32(), MachineType::Int32(),
+                            function, m.Parameter(0)));
   FOR_INT32_INPUTS(i) {
     int32_t const expected = *i;
     CHECK_EQ(expected, m.Call(expected));
   }
 }
 
 
 TEST(RunCallCFunction2) {
   auto* foo2_ptr = &foo2;
-  RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
-  Node* function = m.LoadFromPointer(&foo2_ptr, kMachPtr);
-  m.Return(m.CallCFunction2(kMachInt32, kMachInt32, kMachInt32, function,
-                            m.Parameter(0), m.Parameter(1)));
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
+                                       MachineType::Int32());
+  Node* function = m.LoadFromPointer(&foo2_ptr, MachineType::Pointer());
+  m.Return(m.CallCFunction2(MachineType::Int32(), MachineType::Int32(),
+                            MachineType::Int32(), function, m.Parameter(0),
+                            m.Parameter(1)));
   FOR_INT32_INPUTS(i) {
     int32_t const x = *i;
     FOR_INT32_INPUTS(j) {
       int32_t const y = *j;
       CHECK_EQ(x - y, m.Call(x, y));
     }
   }
 }
 
 
 TEST(RunCallCFunction8) {
   auto* foo8_ptr = &foo8;
-  RawMachineAssemblerTester<int32_t> m(kMachInt32);
-  Node* function = m.LoadFromPointer(&foo8_ptr, kMachPtr);
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
+  Node* function = m.LoadFromPointer(&foo8_ptr, MachineType::Pointer());
   Node* param = m.Parameter(0);
-  m.Return(m.CallCFunction8(kMachInt32, kMachInt32, kMachInt32, kMachInt32,
-                            kMachInt32, kMachInt32, kMachInt32, kMachInt32,
-                            kMachInt32, function, param, param, param, param,
-                            param, param, param, param));
+  m.Return(m.CallCFunction8(
+      MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+      MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+      MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+      function, param, param, param, param, param, param, param, param));
   FOR_INT32_INPUTS(i) {
     int32_t const x = *i;
     CHECK_EQ(x * 8, m.Call(x));
   }
 }
 #endif  // USE_SIMULATOR
 
 #if V8_TARGET_ARCH_64_BIT
 // TODO(titzer): run int64 tests on all platforms when supported.
 TEST(RunCheckedLoadInt64) {
   int64_t buffer[] = {0x66bbccddeeff0011LL, 0x1122334455667788LL};
-  RawMachineAssemblerTester<int64_t> m(kMachInt32);
+  RawMachineAssemblerTester<int64_t> m(MachineType::Int32());
   Node* base = m.PointerConstant(buffer);
   Node* index = m.Parameter(0);
   Node* length = m.Int32Constant(16);
-  Node* load =
-      m.AddNode(m.machine()->CheckedLoad(kMachInt64), base, index, length);
+  Node* load = m.AddNode(m.machine()->CheckedLoad(MachineType::Int64()), base,
+                         index, length);
   m.Return(load);
 
   CHECK_EQ(buffer[0], m.Call(0));
   CHECK_EQ(buffer[1], m.Call(8));
   CHECK_EQ(0, m.Call(16));
 }
 
 
 TEST(RunCheckedStoreInt64) {
   const int64_t write = 0x5566778899aabbLL;
   const int64_t before = 0x33bbccddeeff0011LL;
   int64_t buffer[] = {before, before};
-  RawMachineAssemblerTester<int32_t> m(kMachInt32);
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
   Node* base = m.PointerConstant(buffer);
   Node* index = m.Parameter(0);
   Node* length = m.Int32Constant(16);
   Node* value = m.Int64Constant(write);
-  Node* store = m.AddNode(m.machine()->CheckedStore(kMachInt64), base, index,
-                          length, value);
+  Node* store = m.AddNode(m.machine()->CheckedStore(MachineType::Int64()), base,
+                          index, length, value);
   USE(store);
   m.Return(m.Int32Constant(11));
 
   CHECK_EQ(11, m.Call(16));
   CHECK_EQ(before, buffer[0]);
   CHECK_EQ(before, buffer[1]);
 
   CHECK_EQ(11, m.Call(0));
   CHECK_EQ(write, buffer[0]);
   CHECK_EQ(before, buffer[1]);
 
   CHECK_EQ(11, m.Call(8));
   CHECK_EQ(write, buffer[0]);
   CHECK_EQ(write, buffer[1]);
 }
 
 
 TEST(RunBitcastInt64ToFloat64) {
   int64_t input = 1;
   double output = 0.0;
   RawMachineAssemblerTester<int32_t> m;
   m.StoreToPointer(
-      &output, kMachFloat64,
-      m.BitcastInt64ToFloat64(m.LoadFromPointer(&input, kMachInt64)));
+      &output, MachineType::Float64(),
+      m.BitcastInt64ToFloat64(m.LoadFromPointer(&input, MachineType::Int64())));
   m.Return(m.Int32Constant(11));
   FOR_INT64_INPUTS(i) {
     input = *i;
     CHECK_EQ(11, m.Call());
     double expected = bit_cast<double>(input);
     CHECK_EQ(bit_cast<int64_t>(expected), bit_cast<int64_t>(output));
   }
 }
 
 
 TEST(RunBitcastFloat64ToInt64) {
-  BufferedRawMachineAssemblerTester<int64_t> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float64());
 
   m.Return(m.BitcastFloat64ToInt64(m.Parameter(0)));
   FOR_FLOAT64_INPUTS(i) { CHECK_EQ(bit_cast<int64_t>(*i), m.Call(*i)); }
 }
 
 
 TEST(RunTryTruncateFloat32ToInt64WithoutCheck) {
-  BufferedRawMachineAssemblerTester<int64_t> m(kMachFloat32);
+  BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float32());
   m.Return(m.TryTruncateFloat32ToInt64(m.Parameter(0)));
 
   FOR_INT64_INPUTS(i) {
     float input = static_cast<float>(*i);
     if (input < 9223372036854775808.0 && input > -9223372036854775809.0) {
       CHECK_EQ(static_cast<int64_t>(input), m.Call(input));
     }
   }
 }
 
 
 TEST(RunTryTruncateFloat32ToInt64WithCheck) {
   int64_t success = 0;
-  BufferedRawMachineAssemblerTester<int64_t> m(kMachFloat32);
+  BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float32());
   Node* trunc = m.TryTruncateFloat32ToInt64(m.Parameter(0));
   Node* val = m.Projection(0, trunc);
   Node* check = m.Projection(1, trunc);
-  m.StoreToPointer(&success, kMachInt64, check);
+  m.StoreToPointer(&success, MachineType::Int64(), check);
   m.Return(val);
 
   FOR_FLOAT32_INPUTS(i) {
     if (*i < 9223372036854775808.0 && *i > -9223372036854775809.0) {
       CHECK_EQ(static_cast<int64_t>(*i), m.Call(*i));
       CHECK_NE(0, success);
     } else {
       m.Call(*i);
       CHECK_EQ(0, success);
     }
   }
 }
 
 
 TEST(RunTryTruncateFloat64ToInt64WithoutCheck) {
-  BufferedRawMachineAssemblerTester<int64_t> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float64());
   m.Return(m.TryTruncateFloat64ToInt64(m.Parameter(0)));
 
   FOR_INT64_INPUTS(i) {
     double input = static_cast<double>(*i);
     CHECK_EQ(static_cast<int64_t>(input), m.Call(input));
   }
 }
 
 
 TEST(RunTryTruncateFloat64ToInt64WithCheck) {
   int64_t success = 0;
-  BufferedRawMachineAssemblerTester<int64_t> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float64());
   Node* trunc = m.TryTruncateFloat64ToInt64(m.Parameter(0));
   Node* val = m.Projection(0, trunc);
   Node* check = m.Projection(1, trunc);
-  m.StoreToPointer(&success, kMachInt64, check);
+  m.StoreToPointer(&success, MachineType::Int64(), check);
   m.Return(val);
 
   FOR_FLOAT64_INPUTS(i) {
     if (*i < 9223372036854775808.0 && *i > -9223372036854775809.0) {
       // Conversions within this range should succeed.
       CHECK_EQ(static_cast<int64_t>(*i), m.Call(*i));
       CHECK_NE(0, success);
     } else {
       m.Call(*i);
       CHECK_EQ(0, success);
     }
   }
 }
 
 
 TEST(RunTruncateFloat32ToUint64) {
-  BufferedRawMachineAssemblerTester<uint64_t> m(kMachFloat32);
+  BufferedRawMachineAssemblerTester<uint64_t> m(MachineType::Float32());
   m.Return(m.TruncateFloat32ToUint64(m.Parameter(0)));
 
   FOR_UINT64_INPUTS(i) {
     float input = static_cast<float>(*i);
     if (input < 18446744073709551616.0) {
       CHECK_EQ(static_cast<uint64_t>(input), m.Call(input));
     }
   }
   FOR_FLOAT32_INPUTS(j) {
     if (*j < 18446744073709551616.0 && *j >= 0) {
       CHECK_EQ(static_cast<uint64_t>(*j), m.Call(*j));
     }
   }
 }
 
 
 TEST(RunTryTruncateFloat64ToUint64WithoutCheck) {
-  BufferedRawMachineAssemblerTester<uint64_t> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<uint64_t> m(MachineType::Float64());
   m.Return(m.TruncateFloat64ToUint64(m.Parameter(0)));
 
   FOR_UINT64_INPUTS(j) {
     double input = static_cast<double>(*j);
 
     if (input < 18446744073709551616.0) {
       CHECK_EQ(static_cast<uint64_t>(input), m.Call(input));
     }
   }
 }
 
 
 TEST(RunTryTruncateFloat64ToUint64WithCheck) {
   int64_t success = 0;
-  BufferedRawMachineAssemblerTester<int64_t> m(kMachFloat64);
+  BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float64());
   Node* trunc = m.TryTruncateFloat64ToUint64(m.Parameter(0));
   Node* val = m.Projection(0, trunc);
   Node* check = m.Projection(1, trunc);
-  m.StoreToPointer(&success, kMachInt64, check);
+  m.StoreToPointer(&success, MachineType::Int64(), check);
   m.Return(val);
 
   FOR_FLOAT64_INPUTS(i) {
     if (*i < 18446744073709551616.0 && *i >= 0) {
       // Conversions within this range should succeed.
       CHECK_EQ(static_cast<uint64_t>(*i), m.Call(*i));
       CHECK_NE(0, success);
     } else {
       m.Call(*i);
       CHECK_EQ(0, success);
     }
   }
 }
 
 
 TEST(RunRoundInt64ToFloat32) {
-  BufferedRawMachineAssemblerTester<float> m(kMachInt64);
+  BufferedRawMachineAssemblerTester<float> m(MachineType::Int64());
   m.Return(m.RoundInt64ToFloat32(m.Parameter(0)));
   FOR_INT64_INPUTS(i) { CHECK_EQ(static_cast<float>(*i), m.Call(*i)); }
 }
 
 
 TEST(RunRoundInt64ToFloat64) {
-  BufferedRawMachineAssemblerTester<double> m(kMachInt64);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Int64());
   m.Return(m.RoundInt64ToFloat64(m.Parameter(0)));
   FOR_INT64_INPUTS(i) { CHECK_EQ(static_cast<double>(*i), m.Call(*i)); }
 }
 
 
 TEST(RunRoundUint64ToFloat64) {
   struct {
     uint64_t input;
     uint64_t expected;
   } values[] = {{0x0, 0x0},
@@ skipping 65 matching lines @@
                 {0x1fffffffffff, 0x42bfffffffffff00},
                 {0xfffffffffff, 0x42affffffffffe00},
                 {0x7ffffffffff, 0x429ffffffffffc00},
                 {0x3ffffffffff, 0x428ffffffffff800},
                 {0x1ffffffffff, 0x427ffffffffff000},
                 {0x8000008000000000, 0x43e0000010000000},
                 {0x8000008000000001, 0x43e0000010000000},
                 {0x8000000000000400, 0x43e0000000000000},
                 {0x8000000000000401, 0x43e0000000000001}};
 
-  BufferedRawMachineAssemblerTester<double> m(kMachUint64);
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Uint64());
   m.Return(m.RoundUint64ToFloat64(m.Parameter(0)));
 
   for (size_t i = 0; i < arraysize(values); i++) {
     CHECK_EQ(bit_cast<double>(values[i].expected), m.Call(values[i].input));
   }
 }
 
 
 TEST(RunRoundUint64ToFloat32) {
   struct {
@@ skipping 69 matching lines @@
                 {0x1fffffffffff, 0x56000000},
                 {0xfffffffffff, 0x55800000},
                 {0x7ffffffffff, 0x55000000},
                 {0x3ffffffffff, 0x54800000},
                 {0x1ffffffffff, 0x54000000},
                 {0x8000008000000000, 0x5f000000},
                 {0x8000008000000001, 0x5f000001},
                 {0x8000000000000400, 0x5f000000},
                 {0x8000000000000401, 0x5f000000}};
 
-  BufferedRawMachineAssemblerTester<float> m(kMachUint64);
+  BufferedRawMachineAssemblerTester<float> m(MachineType::Uint64());
   m.Return(m.RoundUint64ToFloat32(m.Parameter(0)));
 
   for (size_t i = 0; i < arraysize(values); i++) {
     CHECK_EQ(bit_cast<float>(values[i].expected), m.Call(values[i].input));
   }
 }
 
 
 #endif
 
 
 TEST(RunBitcastFloat32ToInt32) {
   float input = 32.25;
   RawMachineAssemblerTester<int32_t> m;
-  m.Return(m.BitcastFloat32ToInt32(m.LoadFromPointer(&input, kMachFloat32)));
+  m.Return(m.BitcastFloat32ToInt32(
+      m.LoadFromPointer(&input, MachineType::Float32())));
   FOR_FLOAT32_INPUTS(i) {
     input = *i;
     int32_t expected = bit_cast<int32_t>(input);
     CHECK_EQ(expected, m.Call());
   }
 }
 
 
 TEST(RunBitcastInt32ToFloat32) {
   int32_t input = 1;
   float output = 0.0;
   RawMachineAssemblerTester<int32_t> m;
   m.StoreToPointer(
-      &output, kMachFloat32,
-      m.BitcastInt32ToFloat32(m.LoadFromPointer(&input, kMachInt32)));
+      &output, MachineType::Float32(),
+      m.BitcastInt32ToFloat32(m.LoadFromPointer(&input, MachineType::Int32())));
   m.Return(m.Int32Constant(11));
   FOR_INT32_INPUTS(i) {
     input = *i;
     CHECK_EQ(11, m.Call());
     float expected = bit_cast<float>(input);
     CHECK_EQ(bit_cast<int32_t>(expected), bit_cast<int32_t>(output));
   }
 }
 
 
 TEST(RunComputedCodeObject) {
   GraphBuilderTester<int32_t> a;
   a.Return(a.Int32Constant(33));
   a.End();
   Handle<Code> code_a = a.GetCode();
 
   GraphBuilderTester<int32_t> b;
   b.Return(b.Int32Constant(44));
   b.End();
   Handle<Code> code_b = b.GetCode();
 
-  RawMachineAssemblerTester<int32_t> r(kMachInt32);
+  RawMachineAssemblerTester<int32_t> r(MachineType::Int32());
   RawMachineLabel tlabel;
   RawMachineLabel flabel;
   RawMachineLabel merge;
   r.Branch(r.Parameter(0), &tlabel, &flabel);
   r.Bind(&tlabel);
   Node* fa = r.HeapConstant(code_a);
   r.Goto(&merge);
   r.Bind(&flabel);
   Node* fb = r.HeapConstant(code_b);
   r.Goto(&merge);
   r.Bind(&merge);
-  Node* phi = r.Phi(kMachInt32, fa, fb);
+  Node* phi = r.Phi(MachineRepresentation::kWord32, fa, fb);
 
   // TODO(titzer): all this descriptor hackery is just to call the above
   // functions as code objects instead of direct addresses.
   CSignature0<int32_t> sig;
   CallDescriptor* c = Linkage::GetSimplifiedCDescriptor(r.zone(), &sig);
   LinkageLocation ret[] = {c->GetReturnLocation(0)};
   Signature<LinkageLocation> loc(1, 0, ret);
   CallDescriptor* desc = new (r.zone()) CallDescriptor(  // --
       CallDescriptor::kCallCodeObject,                   // kind
-      kMachAnyTagged,                                    // target_type
+      MachineType::AnyTagged(),                          // target_type
       c->GetInputLocation(0),                            // target_loc
       &sig,                                              // machine_sig
       &loc,                                              // location_sig
       0,                                                 // stack count
       Operator::kNoProperties,                           // properties
       c->CalleeSavedRegisters(),                         // callee saved
       c->CalleeSavedFPRegisters(),                       // callee saved FP
       CallDescriptor::kNoFlags,                          // flags
       "c-call-as-code");
   Node* call = r.AddNode(r.common()->Call(desc), phi);
   r.Return(call);
 
   CHECK_EQ(33, r.Call(1));
   CHECK_EQ(44, r.Call(0));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8