- Fix x64 build....

src/spaces.cc

 // Copyright 2006-2008 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 648 matching lines @@
   }
 
   if (last_page != NULL) {
     *last_page = last;
   }
 }
 
 
 Page* MemoryAllocator::RelinkPagesInChunk(int chunk_id,
                                           Address chunk_start,
-                                          int chunk_size,
+                                          size_t chunk_size,
                                           Page* prev,
                                           Page** last_page_in_use) {
   Address page_addr = RoundUp(chunk_start, Page::kPageSize);
   int pages_in_chunk = PagesInChunk(chunk_start, chunk_size);
 
   if (prev->is_valid()) {
     SetNextPage(prev, Page::FromAddress(page_addr));
   }
 
   for (int i = 0; i < pages_in_chunk; i++) {
@@ skipping 1305 matching lines @@
       Page* p = all_pages_iterator.next();
       p->SetWasInUseBeforeMC(in_use);
       if (p == last_in_use) {
         // We passed a page containing allocation top. All consequent
         // pages are not used.
         in_use = false;
       }
     }
 
     if (!page_list_is_chunk_ordered_) {
-      Page* new_last_in_use = NULL;
+      Page* new_last_in_use = Page::FromAddress(NULL);
       MemoryAllocator::RelinkPageListInChunkOrder(this,
                                                   &first_page_,
                                                   &last_page_,
                                                   &new_last_in_use);
-      ASSERT(new_last_in_use != NULL);
+      ASSERT(new_last_in_use->is_valid());
 
       if (new_last_in_use != last_in_use) {
         // Current allocation top points to a page which is now in the middle
         // of page list. We should move allocation top forward to the new last
         // used page so various object iterators will continue to work properly.
 
-        int size_in_bytes =
-            PageAllocationLimit(last_in_use) - last_in_use->AllocationTop();
+        int size_in_bytes = static_cast<int>(PageAllocationLimit(last_in_use) -
+                                             last_in_use->AllocationTop());
 
         if (size_in_bytes > 0) {
           // There is still some space left on this page. Create a fake
           // object which will occupy all free space on this page.
           // Otherwise iterators would not be able to scan this page
           // correctly.
 
-          FreeListNode* node =
-              FreeListNode::FromAddress(last_in_use->AllocationTop());
-          node->set_size(size_in_bytes);
+          Heap::CreateFillerObjectAt(last_in_use->AllocationTop(),
+                                     size_in_bytes);
         }
 
         // New last in use page was in the middle of the list before
         // sorting so it full.
         SetTop(new_last_in_use->AllocationTop());
 
         ASSERT(AllocationTopPage() == new_last_in_use);
         ASSERT(AllocationTopPage()->WasInUseBeforeMC());
       }
 
       PageIterator pages_in_use_iterator(this, PageIterator::PAGES_IN_USE);
       while (pages_in_use_iterator.has_next()) {
         Page* p = pages_in_use_iterator.next();
         if (!p->WasInUseBeforeMC()) {
           // Empty page is in the middle of a sequence of used pages.
           // Create a fake object which will occupy all free space on this page.
           // Otherwise iterators would not be able to scan this page correctly.
-          FreeListNode* node =
-              FreeListNode::FromAddress(p->ObjectAreaStart());
-          node->set_size(PageAllocationLimit(p) - p->ObjectAreaStart());
+          int size_in_bytes = static_cast<int>(PageAllocationLimit(p) -
+                                               p->ObjectAreaStart());
+
+          Heap::CreateFillerObjectAt(p->ObjectAreaStart(), size_in_bytes);
         }
       }
 
       page_list_is_chunk_ordered_ = true;
     }
   }
 }
 
 
 bool PagedSpace::ReserveSpace(int bytes) {
@@ skipping 1020 matching lines @@
                      reinterpret_cast<Object**>(object->address()
                                                 + Page::kObjectAreaSize),
                      allocation_top);
       PrintF("\n");
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal