Fix size_t/int conversions for Win64.

test/cctest/compiler/test-simplified-lowering.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/compiler/control-builders.h"
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/node-properties-inl.h"
@@ skipping 357 matching lines @@
   size_t num_elements;
   E* untagged_array;
   Handle<ByteArray> tagged_array;  // TODO(titzer): use FixedArray for tagged.
 
   AccessTester(bool t, MachineRepresentation r, E* orig, size_t num)
       : tagged(t),
         rep(r),
         original_elements(orig),
         num_elements(num),
         untagged_array(static_cast<E*>(malloc(ByteSize()))),
-        tagged_array(main_isolate()->factory()->NewByteArray(ByteSize())) {
+        tagged_array(main_isolate()->factory()->NewByteArray(
+            static_cast<int>(ByteSize()))) {
     Reinitialize();
   }
 
   ~AccessTester() { free(untagged_array); }
 
   size_t ByteSize() { return num_elements * sizeof(E); }
 
   // Nuke both {untagged_array} and {tagged_array} with {original_elements}.
   void Reinitialize() {
     memcpy(untagged_array, original_elements, ByteSize());
-    CHECK_EQ(ByteSize(), tagged_array->length());
+    CHECK_EQ(static_cast<int>(ByteSize()), tagged_array->length());
     E* raw = reinterpret_cast<E*>(tagged_array->GetDataStartAddress());
     memcpy(raw, original_elements, ByteSize());
   }
 
   // Create and run code that copies the element in either {untagged_array}
   // or {tagged_array} at index {from_index} to index {to_index}.
   void RunCopyElement(int from_index, int to_index) {
     // TODO(titzer): test element and field accesses where the base is not
     // a constant in the code.
     BoundsCheck(from_index);
@@ skipping 103 matching lines @@
 
   template <typename T>
   Node* GetBaseNode(SimplifiedLoweringTester<T>* t) {
     return tagged ? t->HeapConstant(tagged_array)
                   : t->PointerConstant(untagged_array);
   }
 
   void BoundsCheck(int index) {
     CHECK_GE(index, 0);
     CHECK_LT(index, static_cast<int>(num_elements));
-    CHECK_EQ(ByteSize(), tagged_array->length());
+    CHECK_EQ(static_cast<int>(ByteSize()), tagged_array->length());
   }
 };
 
 
 template <typename E>
 static void RunAccessTest(MachineRepresentation rep, E* original_elements,
                           size_t num) {
   int num_elements = static_cast<int>(num);
 
   for (int taggedness = 0; taggedness < 2; taggedness++) {
@@ skipping 839 matching lines @@
 
   Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
                                    t.p1, t.start, t.start);
   t.Effect(store);
   t.Lower();
 
   CHECK_EQ(IrOpcode::kStore, store->opcode());
   CHECK_EQ(t.p0, store->InputAt(0));
   CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p1, store->InputAt(2));
 }