[turbofan] Store nodes use only MachineRepresentation, not MachineType.

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 950 matching lines @@
 
   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(MachineType::Float32(), m.PointerConstant(from),
                         m.IntPtrConstant(offset));
-    m.Store(MachineType::Float32(), m.PointerConstant(to),
+    m.Store(MachineRepresentation::kFloat32, 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(MachineType::Float64(), m.PointerConstant(from),
                         m.IntPtrConstant(offset));
-    m.Store(MachineType::Float64(), m.PointerConstant(to),
+    m.Store(MachineRepresentation::kFloat64, 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 2390 matching lines @@
     for (size_t i = 0; i < sizeof(buffer); i++) {
       raw[i] = static_cast<byte>((i + sizeof(buffer)) ^ 0xAA);
     }
 
     RawMachineAssemblerTester<int32_t> m;
     int32_t OK = 0x29000 + x;
     Node* base = m.PointerConstant(buffer);
     Node* index0 = m.IntPtrConstant(x * sizeof(buffer[0]));
     Node* load = m.Load(rep, base, index0);
     Node* index1 = m.IntPtrConstant(y * sizeof(buffer[0]));
-    m.Store(rep, base, index1, load, kNoWriteBarrier);
+    m.Store(rep.representation(), base, index1, load, kNoWriteBarrier);
     m.Return(m.Int32Constant(OK));
 
     CHECK(buffer[x] != buffer[y]);
     CHECK_EQ(OK, m.Call());
     CHECK(buffer[x] == buffer[y]);
   }
 }
 
 
 TEST(RunLoadStore) {
@@ skipping 619 matching lines @@
   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(MachineRepresentation::kFloat32, k2, k1);
-  m.Store(MachineType::Float32(), m.PointerConstant(&buffer),
+  m.Store(MachineRepresentation::kFloat32, 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(MachineRepresentation::kFloat64, k2, k1);
-  m.Store(MachineType::Float64(), m.PointerConstant(&buffer),
+  m.Store(MachineRepresentation::kFloat64, 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(MachineRepresentation::kTagged, k2, k1);
-  m.Store(MachineType::AnyTagged(), m.PointerConstant(&buffer),
+  m.Store(MachineRepresentation::kTagged, 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;
@@ skipping 11 matching lines @@
   Node* r1 = m.StringConstant("AX");
   Node* r2 = m.StringConstant("BX");
   m.Branch(m.Int32Constant(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&end);
   m.Bind(&blockb);
   m.Goto(&end);
   m.Bind(&end);
   Node* dphi = m.Phi(MachineRepresentation::kFloat64, d2, d1);
   Node* rphi = m.Phi(MachineRepresentation::kTagged, r2, r1);
-  m.Store(MachineType::Float64(), m.PointerConstant(&dbuffer),
+  m.Store(MachineRepresentation::kFloat64, m.PointerConstant(&dbuffer),
           m.Int32Constant(0), dphi, kNoWriteBarrier);
-  m.Store(MachineType::AnyTagged(), m.PointerConstant(&rbuffer),
+  m.Store(MachineRepresentation::kTagged, 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) {
@@ skipping 22 matching lines @@
   m.Branch(m.Int32Constant(0), &blockd, &blocke);
 
   m.Bind(&blockd);
   m.Goto(&end);
   m.Bind(&blocke);
   m.Goto(&end);
   m.Bind(&end);
   Node* dphi2 = m.Phi(MachineRepresentation::kFloat64, d1, dphi1);
   Node* rphi2 = m.Phi(MachineRepresentation::kTagged, r1, rphi1);
 
-  m.Store(MachineType::Float64(), m.PointerConstant(&dbuffer),
+  m.Store(MachineRepresentation::kFloat64, m.PointerConstant(&dbuffer),
           m.Int32Constant(0), dphi2, kNoWriteBarrier);
-  m.Store(MachineType::AnyTagged(), m.PointerConstant(&rbuffer),
+  m.Store(MachineRepresentation::kTagged, 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(MachineRepresentation::kFloat64, dk, dk);
   phi->ReplaceInput(1, phi);
   m.Branch(zero, &body, &end);
   m.Bind(&body);
   m.Goto(&header);
   m.Bind(&end);
-  m.Store(MachineType::Float64(), m.PointerConstant(&buffer),
+  m.Store(MachineRepresentation::kFloat64, m.PointerConstant(&buffer),
           m.Int32Constant(0), phi, kNoWriteBarrier);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
 }
 
 
 TEST(RunCountToTenAccRaw) {
   RawMachineAssemblerTester<int32_t> m;
 
@@ skipping 284 matching lines @@
 }
 
 
 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.StoreToPointer(&input, kRepresentation.representation(), ap1);
   m.Return(ap1);
 
   const IntType max = std::numeric_limits<IntType>::max();
   const IntType min = std::numeric_limits<IntType>::min();
 
   // Test upper bound.
   input = max;
   CHECK_EQ(max + 1, m.Call());
   CHECK_EQ(min, input);
 
@@ skipping 83 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(MachineType::Int32(), output, m.Load(MachineType::Int32(), input),
-            kNoWriteBarrier);
+    m.Store(MachineRepresentation::kWord32, 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], MachineType::Int32(), accs[i]);
+    m.StoreToPointer(&outputs[i], MachineRepresentation::kWord32, 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(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], MachineType::Int32(), accs[i]);
+    m.StoreToPointer(&outputs[i], MachineRepresentation::kWord32, 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;
@@ skipping 31 matching lines @@
 }
 
 
 TEST(RunInt32AddWithOverflowP) {
   int32_t actual_val = -1;
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
   Node* add = m.Int32AddWithOverflow(bt.param0, bt.param1);
   Node* val = m.Projection(0, add);
   Node* ovf = m.Projection(1, add);
-  m.StoreToPointer(&actual_val, MachineType::Int32(), val);
+  m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, 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(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, MachineType::Int32(), val);
+      m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, 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(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, MachineType::Int32(), val);
+      m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, 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, MachineType::Int32(), val);
+      m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, 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, MachineType::Int32(), val);
+  m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, 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(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, MachineType::Int32(), val);
+      m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, 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(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, MachineType::Int32(), val);
+      m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, 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, MachineType::Int32(), val);
+      m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, 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 36 matching lines @@
   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(MachineType::Int32());
-  m.StoreToPointer(&actual, MachineType::Int64(),
+  m.StoreToPointer(&actual, MachineRepresentation::kWord64,
                    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(MachineType::Uint32());
-  m.StoreToPointer(&actual, MachineType::Uint64(),
+  m.StoreToPointer(&actual, MachineRepresentation::kWord64,
                    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);
   }
 }
 
 
@@ skipping 464 matching lines @@
 
 TEST(RunCheckedStoreInt64) {
   const int64_t write = 0x5566778899aabbLL;
   const int64_t before = 0x33bbccddeeff0011LL;
   int64_t buffer[] = {before, before};
   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(MachineType::Int64()), base,
-                          index, length, value);
+  Node* store =
+      m.AddNode(m.machine()->CheckedStore(MachineRepresentation::kWord64), 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, MachineType::Float64(),
+      &output, MachineRepresentation::kFloat64,
       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));
   }
 }
 
@@ skipping 18 matching lines @@
   }
 }
 
 
 TEST(RunTryTruncateFloat32ToInt64WithCheck) {
   int64_t success = 0;
   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, MachineType::Int64(), check);
+  m.StoreToPointer(&success, MachineRepresentation::kWord64, 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);
     }
@@ skipping 11 matching lines @@
   }
 }
 
 
 TEST(RunTryTruncateFloat64ToInt64WithCheck) {
   int64_t success = 0;
   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, MachineType::Int64(), check);
+  m.StoreToPointer(&success, MachineRepresentation::kWord64, 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);
@@ skipping 19 matching lines @@
   }
 }
 
 
 TEST(RunTryTruncateFloat32ToUint64WithCheck) {
   int64_t success = 0;
   BufferedRawMachineAssemblerTester<uint64_t> m(MachineType::Float32());
   Node* trunc = m.TryTruncateFloat32ToUint64(m.Parameter(0));
   Node* val = m.Projection(0, trunc);
   Node* check = m.Projection(1, trunc);
-  m.StoreToPointer(&success, MachineType::Int64(), check);
+  m.StoreToPointer(&success, MachineRepresentation::kWord64, check);
   m.Return(val);
 
   FOR_FLOAT32_INPUTS(i) {
     if (*i < 18446744073709551616.0 && *i >= 0.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);
@@ skipping 15 matching lines @@
   }
 }
 
 
 TEST(RunTryTruncateFloat64ToUint64WithCheck) {
   int64_t success = 0;
   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, MachineType::Int64(), check);
+  m.StoreToPointer(&success, MachineRepresentation::kWord64, 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);
@@ skipping 209 matching lines @@
     CHECK_EQ(expected, m.Call());
   }
 }
 
 
 TEST(RunBitcastInt32ToFloat32) {
   int32_t input = 1;
   float output = 0.0;
   RawMachineAssemblerTester<int32_t> m;
   m.StoreToPointer(
-      &output, MachineType::Float32(),
+      &output, MachineRepresentation::kFloat32,
       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));
   }
 }
 
@@ skipping 44 matching lines @@
   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