[Interpreter] Add support for loading from / storing to outer context variables.

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"
 #include "src/codegen.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/value-helper.h"
 
 using namespace v8::base;
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
 typedef RawMachineAssembler::Label MLabel;
 
+
+StoreRepresentation StoreRepForType(MachineType type) {
+  return StoreRepresentation(type, kNoWriteBarrier);
+}
+
+
 TEST(RunInt32Add) {
   RawMachineAssemblerTester<int32_t> m;
   Node* add = m.Int32Add(m.Int32Constant(0), m.Int32Constant(1));
   m.Return(add);
   CHECK_EQ(1, m.Call());
 }
 
 
 void TestWord32Ctz(int32_t value, int32_t expected) {
   RawMachineAssemblerTester<int32_t> m;
@@ skipping 759 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(kMachFloat32, m.PointerConstant(from), m.IntPtrConstant(offset));
-    m.Store(kMachFloat32, m.PointerConstant(to), m.IntPtrConstant(offset),
-            load);
+    m.Store(StoreRepresentation(kMachFloat32, kNoWriteBarrier),
+            m.PointerConstant(to), m.IntPtrConstant(offset), load);
     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);
+    m.Store(StoreRepresentation(kMachFloat64, kNoWriteBarrier),
+            m.PointerConstant(to), m.IntPtrConstant(offset), load);
     m.Return(m.Int32Constant(magic));
 
     FOR_FLOAT64_INPUTS(j) {
       p1 = *j;
       p2 = *j - 5;
       CHECK_EQ(magic, m.Call());
       CheckDoubleEq(p1, p2);
     }
   }
 }
@@ skipping 2360 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);
+    StoreRepresentation store_rep(rep, kNoWriteBarrier);
+    m.Store(StoreRepForType(rep), base, index1, load);
     m.Return(m.Int32Constant(OK));
 
     CHECK(buffer[x] != buffer[y]);
     CHECK_EQ(OK, m.Call());
     CHECK(buffer[x] == buffer[y]);
   }
 }
 
 
 TEST(RunLoadStore) {
@@ skipping 30 matching lines @@
       NULL};
 
   for (int i = 0; ops[i] != NULL; i++) {
     for (int j = 0; inputs[j] != NULL; j += 2) {
       RawMachineAssemblerTester<int32_t> m;
       Node* a = m.AddNode(inputs[j]);
       Node* b = m.AddNode(inputs[j + 1]);
       Node* binop = m.AddNode(ops[i], a, b);
       Node* base = m.PointerConstant(&result);
       Node* zero = m.IntPtrConstant(0);
-      m.Store(kMachFloat32, base, zero, binop);
+      m.Store(StoreRepForType(kMachFloat32), base, zero, binop);
       m.Return(m.Int32Constant(i + j));
       CHECK_EQ(i + j, m.Call());
     }
   }
 }
 
 
 TEST(RunFloat64Binop) {
   RawMachineAssemblerTester<int32_t> m;
   double result;
@@ skipping 15 matching lines @@
       NULL};
 
   for (int i = 0; ops[i] != NULL; i++) {
     for (int j = 0; inputs[j] != NULL; j += 2) {
       RawMachineAssemblerTester<int32_t> m;
       Node* a = m.AddNode(inputs[j]);
       Node* b = m.AddNode(inputs[j + 1]);
       Node* binop = m.AddNode(ops[i], a, b);
       Node* base = m.PointerConstant(&result);
       Node* zero = m.Int32Constant(0);
-      m.Store(kMachFloat64, base, zero, binop);
+      m.Store(StoreRepForType(kMachFloat64), base, zero, binop);
       m.Return(m.Int32Constant(i + j));
       CHECK_EQ(i + j, m.Call());
     }
   }
 }
 
 
 TEST(RunDeadFloat32Binops) {
   RawMachineAssemblerTester<int32_t> m;
 
@@ skipping 74 matching lines @@
 
 
 TEST(RunFloat32SubImm1) {
   float input = 0.0f;
   float output = 0.0f;
 
   FOR_FLOAT32_INPUTS(i) {
     RawMachineAssemblerTester<int32_t> m;
     Node* t0 = m.LoadFromPointer(&input, kMachFloat32);
     Node* t1 = m.Float32Sub(m.Float32Constant(*i), t0);
-    m.StoreToPointer(&output, kMachFloat32, t1);
+    m.StoreToPointer(&output, StoreRepForType(kMachFloat32), t1);
     m.Return(m.Int32Constant(0));
     FOR_FLOAT32_INPUTS(j) {
       input = *j;
       float expected = *i - input;
       CHECK_EQ(0, m.Call());
       CheckFloatEq(expected, output);
     }
   }
 }
 
 
 TEST(RunFloat32SubImm2) {
   float input = 0.0f;
   float output = 0.0f;
 
   FOR_FLOAT32_INPUTS(i) {
     RawMachineAssemblerTester<int32_t> m;
     Node* t0 = m.LoadFromPointer(&input, kMachFloat32);
     Node* t1 = m.Float32Sub(t0, m.Float32Constant(*i));
-    m.StoreToPointer(&output, kMachFloat32, t1);
+    m.StoreToPointer(&output, StoreRepForType(kMachFloat32), t1);
     m.Return(m.Int32Constant(0));
     FOR_FLOAT32_INPUTS(j) {
       input = *j;
       float expected = input - *i;
       CHECK_EQ(0, m.Call());
       CheckFloatEq(expected, output);
     }
   }
 }
 
@@ skipping 14 matching lines @@
 
 
 TEST(RunFloat64SubImm1) {
   double input = 0.0;
   double output = 0.0;
 
   FOR_FLOAT64_INPUTS(i) {
     RawMachineAssemblerTester<int32_t> m;
     Node* t0 = m.LoadFromPointer(&input, kMachFloat64);
     Node* t1 = m.Float64Sub(m.Float64Constant(*i), t0);
-    m.StoreToPointer(&output, kMachFloat64, t1);
+    m.StoreToPointer(&output, StoreRepForType(kMachFloat64), t1);
     m.Return(m.Int32Constant(0));
     FOR_FLOAT64_INPUTS(j) {
       input = *j;
       double expected = *i - input;
       CHECK_EQ(0, m.Call());
       CheckDoubleEq(expected, output);
     }
   }
 }
 
 
 TEST(RunFloat64SubImm2) {
   double input = 0.0;
   double output = 0.0;
 
   FOR_FLOAT64_INPUTS(i) {
     RawMachineAssemblerTester<int32_t> m;
     Node* t0 = m.LoadFromPointer(&input, kMachFloat64);
     Node* t1 = m.Float64Sub(t0, m.Float64Constant(*i));
-    m.StoreToPointer(&output, kMachFloat64, t1);
+    m.StoreToPointer(&output, StoreRepForType(kMachFloat64), t1);
     m.Return(m.Int32Constant(0));
     FOR_FLOAT64_INPUTS(j) {
       input = *j;
       double expected = input - *i;
       CHECK_EQ(0, m.Call());
       CheckDoubleEq(expected, output);
     }
   }
 }
 
@@ skipping 32 matching lines @@
   double input_a = 0.0;
   double input_b = 0.0;
   double input_c = 0.0;
   double output = 0.0;
 
   {
     RawMachineAssemblerTester<int32_t> m;
     Node* a = m.LoadFromPointer(&input_a, kMachFloat64);
     Node* b = m.LoadFromPointer(&input_b, kMachFloat64);
     Node* c = m.LoadFromPointer(&input_c, kMachFloat64);
-    m.StoreToPointer(&output, kMachFloat64,
+    m.StoreToPointer(&output, StoreRepForType(kMachFloat64),
                      m.Float64Add(m.Float64Mul(a, b), c));
     m.Return(m.Int32Constant(0));
     FOR_FLOAT64_INPUTS(i) {
       FOR_FLOAT64_INPUTS(j) {
         FOR_FLOAT64_INPUTS(k) {
           input_a = *i;
           input_b = *j;
           input_c = *k;
           volatile double temp = input_a * input_b;
           volatile double expected = temp + input_c;
           CHECK_EQ(0, m.Call());
           CheckDoubleEq(expected, output);
         }
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Node* a = m.LoadFromPointer(&input_a, kMachFloat64);
     Node* b = m.LoadFromPointer(&input_b, kMachFloat64);
     Node* c = m.LoadFromPointer(&input_c, kMachFloat64);
-    m.StoreToPointer(&output, kMachFloat64,
+    m.StoreToPointer(&output, StoreRepForType(kMachFloat64),
                      m.Float64Add(a, m.Float64Mul(b, c)));
     m.Return(m.Int32Constant(0));
     FOR_FLOAT64_INPUTS(i) {
       FOR_FLOAT64_INPUTS(j) {
         FOR_FLOAT64_INPUTS(k) {
           input_a = *i;
           input_b = *j;
           input_c = *k;
           volatile double temp = input_b * input_c;
           volatile double expected = input_a + temp;
           CHECK_EQ(0, m.Call());
           CheckDoubleEq(expected, output);
         }
       }
     }
   }
 }
 
 
 TEST(RunFloat64MulAndFloat64SubP) {
   double input_a = 0.0;
   double input_b = 0.0;
   double input_c = 0.0;
   double output = 0.0;
 
   RawMachineAssemblerTester<int32_t> m;
   Node* a = m.LoadFromPointer(&input_a, kMachFloat64);
   Node* b = m.LoadFromPointer(&input_b, kMachFloat64);
   Node* c = m.LoadFromPointer(&input_c, kMachFloat64);
-  m.StoreToPointer(&output, kMachFloat64, m.Float64Sub(a, m.Float64Mul(b, c)));
+  m.StoreToPointer(&output, StoreRepForType(kMachFloat64),
+                   m.Float64Sub(a, m.Float64Mul(b, c)));
   m.Return(m.Int32Constant(0));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) {
       FOR_FLOAT64_INPUTS(k) {
         input_a = *i;
         input_b = *j;
         input_c = *k;
         volatile double temp = input_b * input_c;
         volatile double expected = input_a - temp;
         CHECK_EQ(0, m.Call());
         CheckDoubleEq(expected, output);
       }
     }
   }
 }
 
 
 TEST(RunFloat64MulImm) {
   double input = 0.0;
   double output = 0.0;
 
   {
     FOR_FLOAT64_INPUTS(i) {
       RawMachineAssemblerTester<int32_t> m;
       Node* t0 = m.LoadFromPointer(&input, kMachFloat64);
       Node* t1 = m.Float64Mul(m.Float64Constant(*i), t0);
-      m.StoreToPointer(&output, kMachFloat64, t1);
+      m.StoreToPointer(&output, StoreRepForType(kMachFloat64), t1);
       m.Return(m.Int32Constant(0));
       FOR_FLOAT64_INPUTS(j) {
         input = *j;
         double expected = *i * input;
         CHECK_EQ(0, m.Call());
         CheckDoubleEq(expected, output);
       }
     }
   }
   {
     FOR_FLOAT64_INPUTS(i) {
       RawMachineAssemblerTester<int32_t> m;
       Node* t0 = m.LoadFromPointer(&input, kMachFloat64);
       Node* t1 = m.Float64Mul(t0, m.Float64Constant(*i));
-      m.StoreToPointer(&output, kMachFloat64, t1);
+      m.StoreToPointer(&output, StoreRepForType(kMachFloat64), t1);
       m.Return(m.Int32Constant(0));
       FOR_FLOAT64_INPUTS(j) {
         input = *j;
         double expected = input * *i;
         CHECK_EQ(0, m.Call());
         CheckDoubleEq(expected, output);
       }
     }
   }
 }
@@ skipping 44 matching lines @@
   }
 }
 
 
 TEST(RunChangeInt32ToFloat64_A) {
   RawMachineAssemblerTester<int32_t> m;
   int32_t magic = 0x986234;
   double result = 0;
 
   Node* convert = m.ChangeInt32ToFloat64(m.Int32Constant(magic));
-  m.Store(kMachFloat64, m.PointerConstant(&result), m.Int32Constant(0),
-          convert);
+  m.Store(StoreRepForType(kMachFloat64), m.PointerConstant(&result),
+          m.Int32Constant(0), convert);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(static_cast<double>(magic), result);
 }
 
 
 TEST(RunChangeInt32ToFloat64_B) {
   RawMachineAssemblerTester<int32_t> m(kMachInt32);
   double output = 0;
 
   Node* convert = m.ChangeInt32ToFloat64(m.Parameter(0));
-  m.Store(kMachFloat64, m.PointerConstant(&output), m.Int32Constant(0),
-          convert);
+  m.Store(StoreRepForType(kMachFloat64), m.PointerConstant(&output),
+          m.Int32Constant(0), convert);
   m.Return(m.Parameter(0));
 
   FOR_INT32_INPUTS(i) {
     int32_t expect = *i;
     CHECK_EQ(expect, m.Call(expect));
     CHECK_EQ(static_cast<double>(expect), output);
   }
 }
 
 
 TEST(RunChangeUint32ToFloat64_B) {
   RawMachineAssemblerTester<uint32_t> m(kMachUint32);
   double output = 0;
 
   Node* convert = m.ChangeUint32ToFloat64(m.Parameter(0));
-  m.Store(kMachFloat64, m.PointerConstant(&output), m.Int32Constant(0),
-          convert);
+  m.Store(StoreRepForType(kMachFloat64), m.PointerConstant(&output),
+          m.Int32Constant(0), convert);
   m.Return(m.Parameter(0));
 
   FOR_UINT32_INPUTS(i) {
     uint32_t expect = *i;
     CHECK_EQ(expect, m.Call(expect));
     CHECK_EQ(static_cast<double>(expect), output);
   }
 }
 
 
 TEST(RunChangeUint32ToFloat64_spilled) {
   RawMachineAssemblerTester<int32_t> m;
   const int kNumInputs = 32;
   int32_t magic = 0x786234;
   uint32_t input[kNumInputs];
   double result[kNumInputs];
   Node* input_node[kNumInputs];
 
   for (int i = 0; i < kNumInputs; i++) {
     input_node[i] =
         m.Load(kMachUint32, m.PointerConstant(&input), m.Int32Constant(i * 4));
   }
 
   for (int i = 0; i < kNumInputs; i++) {
-    m.Store(kMachFloat64, m.PointerConstant(&result), m.Int32Constant(i * 8),
-            m.ChangeUint32ToFloat64(input_node[i]));
+    m.Store(StoreRepForType(kMachFloat64), m.PointerConstant(&result),
+            m.Int32Constant(i * 8), m.ChangeUint32ToFloat64(input_node[i]));
   }
 
   m.Return(m.Int32Constant(magic));
 
   for (int i = 0; i < kNumInputs; i++) {
     input[i] = 100 + i;
   }
 
   CHECK_EQ(magic, m.Call());
 
   for (int i = 0; i < kNumInputs; i++) {
     CHECK_EQ(result[i], static_cast<double>(100 + i));
   }
 }
 
 
 TEST(RunChangeFloat64ToInt32_A) {
   RawMachineAssemblerTester<int32_t> m;
   int32_t magic = 0x786234;
   double input = 11.1;
   int32_t result = 0;
 
-  m.Store(kMachInt32, m.PointerConstant(&result), m.Int32Constant(0),
-          m.ChangeFloat64ToInt32(m.Float64Constant(input)));
+  m.Store(StoreRepForType(kMachInt32), m.PointerConstant(&result),
+          m.Int32Constant(0), m.ChangeFloat64ToInt32(m.Float64Constant(input)));
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(static_cast<int32_t>(input), result);
 }
 
 
 TEST(RunChangeFloat64ToInt32_B) {
   RawMachineAssemblerTester<int32_t> m;
   double input = 0;
   int32_t output = 0;
 
   Node* load =
       m.Load(kMachFloat64, m.PointerConstant(&input), m.Int32Constant(0));
   Node* convert = m.ChangeFloat64ToInt32(load);
-  m.Store(kMachInt32, m.PointerConstant(&output), m.Int32Constant(0), convert);
+  m.Store(StoreRepForType(kMachInt32), m.PointerConstant(&output),
+          m.Int32Constant(0), convert);
   m.Return(convert);
 
   {
     FOR_INT32_INPUTS(i) {
       input = *i;
       int32_t expect = *i;
       CHECK_EQ(expect, m.Call());
       CHECK_EQ(expect, output);
     }
   }
@@ skipping 20 matching lines @@
 
 
 TEST(RunChangeFloat64ToUint32_B) {
   RawMachineAssemblerTester<int32_t> m;
   double input = 0;
   int32_t output = 0;
 
   Node* load =
       m.Load(kMachFloat64, m.PointerConstant(&input), m.Int32Constant(0));
   Node* convert = m.ChangeFloat64ToUint32(load);
-  m.Store(kMachInt32, m.PointerConstant(&output), m.Int32Constant(0), convert);
+  m.Store(StoreRepForType(kMachInt32), m.PointerConstant(&output),
+          m.Int32Constant(0), convert);
   m.Return(convert);
 
   {
     FOR_UINT32_INPUTS(i) {
       input = *i;
       // TODO(titzer): add a CheckEqualsHelper overload for uint32_t.
       int32_t expect = static_cast<int32_t>(*i);
       CHECK_EQ(expect, m.Call());
       CHECK_EQ(expect, output);
     }
@@ skipping 27 matching lines @@
   double input[kNumInputs];
   int32_t result[kNumInputs];
   Node* input_node[kNumInputs];
 
   for (int i = 0; i < kNumInputs; i++) {
     input_node[i] =
         m.Load(kMachFloat64, m.PointerConstant(&input), m.Int32Constant(i * 8));
   }
 
   for (int i = 0; i < kNumInputs; i++) {
-    m.Store(kMachInt32, m.PointerConstant(&result), m.Int32Constant(i * 4),
-            m.ChangeFloat64ToInt32(input_node[i]));
+    m.Store(StoreRepForType(kMachInt32), m.PointerConstant(&result),
+            m.Int32Constant(i * 4), m.ChangeFloat64ToInt32(input_node[i]));
   }
 
   m.Return(m.Int32Constant(magic));
 
   for (int i = 0; i < kNumInputs; i++) {
     input[i] = 100.9 + i;
   }
 
   CHECK_EQ(magic, m.Call());
 
@@ skipping 10 matching lines @@
   double input[kNumInputs];
   uint32_t result[kNumInputs];
   Node* input_node[kNumInputs];
 
   for (int i = 0; i < kNumInputs; i++) {
     input_node[i] =
         m.Load(kMachFloat64, m.PointerConstant(&input), m.Int32Constant(i * 8));
   }
 
   for (int i = 0; i < kNumInputs; i++) {
-    m.Store(kMachUint32, m.PointerConstant(&result), m.Int32Constant(i * 4),
-            m.ChangeFloat64ToUint32(input_node[i]));
+    m.Store(StoreRepForType(kMachUint32), m.PointerConstant(&result),
+            m.Int32Constant(i * 4), m.ChangeFloat64ToUint32(input_node[i]));
   }
 
   m.Return(m.Int32Constant(magic));
 
   for (int i = 0; i < kNumInputs; i++) {
     if (i % 2) {
       input[i] = 100 + i + 2147483648u;
     } else {
       input[i] = 100 + i;
     }
@@ skipping 18 matching lines @@
   double input[kNumInputs];
   float result[kNumInputs];
   Node* input_node[kNumInputs];
 
   for (int i = 0; i < kNumInputs; i++) {
     input_node[i] =
         m.Load(kMachFloat64, m.PointerConstant(&input), m.Int32Constant(i * 8));
   }
 
   for (int i = 0; i < kNumInputs; i++) {
-    m.Store(kMachFloat32, m.PointerConstant(&result), m.Int32Constant(i * 4),
-            m.TruncateFloat64ToFloat32(input_node[i]));
+    m.Store(StoreRepForType(kMachFloat32), m.PointerConstant(&result),
+            m.Int32Constant(i * 4), m.TruncateFloat64ToFloat32(input_node[i]));
   }
 
   m.Return(m.Int32Constant(magic));
 
   for (int i = 0; i < kNumInputs; i++) {
     input[i] = 0.1 + i;
   }
 
   CHECK_EQ(magic, m.Call());
 
@@ skipping 54 matching lines @@
   MLabel 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);
+  m.Store(StoreRepForType(kMachFloat32), m.PointerConstant(&buffer),
+          m.IntPtrConstant(0), phi);
   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;
 
   MLabel blocka, blockb, end;
   Node* k1 = m.Float64Constant(constant);
   Node* k2 = m.Float64Constant(0 - constant);
   m.Branch(m.Int32Constant(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&end);
   m.Bind(&blockb);
   m.Goto(&end);
   m.Bind(&end);
   Node* phi = m.Phi(kMachFloat64, k2, k1);
-  m.Store(kMachFloat64, m.PointerConstant(&buffer), m.Int32Constant(0), phi);
+  m.Store(StoreRepForType(kMachFloat64), m.PointerConstant(&buffer),
+          m.Int32Constant(0), phi);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(constant, buffer);
 }
 
 
 TEST(RunRefDiamond) {
   RawMachineAssemblerTester<int32_t> m;
 
   const int magic = 99644;
   Handle<String> rexpected =
       CcTest::i_isolate()->factory()->InternalizeUtf8String("A");
   String* buffer;
 
   MLabel blocka, blockb, end;
   Node* k1 = m.StringConstant("A");
   Node* k2 = m.StringConstant("B");
   m.Branch(m.Int32Constant(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&end);
   m.Bind(&blockb);
   m.Goto(&end);
   m.Bind(&end);
   Node* phi = m.Phi(kMachAnyTagged, k2, k1);
-  m.Store(kMachAnyTagged, m.PointerConstant(&buffer), m.Int32Constant(0), phi);
+  m.Store(StoreRepForType(kMachAnyTagged), m.PointerConstant(&buffer),
+          m.Int32Constant(0), phi);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK(rexpected->SameValue(buffer));
 }
 
 
 TEST(RunDoubleRefDiamond) {
   RawMachineAssemblerTester<int32_t> m;
 
@@ skipping 10 matching lines @@
   Node* r1 = m.StringConstant("AX");
   Node* r2 = m.StringConstant("BX");
   m.Branch(m.Int32Constant(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&end);
   m.Bind(&blockb);
   m.Goto(&end);
   m.Bind(&end);
   Node* dphi = m.Phi(kMachFloat64, d2, d1);
   Node* rphi = m.Phi(kMachAnyTagged, r2, r1);
-  m.Store(kMachFloat64, m.PointerConstant(&dbuffer), m.Int32Constant(0), dphi);
-  m.Store(kMachAnyTagged, m.PointerConstant(&rbuffer), m.Int32Constant(0),
-          rphi);
+  m.Store(StoreRepForType(kMachFloat64), m.PointerConstant(&dbuffer),
+          m.Int32Constant(0), dphi);
+  m.Store(StoreRepForType(kMachAnyTagged), m.PointerConstant(&rbuffer),
+          m.Int32Constant(0), rphi);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(dconstant, dbuffer);
   CHECK(rexpected->SameValue(rbuffer));
 }
 
 
 TEST(RunDoubleRefDoubleDiamond) {
   RawMachineAssemblerTester<int32_t> m;
@@ skipping 21 matching lines @@
   m.Branch(m.Int32Constant(0), &blockd, &blocke);
 
   m.Bind(&blockd);
   m.Goto(&end);
   m.Bind(&blocke);
   m.Goto(&end);
   m.Bind(&end);
   Node* dphi2 = m.Phi(kMachFloat64, d1, dphi1);
   Node* rphi2 = m.Phi(kMachAnyTagged, r1, rphi1);
 
-  m.Store(kMachFloat64, m.PointerConstant(&dbuffer), m.Int32Constant(0), dphi2);
-  m.Store(kMachAnyTagged, m.PointerConstant(&rbuffer), m.Int32Constant(0),
-          rphi2);
+  m.Store(StoreRepForType(kMachFloat64), m.PointerConstant(&dbuffer),
+          m.Int32Constant(0), dphi2);
+  m.Store(StoreRepForType(kMachAnyTagged), m.PointerConstant(&rbuffer),
+          m.Int32Constant(0), rphi2);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(dconstant, dbuffer);
   CHECK(rexpected->SameValue(rbuffer));
 }
 
 
 TEST(RunDoubleLoopPhi) {
   RawMachineAssemblerTester<int32_t> m;
   MLabel header, body, end;
 
   int magic = 99773;
   double buffer = 0.99;
   double dconstant = 777.1;
 
   Node* zero = m.Int32Constant(0);
   Node* dk = m.Float64Constant(dconstant);
 
   m.Goto(&header);
   m.Bind(&header);
   Node* phi = m.Phi(kMachFloat64, 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);
+  m.Store(StoreRepForType(kMachFloat64), m.PointerConstant(&buffer),
+          m.Int32Constant(0), phi);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
 }
 
 
 TEST(RunCountToTenAccRaw) {
   RawMachineAssemblerTester<int32_t> m;
 
   Node* zero = m.Int32Constant(0);
@@ skipping 273 matching lines @@
 }
 
 
 template <typename IntType, MachineType kRepresentation>
 static void LoadStoreTruncation() {
   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, StoreRepForType(kRepresentation), 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 82 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));
+    m.Store(StoreRepForType(kMachInt32), output, m.Load(kMachInt32, input));
     input = m.IntPtrAdd(input, elem_size);
     output = m.IntPtrSub(output, elem_size);
   }
   m.Return(input);
   CHECK_EQ(&inputs[kInputSize], m.Call());
   for (int i = 0; i < kInputSize; i++) {
     CHECK_EQ(i, inputs[i]);
     CHECK_EQ(kInputSize - i - 1, outputs[i]);
   }
 }
 
 
 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], StoreRepForType(kMachInt32), 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);
   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], StoreRepForType(kMachInt32), 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, kMachInt32, val);
+  m.StoreToPointer(&actual_val, StoreRepForType(kMachInt32), 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);
       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, StoreRepForType(kMachInt32), 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);
       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, StoreRepForType(kMachInt32), 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, StoreRepForType(kMachInt32), 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, StoreRepForType(kMachInt32), 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);
       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, StoreRepForType(kMachInt32), 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);
       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, StoreRepForType(kMachInt32), 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, StoreRepForType(kMachInt32), 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(kMachInt32);
-  m.StoreToPointer(&actual, kMachInt64, m.ChangeInt32ToInt64(m.Parameter(0)));
+  m.StoreToPointer(&actual, StoreRepForType(kMachInt64),
+                   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,
+  m.StoreToPointer(&actual, StoreRepForType(kMachUint64),
                    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 80 matching lines @@
     CHECK_EQ(static_cast<int>(expected), m.Call());
   }
 }
 
 
 TEST(RunChangeFloat32ToFloat64) {
   double actual = 0.0f;
   float expected = 0.0;
   RawMachineAssemblerTester<int32_t> m;
   m.StoreToPointer(
-      &actual, kMachFloat64,
+      &actual, StoreRepForType(kMachFloat64),
       m.ChangeFloat32ToFloat64(m.LoadFromPointer(&expected, kMachFloat32)));
   m.Return(m.Int32Constant(0));
   FOR_FLOAT32_INPUTS(i) {
     expected = *i;
     CHECK_EQ(0, m.Call());
     CHECK_EQ(static_cast<double>(expected), actual);
   }
 }
 
 
 TEST(RunChangeFloat32ToFloat64_spilled) {
   RawMachineAssemblerTester<int32_t> m;
   const int kNumInputs = 32;
   int32_t magic = 0x786234;
   float input[kNumInputs];
   double result[kNumInputs];
   Node* input_node[kNumInputs];
 
   for (int i = 0; i < kNumInputs; i++) {
     input_node[i] =
         m.Load(kMachFloat32, m.PointerConstant(&input), m.Int32Constant(i * 4));
   }
 
   for (int i = 0; i < kNumInputs; i++) {
-    m.Store(kMachFloat64, m.PointerConstant(&result), m.Int32Constant(i * 8),
-            m.ChangeFloat32ToFloat64(input_node[i]));
+    m.Store(StoreRepForType(kMachFloat64), m.PointerConstant(&result),
+            m.Int32Constant(i * 8), m.ChangeFloat32ToFloat64(input_node[i]));
   }
 
   m.Return(m.Int32Constant(magic));
 
   for (int i = 0; i < kNumInputs; i++) {
     input[i] = 100.9f + i;
   }
 
   CHECK_EQ(magic, m.Call());
 
   for (int i = 0; i < kNumInputs; i++) {
     CHECK_EQ(result[i], static_cast<double>(input[i]));
   }
 }
 
 
 TEST(RunTruncateFloat64ToFloat32) {
   float actual = 0.0f;
   double input = 0.0;
   RawMachineAssemblerTester<int32_t> m;
   m.StoreToPointer(
-      &actual, kMachFloat32,
+      &actual, StoreRepForType(kMachFloat32),
       m.TruncateFloat64ToFloat32(m.LoadFromPointer(&input, kMachFloat64)));
   m.Return(m.Int32Constant(0));
   FOR_FLOAT64_INPUTS(i) {
     input = *i;
     volatile double expected = DoubleToFloat32(input);
     CHECK_EQ(0, m.Call());
     CheckDoubleEq(expected, actual);
   }
 }
 
 
 TEST(RunFloat32Constant) {
   FOR_FLOAT32_INPUTS(i) {
     float expected = *i;
     float actual = *i;
     RawMachineAssemblerTester<int32_t> m;
-    m.StoreToPointer(&actual, kMachFloat32, m.Float32Constant(expected));
+    m.StoreToPointer(&actual, StoreRepForType(kMachFloat32),
+                     m.Float32Constant(expected));
     m.Return(m.Int32Constant(0));
     CHECK_EQ(0, m.Call());
     CHECK_EQ(expected, actual);
   }
 }
 
 
 TEST(RunFloat64ExtractLowWord32) {
   uint64_t input = 0;
   RawMachineAssemblerTester<int32_t> m;
@@ skipping 16 matching lines @@
     CHECK_EQ(expected, m.Call());
   }
 }
 
 
 TEST(RunFloat64InsertLowWord32) {
   uint64_t input = 0;
   uint64_t result = 0;
   RawMachineAssemblerTester<int32_t> m(kMachInt32);
   m.StoreToPointer(
-      &result, kMachFloat64,
+      &result, StoreRepForType(kMachFloat64),
       m.Float64InsertLowWord32(m.LoadFromPointer(&input, kMachFloat64),
                                m.Parameter(0)));
   m.Return(m.Int32Constant(0));
   FOR_FLOAT64_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       input = bit_cast<uint64_t>(*i);
       uint64_t expected = (input & ~(V8_UINT64_C(0xFFFFFFFF))) |
                           (static_cast<uint64_t>(bit_cast<uint32_t>(*j)));
       CHECK_EQ(0, m.Call(*j));
       CHECK_EQ(expected, result);
     }
   }
 }
 
 
 TEST(RunFloat64InsertHighWord32) {
   uint64_t input = 0;
   uint64_t result = 0;
   RawMachineAssemblerTester<int32_t> m(kMachInt32);
   m.StoreToPointer(
-      &result, kMachFloat64,
+      &result, StoreRepForType(kMachFloat64),
       m.Float64InsertHighWord32(m.LoadFromPointer(&input, kMachFloat64),
                                 m.Parameter(0)));
   m.Return(m.Int32Constant(0));
   FOR_FLOAT64_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       input = bit_cast<uint64_t>(*i);
       uint64_t expected = (input & ~(V8_UINT64_C(0xFFFFFFFF) << 32)) |
                           (static_cast<uint64_t>(bit_cast<uint32_t>(*j)) << 32);
       CHECK_EQ(0, m.Call(*j));
       CHECK_EQ(expected, result);
     }
   }
 }
 
 
 TEST(RunFloat32Abs) {
   float input = -1.0;
   float result = 0.0;
   RawMachineAssemblerTester<int32_t> m;
-  m.StoreToPointer(&result, kMachFloat32,
+  m.StoreToPointer(&result, StoreRepForType(kMachFloat32),
                    m.Float32Abs(m.LoadFromPointer(&input, kMachFloat32)));
   m.Return(m.Int32Constant(0));
   FOR_FLOAT32_INPUTS(i) {
     input = *i;
     float expected = std::abs(input);
     CHECK_EQ(0, m.Call());
     CheckFloatEq(expected, result);
   }
 }
 
 
 TEST(RunFloat64Abs) {
   double input = -1.0;
   double result = 0.0;
   RawMachineAssemblerTester<int32_t> m;
-  m.StoreToPointer(&result, kMachFloat64,
+  m.StoreToPointer(&result, StoreRepForType(kMachFloat64),
                    m.Float64Abs(m.LoadFromPointer(&input, kMachFloat64)));
   m.Return(m.Int32Constant(0));
   FOR_FLOAT64_INPUTS(i) {
     input = *i;
     double expected = std::abs(input);
     CHECK_EQ(0, m.Call());
     CheckDoubleEq(expected, result);
   }
 }
 
@@ skipping 94 matching lines @@
                            -two_52 + 1 - 0.1,
                            -two_52 + 1 - 0.5,
                            -two_52 + 1 - 0.7};
 
 
 TEST(RunFloat64RoundDown1) {
   double input = -1.0;
   double result = 0.0;
   RawMachineAssemblerTester<int32_t> m;
   if (!m.machine()->Float64RoundDown().IsSupported()) return;
-  m.StoreToPointer(&result, kMachFloat64,
+  m.StoreToPointer(&result, StoreRepForType(kMachFloat64),
                    m.Float64RoundDown(m.LoadFromPointer(&input, kMachFloat64)));
   m.Return(m.Int32Constant(0));
   for (size_t i = 0; i < arraysize(kValues); ++i) {
     input = kValues[i];
     CHECK_EQ(0, m.Call());
     double expected = std::floor(kValues[i]);
     CHECK_EQ(expected, result);
   }
 }
 
 
 TEST(RunFloat64RoundDown2) {
   double input = -1.0;
   double result = 0.0;
   RawMachineAssemblerTester<int32_t> m;
   if (!m.machine()->Float64RoundDown().IsSupported()) return;
-  m.StoreToPointer(&result, kMachFloat64,
+  m.StoreToPointer(&result, StoreRepForType(kMachFloat64),
                    m.Float64Sub(m.Float64Constant(-0.0),
                                 m.Float64RoundDown(m.Float64Sub(
                                     m.Float64Constant(-0.0),
                                     m.LoadFromPointer(&input, kMachFloat64)))));
   m.Return(m.Int32Constant(0));
   for (size_t i = 0; i < arraysize(kValues); ++i) {
     input = kValues[i];
     CHECK_EQ(0, m.Call());
     double expected = std::ceil(kValues[i]);
     CHECK_EQ(expected, result);
   }
 }
 
 
 TEST(RunFloat64RoundTruncate) {
   double input = -1.0;
   double result = 0.0;
   RawMachineAssemblerTester<int32_t> m;
   if (!m.machine()->Float64RoundTruncate().IsSupported()) return;
   m.StoreToPointer(
-      &result, kMachFloat64,
+      &result, StoreRepForType(kMachFloat64),
       m.Float64RoundTruncate(m.LoadFromPointer(&input, kMachFloat64)));
   m.Return(m.Int32Constant(0));
   for (size_t i = 0; i < arraysize(kValues); ++i) {
     input = kValues[i];
     CHECK_EQ(0, m.Call());
     double expected = trunc(kValues[i]);
     CHECK_EQ(expected, result);
   }
 }
 
 
 TEST(RunFloat64RoundTiesAway) {
   double input = -1.0;
   double result = 0.0;
   RawMachineAssemblerTester<int32_t> m;
   if (!m.machine()->Float64RoundTiesAway().IsSupported()) return;
   m.StoreToPointer(
-      &result, kMachFloat64,
+      &result, StoreRepForType(kMachFloat64),
       m.Float64RoundTiesAway(m.LoadFromPointer(&input, kMachFloat64)));
   m.Return(m.Int32Constant(0));
   for (size_t i = 0; i < arraysize(kValues); ++i) {
     input = kValues[i];
     CHECK_EQ(0, m.Call());
     double expected = round(kValues[i]);
     CHECK_EQ(expected, result);
   }
 }
 
@@ skipping 119 matching lines @@
   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,
+      &output, StoreRepForType(kMachFloat64),
       m.BitcastInt64ToFloat64(m.LoadFromPointer(&input, kMachInt64)));
   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) {
   double input = 0;
   int64_t output = 0;
   RawMachineAssemblerTester<int32_t> m;
   m.StoreToPointer(
-      &output, kMachInt64,
+      &output, StoreRepForType(kMachInt64),
       m.BitcastFloat64ToInt64(m.LoadFromPointer(&input, kMachFloat64)));
   m.Return(m.Int32Constant(11));
   FOR_FLOAT64_INPUTS(i) {
     input = *i;
     CHECK_EQ(11, m.Call());
     double expected = bit_cast<int64_t>(input);
     CHECK_EQ(expected, output);
   }
 }
 #endif
 
 
 TEST(RunBitcastFloat32ToInt32) {
   float input = 32.25;
   RawMachineAssemblerTester<int32_t> m;
   m.Return(m.BitcastFloat32ToInt32(m.LoadFromPointer(&input, kMachFloat32)));
   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,
+      &output, StoreRepForType(kMachFloat32),
       m.BitcastInt32ToFloat32(m.LoadFromPointer(&input, kMachInt32)));
   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 38 matching lines @@
       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));
 }