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 137 matching lines @@
     ASSERT(executable == NOT_EXECUTABLE || !isolate_->code_range()->exists());
     VirtualMemory::ReleaseRegion(base, size);
   }
 }
 
 
 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;
+  if (size_ + requested > capacity_) {
+    return NULL;
+  }

[Erik Corry, 2011/07/15 21:37:33]

Unneeded change.

[Lasse Reichstein, 2011/08/01 12:40:33]

I added it in order to be able to make a breakpoint at the return. Will revert
them all.

 
-  size_t allocated = RoundUp(requested + alignment, OS::AllocateAlignment());
+  size_t allocated = RoundUp(requested + alignment,
+                             static_cast<int>(OS::AllocateAlignment()));

[Erik Corry, 2011/07/15 21:37:33]

RoundUp takes a size_t and an int?  Perhaps that's the bug.

[Lasse Reichstein, 2011/08/01 12:40:33]

It's taking intptr_t for its second argument actually. That's what it's using
internally when rounding. I'll fix the cast.

 
   Address base = reinterpret_cast<Address>(
       VirtualMemory::ReserveRegion(allocated));
 
   Address end = base + allocated;
 
-  if (base == 0) return NULL;
+  if (base == 0) {
+        return NULL;

[Lasse Reichstein, 2011/08/01 12:40:33]

reverted.

+  }
 
   Address aligned_base = RoundUp(base, alignment);
 
   ASSERT(aligned_base + requested <= base + allocated);
 
   // The difference between re-aligned base address and base address is
   // multiple of OS::AllocateAlignment().
   if (aligned_base != base) {
     ASSERT(aligned_base > base);
     // TODO(gc) check result of operation?
@@ skipping 167 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 126 matching lines @@
                        Executability executable)
     : Space(heap, id, executable),
       free_list_(this),
       was_swept_conservatively_(false),
       first_unswept_page_(Page::FromAddress(NULL)),
       last_unswept_page_(Page::FromAddress(NULL)) {
   max_capacity_ = (RoundDown(max_capacity, Page::kPageSize) / Page::kPageSize)
                   * Page::kObjectAreaSize;
   accounting_stats_.Clear();
 
-  allocation_info_.top = NULL;
-  allocation_info_.limit = NULL;
+  allocation_info_.top = reinterpret_cast<Address>(static_cast<uintptr_t>(2));

[Erik Corry, 2011/07/15 21:37:33]

2?

Don't understand this at all, but it seems the number should have a name, in
which case it can have the right type.

[Lasse Reichstein, 2011/08/01 12:40:33]

Sorry, leftover from debugging. Should be NULL again.

+  allocation_info_.limit = reinterpret_cast<Address>(static_cast<uintptr_t>(2));
 
   anchor_.InitializeAsAnchor(this);
 }
 
 
 bool PagedSpace::Setup() {
   return true;
 }
 
 
@@ skipping 172 matching lines @@
   // this chunk must be a power of two and it must be aligned to its size.
   int initial_semispace_capacity = heap()->InitialSemiSpaceSize();
 
   size_t size = 0;
   Address base =
       heap()->isolate()->memory_allocator()->ReserveAlignedMemory(
           2 * maximum_semispace_capacity,
           2 * maximum_semispace_capacity,
           &size);
 
-  if (base == NULL) return false;
+  if (base == NULL) {

[Erik Corry, 2011/07/15 21:37:33]

Grrr.

[Lasse Reichstein, 2011/08/01 12:40:33]

Curly-brace-ophobia is treatable.

+    return false;
+  }
 
   chunk_base_ = base;
   chunk_size_ = static_cast<uintptr_t>(size);
   LOG(heap()->isolate(), NewEvent("InitialChunk", chunk_base_, chunk_size_));
 
   ASSERT(initial_semispace_capacity <= maximum_semispace_capacity);
   ASSERT(IsPowerOf2(maximum_semispace_capacity));
 
   // Allocate and setup the histogram arrays if necessary.
 #if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
@@ skipping 962 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;
 }
 
@@ skipping 466 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