Fix build problems on Windows 64-bit by casting.

test/cctest/test-heap.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 
 #include <stdlib.h>
 
 #include "v8.h"
 
 #include "execution.h"
 #include "factory.h"
 #include "macro-assembler.h"
 #include "global-handles.h"
@@ skipping 803 matching lines @@
 TEST(LargeObjectSpaceContains) {
   InitializeVM();
 
   int free_bytes = Heap::MaxObjectSizeInPagedSpace();
   CHECK(Heap::CollectGarbage(free_bytes, NEW_SPACE));
 
   Address current_top = Heap::new_space()->top();
   Page* page = Page::FromAddress(current_top);
   Address current_page = page->address();
   Address next_page = current_page + Page::kPageSize;
-  int bytes_to_page = next_page - current_top;
+  int bytes_to_page = static_cast<int>(next_page - current_top);
   if (bytes_to_page <= FixedArray::kHeaderSize) {
     // Alas, need to cross another page to be able to
     // put desired value.
     next_page += Page::kPageSize;
-    bytes_to_page = next_page - current_top;
+    bytes_to_page = static_cast<int>(next_page - current_top);
   }
   CHECK(bytes_to_page > FixedArray::kHeaderSize);
 
   int* is_normal_page_ptr = &Page::FromAddress(next_page)->is_normal_page;
   Address is_normal_page_addr = reinterpret_cast<Address>(is_normal_page_ptr);
 
-  int bytes_to_allocate = (is_normal_page_addr - current_top) + kPointerSize;
+  int bytes_to_allocate =
+      static_cast<int>(is_normal_page_addr - current_top) + kPointerSize;
 
   int n_elements = (bytes_to_allocate - FixedArray::kHeaderSize) /
       kPointerSize;
   CHECK_EQ(bytes_to_allocate, FixedArray::SizeFor(n_elements));
   FixedArray* array = FixedArray::cast(
       Heap::AllocateFixedArray(n_elements));
 
   int index = n_elements - 1;
   CHECK_EQ(is_normal_page_ptr,
            HeapObject::RawField(array, FixedArray::OffsetOfElementAt(index)));
@@ skipping 63 matching lines @@
   Address* top_addr = new_space->allocation_top_address();
   Address* limit_addr = new_space->allocation_limit_address();
   while ((*limit_addr - *top_addr) > allocation_amount) {
     CHECK(!Heap::always_allocate());
     Object* array = Heap::AllocateFixedArray(allocation_len);
     CHECK(!array->IsFailure());
     CHECK(new_space->Contains(array));
   }
 
   // Step 3: now allocate fixed array and JSObject to fill the whole new space.
-  int to_fill = *limit_addr - *top_addr - object_size;
+  int to_fill = static_cast<int>(*limit_addr - *top_addr - object_size);
   int fixed_array_len = LenFromSize(to_fill);
   CHECK(fixed_array_len < FixedArray::kMaxLength);
 
   CHECK(!Heap::always_allocate());
   Object* array = Heap::AllocateFixedArray(fixed_array_len);
   CHECK(!array->IsFailure());
   CHECK(new_space->Contains(array));
 
   Object* object = Heap::AllocateJSObjectFromMap(*my_map);
   CHECK(!object->IsFailure());
   CHECK(new_space->Contains(object));
   JSObject* jsobject = JSObject::cast(object);
   CHECK_EQ(0, jsobject->elements()->length());
   CHECK_EQ(0, jsobject->properties()->length());
   // Create a reference to object in new space in jsobject.
   jsobject->FastPropertyAtPut(-1, array);
 
-  CHECK_EQ(0L, (*limit_addr - *top_addr));
+  CHECK_EQ(0, static_cast<int>(*limit_addr - *top_addr));
 
   // Step 4: clone jsobject, but force always allocate first to create a clone
   // in old pointer space.
   Address old_pointer_space_top = Heap::old_pointer_space()->top();
   AlwaysAllocateScope aa_scope;
   Object* clone_obj = Heap::CopyJSObject(jsobject);
   CHECK(!object->IsFailure());
   JSObject* clone = JSObject::cast(clone_obj);
   if (clone->address() != old_pointer_space_top) {
     // Alas, got allocated from free list, we cannot do checks.
     return;
   }
   CHECK(Heap::old_pointer_space()->Contains(clone->address()));
 
   // Step 5: verify validity of remembered set.
   Address clone_addr = clone->address();
   Page* page = Page::FromAddress(clone_addr);
   // Check that remembered set tracks a reference from inobject property 1.
   CHECK(page->IsRSetSet(clone_addr, object_size - kPointerSize));
   // Probe several addresses after the object.
   for (int i = 0; i < 7; i++) {
     int offset = object_size + i * kPointerSize;
     if (clone_addr + offset >= page->ObjectAreaEnd()) {
       break;
     }
     CHECK(!page->IsRSetSet(clone_addr, offset));
   }
 }