Fix 64-bit VS2010 build

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 <limits>
 #include "src/v8.h"
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/value-helper.h"
@@ skipping 2482 matching lines @@
 
 
 template <typename CType>
 static void RunLoadImmIndex(MachineRepresentation rep) {
   const int kNumElems = 3;
   CType buffer[kNumElems];
 
   // initialize the buffer with raw data.
   byte* raw = reinterpret_cast<byte*>(buffer);
   for (size_t i = 0; i < sizeof(buffer); i++) {
-    raw[i] = (i + sizeof(buffer)) ^ 0xAA;
+    raw[i] = static_cast<byte>((i + sizeof(buffer)) ^ 0xAA);
   }
 
   // Test with various large and small offsets.
   for (int offset = -1; offset <= 200000; offset *= -5) {
     for (int i = 0; i < kNumElems; i++) {
       RawMachineAssemblerTester<CType> m;
       Node* base = m.PointerConstant(buffer - offset);
       Node* index = m.Int32Constant((offset + i) * sizeof(buffer[0]));
       m.Return(m.Load(rep, base, index));
 
@@ skipping 18 matching lines @@
 template <typename CType>
 static void RunLoadStore(MachineRepresentation rep) {
   const int kNumElems = 4;
   CType buffer[kNumElems];
 
   for (int32_t x = 0; x < kNumElems; x++) {
     int32_t y = kNumElems - x - 1;
     // initialize the buffer with raw data.
     byte* raw = reinterpret_cast<byte*>(buffer);
     for (size_t i = 0; i < sizeof(buffer); i++) {
-      raw[i] = (i + sizeof(buffer)) ^ 0xAA;
+      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.Int32Constant(x * sizeof(buffer[0]));
     Node* load = m.Load(rep, base, index0);
     Node* index1 = m.Int32Constant(y * sizeof(buffer[0]));
     m.Store(rep, base, index1, load);
     m.Return(m.Int32Constant(OK));
@@ skipping 1143 matching lines @@
   }
   m.Return(one);
   m.Call();
   for (int i = 0; i < kInputSize; i++) {
     CHECK_EQ(outputs[i], i + 2);
   }
 }
 
 
 TEST(RunSpillConstantsAndParameters) {
-  static const size_t kInputSize = 1000;
+  static const int kInputSize = 1000;
   static const int32_t kBase = 987;
   RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32);
   int32_t outputs[kInputSize];
   Node* csts[kInputSize];
   Node* accs[kInputSize];
   Node* acc = m.Int32Constant(0);
-  for (size_t i = 0; i < kInputSize; i++) {
+  for (int i = 0; i < kInputSize; i++) {
     csts[i] = m.Int32Constant(static_cast<int32_t>(kBase + i));
   }
-  for (size_t i = 0; i < kInputSize; i++) {
+  for (int i = 0; i < kInputSize; i++) {
     acc = m.Int32Add(acc, csts[i]);
     accs[i] = acc;
   }
-  for (size_t i = 0; i < kInputSize; i++) {
+  for (int i = 0; i < kInputSize; i++) {
     m.StoreToPointer(&outputs[i], kMachineWord32, 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 (size_t k = 0; k < kInputSize; k++) {
+      for (int k = 0; k < kInputSize; k++) {
         expected += kBase + k;
       }
       CHECK_EQ(expected, m.Call(*i, *j));
       expected = 0;
-      for (size_t k = 0; k < kInputSize; k++) {
+      for (int k = 0; k < kInputSize; k++) {
         expected += kBase + k;
         CHECK_EQ(expected, outputs[k]);
       }
     }
   }
 }
 
 
 TEST(RunNewSpaceConstantsInPhi) {
   RawMachineAssemblerTester<Object*> m(kMachineWord32);
@@ skipping 46 matching lines @@
   m.Return(one);
   m.Call();
   for (int i = 0; i < kInputSize; i++) {
     CHECK_EQ(outputs[i], i + 2);
   }
 }
 
 #endif  // MACHINE_ASSEMBLER_SUPPORTS_CALL_C
 
 #endif