Make Win64 compile.

src/spaces.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 142 matching lines @@
     return false;
   }
 
   // We are sure that we have mapped a block of requested addresses.
   ASSERT(code_range_->size() == requested);
   LOG(isolate_, NewEvent("CodeRange", code_range_->address(), requested));
   Address base = reinterpret_cast<Address>(code_range_->address());
   Address aligned_base =
       RoundUp(reinterpret_cast<Address>(code_range_->address()),
               MemoryChunk::kAlignment);
-  int size = code_range_->size() - (aligned_base - base);
+  size_t size = code_range_->size() - (aligned_base - base);
   allocation_list_.Add(FreeBlock(aligned_base, size));
   current_allocation_block_index_ = 0;
   return true;
 }
 
 
 int CodeRange::CompareFreeBlockAddress(const FreeBlock* left,
                                        const FreeBlock* right) {
   // The entire point of CodeRange is that the difference between two
   // addresses in the range can be represented as a signed 32-bit int,
@@ skipping 139 matching lines @@
   }
 }
 
 
 Address MemoryAllocator::ReserveAlignedMemory(const size_t requested,
                                               size_t alignment,
                                               size_t* allocated_size) {
   ASSERT(IsAligned(alignment, OS::AllocateAlignment()));
   if (size_ + requested > capacity_) return NULL;
 
-  size_t allocated = RoundUp(requested + alignment, OS::AllocateAlignment());
+  size_t allocated = RoundUp(requested + alignment,
+                             static_cast<intptr_t>(OS::AllocateAlignment()));
 
   Address base = reinterpret_cast<Address>(
       VirtualMemory::ReserveRegion(allocated));
 
   Address end = base + allocated;
 
   if (base == 0) return NULL;
 
   Address aligned_base = RoundUp(base, alignment);
 
@@ skipping 174 matching lines @@
                                  MemoryChunk::kAlignment,
                                  executable,
                                  &chunk_size);
 
     if (base == NULL) return NULL;
   }
 
 #ifdef DEBUG
   ZapBlock(base, chunk_size);
 #endif
-  isolate_->counters()->memory_allocated()->Increment(chunk_size);
+  isolate_->counters()->memory_allocated()->
+      Increment(static_cast<int>(chunk_size));
 
   LOG(isolate_, NewEvent("MemoryChunk", base, chunk_size));
   if (owner != NULL) {
     ObjectSpace space = static_cast<ObjectSpace>(1 << owner->identity());
     PerformAllocationCallback(space, kAllocationActionAllocate, chunk_size);
   }
 
   return MemoryChunk::Initialize(heap,
                                  base,
                                  chunk_size,
@@ skipping 1303 matching lines @@
   int new_node_size = 0;
   FreeListNode* new_node = FindNodeFor(size_in_bytes, &new_node_size);
   if (new_node == NULL) return NULL;
 
   available_ -= new_node_size;
   ASSERT(IsVeryLong() || available_ == SumFreeLists());
 
   int bytes_left = new_node_size - size_in_bytes;
   ASSERT(bytes_left >= 0);
 
-  int old_linear_size = owner_->limit() - owner_->top();
-
+  int old_linear_size = static_cast<int>(owner_->limit() - owner_->top());
   // Mark the old linear allocation area with a free space map so it can be
   // skipped when scanning the heap.  This also puts it back in the free list
   // if it is big enough.
   owner_->Free(owner_->top(), old_linear_size);
   owner_->heap()->incremental_marking()->Step(size_in_bytes - old_linear_size);
 
   const int kThreshold = IncrementalMarking::kAllocatedThreshold;
 
   // Memory in the linear allocation area is counted as allocated.  We may free
   // a little of this again immediately - see below.
@@ skipping 105 matching lines @@
   Address top = allocation_info_.top;
   return limit - top >= bytes;
 }
 
 
 void PagedSpace::PrepareForMarkCompact() {
   // We don't have a linear allocation area while sweeping.  It will be restored
   // on the first allocation after the sweep.
   // Mark the old linear allocation area with a free space map so it can be
   // skipped when scanning the heap.
-  int old_linear_size = limit() - top();
+  int old_linear_size = static_cast<int>(limit() - top());
   Free(top(), old_linear_size);
   SetTop(NULL, NULL);
 
   // Stop lazy sweeping for the space.
   first_unswept_page_ = last_unswept_page_ = Page::FromAddress(NULL);
 
   // Clear the free list before a full GC---it will be rebuilt afterward.
   free_list_.Reset();
 
   // Clear EVACUATED flag from all pages.
   PageIterator it(this);
   while (it.has_next()) {
     Page* page = it.next();
     page->ClearSwept();
   }
 }
 
 
 bool PagedSpace::ReserveSpace(int size_in_bytes) {
   ASSERT(size_in_bytes <= Page::kMaxHeapObjectSize);
   ASSERT(size_in_bytes == RoundSizeDownToObjectAlignment(size_in_bytes));
   Address current_top = allocation_info_.top;
   Address new_top = current_top + size_in_bytes;
   if (new_top <= allocation_info_.limit) return true;
 
   HeapObject* new_area = free_list_.Allocate(size_in_bytes);
   if (new_area == NULL) new_area = SlowAllocateRaw(size_in_bytes);
   if (new_area == NULL) return false;
 
-  int old_linear_size = limit() - top();
+  int old_linear_size = static_cast<int>(limit() - top());
   // Mark the old linear allocation area with a free space so it can be
   // skipped when scanning the heap.  This also puts it back in the free list
   // if it is big enough.
   Free(top(), old_linear_size);
 
   SetTop(new_area->address(), new_area->address() + size_in_bytes);
   Allocate(size_in_bytes);
   return true;
 }
 
 
 // You have to call this last, since the implementation from PagedSpace
 // doesn't know that memory was 'promised' to large object space.
 bool LargeObjectSpace::ReserveSpace(int bytes) {
   return heap()->OldGenerationSpaceAvailable() >= bytes;
 }
 
 
 bool PagedSpace::AdvanceSweeper(intptr_t bytes_to_sweep) {
   if (IsSweepingComplete()) return true;
 
-  int freed_bytes = 0;
+  intptr_t freed_bytes = 0;
   Page* last = last_unswept_page_->next_page();
   Page* p = first_unswept_page_;
   do {
     Page* next_page = p->next_page();
     // Evacuation candidates were swept by evacuator.
     if (!p->IsEvacuationCandidate() &&
         !p->IsFlagSet(Page::RESCAN_ON_EVACUATION) &&
         !p->WasSwept()) {
       freed_bytes += MarkCompactCollector::SweepConservatively(this, p);
     }
@@ skipping 444 matching lines @@
   heap()->FreeQueuedChunks();
 }
 
 
 bool LargeObjectSpace::Contains(HeapObject* object) {
   Address address = object->address();
   MemoryChunk* chunk = MemoryChunk::FromAddress(address);
 
   bool owned = (chunk->owner() == this);
 
-  SLOW_ASSERT(!owned
-              || !FindObject(address)->IsFailure());
+  SLOW_ASSERT(!owned || !FindObject(address)->IsFailure());
 
   return owned;
 }
 
 
 #ifdef DEBUG
 // We do not assume that the large object iterator works, because it depends
 // on the invariants we are checking during verification.
 void LargeObjectSpace::Verify() {
   for (LargePage* chunk = first_page_;
@@ skipping 72 matching lines @@
   for (HeapObject* obj = obj_it.Next(); obj != NULL; obj = obj_it.Next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       isolate->code_kind_statistics()[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal