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

test/cctest/compiler/test-run-native-calls.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/assembler.h"
 #include "src/codegen.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/raw-machine-assembler.h"
 #include "src/machine-type.h"
 #include "src/register-configuration.h"
@@ skipping 340 matching lines @@
   }
 
   Node* LoadInput(RawMachineAssembler& raw, Node* base, int index) {
     Node* offset = raw.Int32Constant(index * sizeof(CType));
     return raw.Load(MachineTypeForC<CType>(), base, offset);
   }
 
   Node* StoreOutput(RawMachineAssembler& raw, Node* value) {
     Node* base = raw.PointerConstant(&output);
     Node* offset = raw.Int32Constant(0);
-    return raw.Store(MachineTypeForC<CType>(), base, offset, value,
-                     kNoWriteBarrier);
+    return raw.Store(MachineTypeForC<CType>().representation(), base, offset,
+                     value, kNoWriteBarrier);
   }
 
   // Computes the next set of inputs by updating the {input} array.
   void Mutate();
 
   void Reset() { memset(input, 0, sizeof(input)); }
 
   int count_;
   int seed_;
   CType input[kMaxParamCount];
@@ skipping 189 matching lines @@
   HandleScope scope(isolate);
   Handle<Code> inner = Handle<Code>::null();
   {
     // Writes all parameters into the output buffer.
     Zone zone;
     Graph graph(&zone);
     RawMachineAssembler raw(isolate, &graph, desc);
     Node* base = raw.PointerConstant(output);
     for (int i = 0; i < kNumParams; i++) {
       Node* offset = raw.Int32Constant(i * sizeof(int32_t));
-      raw.Store(MachineType::Int32(), base, offset, raw.Parameter(i),
+      raw.Store(MachineRepresentation::kWord32, base, offset, raw.Parameter(i),
                 kNoWriteBarrier);
     }
     raw.Return(raw.Int32Constant(42));
     inner = CompileGraph("CopyTwentyInt32", desc, &graph, raw.Export());
   }
 
   CSignature0<int32_t> csig;
   Handle<Code> wrapper = Handle<Code>::null();
   {
     // Loads parameters from the input buffer and calls the above code.
@@ skipping 543 matching lines @@
             konst = raw.Float64Constant(value[0]);
             if (i == which) memcpy(bytes, value, expected_size = 8);
           }
           CHECK_NOT_NULL(konst);
 
           args[i] = konst;
           constant += 0x1010101010101010;
         }
 
         Node* call = raw.CallN(desc, target, args);
-        Node* store = raw.StoreToPointer(output, sig->GetReturn(), call);
+        Node* store =
+            raw.StoreToPointer(output, sig->GetReturn().representation(), call);
         USE(store);
         expected_ret = static_cast<int32_t>(constant);
         raw.Return(raw.Int32Constant(expected_ret));
         wrapper = CompileGraph("Select-mixed-wrapper-const", cdesc, &graph,
                                raw.Export());
       }
 
       CodeRunner<int32_t> runnable(isolate, wrapper, &csig);
       CHECK_EQ(expected_ret, runnable.Call());
       for (int i = 0; i < expected_size; i++) {
         CHECK_EQ(static_cast<int>(bytes[i]), static_cast<int>(output[i]));
       }
     }
   }
 }
 
 
 TEST(MixedParams_0) { MixedParamTest(0); }
 TEST(MixedParams_1) { MixedParamTest(1); }
 TEST(MixedParams_2) { MixedParamTest(2); }
 TEST(MixedParams_3) { MixedParamTest(3); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8