- Fix x64 build....

src/mark-compact.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 1264 matching lines @@
   space->set_age_mark(space->top());
 }
 
 
 static void SweepSpace(PagedSpace* space, DeallocateFunction dealloc) {
   PageIterator it(space, PageIterator::PAGES_IN_USE);
 
   // During sweeping of paged space we are trying to find longest sequences
   // of pages without live objects and free them (instead of putting them on
   // the free list).
-  Page* prev = NULL;  // Page preceding current.
-  Page* first_empty_page = NULL;  // First empty page in a sequence.
-  Page* prec_first_empty_page = NULL;  // Page preceding first empty page.
+
+  // Page preceding current.
+  Page* prev = Page::FromAddress(NULL);
+
+  // First empty page in a sequence.
+  Page* first_empty_page = Page::FromAddress(NULL);
+
+  // Page preceding first empty page.
+  Page* prec_first_empty_page = Page::FromAddress(NULL);
 
   // If last used page of space ends with a sequence of dead objects
   // we can adjust allocation top instead of puting this free area into
   // the free list. Thus during sweeping we keep track of such areas
   // and defer their deallocation until the sweeping of the next page
   // is done: if one of the next pages contains live objects we have
   // to put such area into the free list.
   Address last_free_start = NULL;
   int last_free_size = 0;
 
@@ skipping 26 matching lines @@
       // The object is now unmarked for the call to Size() at the top of the
       // loop.
     }
 
     bool page_is_empty = (p->ObjectAreaStart() == p->AllocationTop())
         || (!is_previous_alive && free_start == p->ObjectAreaStart());
 
     if (page_is_empty) {
       // This page is empty. Check whether we are in the middle of
       // sequence of empty pages and start one if not.
-      if (first_empty_page == NULL) {
+      if (!first_empty_page->is_valid()) {
         first_empty_page = p;
         prec_first_empty_page = prev;
       }
 
       if (!is_previous_alive) {
         // There are dead objects on this page. Update space accounting stats
         // without putting anything into free list.
         int size_in_bytes = static_cast<int>(p->AllocationTop() - free_start);
         if (size_in_bytes > 0) {
           dealloc(free_start, size_in_bytes, false);
         }
       }
     } else {
       // This page is not empty. Sequence of empty pages ended on the previous
       // one.
-      if (first_empty_page != NULL) {
+      if (first_empty_page->is_valid()) {
         space->FreePages(prec_first_empty_page, prev);
-        prec_first_empty_page = first_empty_page = NULL;
+        prec_first_empty_page = first_empty_page = Page::FromAddress(NULL);
       }
 
       // If there is a free ending area on one of the previous pages we have
       // deallocate that area and put it on the free list.
       if (last_free_size > 0) {
         dealloc(last_free_start, last_free_size, true);
         last_free_start = NULL;
         last_free_size  = 0;
       }
 
       // If the last region of this page was not live we remember it.
       if (!is_previous_alive) {
         ASSERT(last_free_size == 0);
         last_free_size = static_cast<int>(p->AllocationTop() - free_start);
         last_free_start = free_start;
       }
     }
 
     prev = p;
   }
 
   // We reached end of space. See if we need to adjust allocation top.
   Address new_allocation_top = NULL;
 
-  if (first_empty_page != NULL) {
+  if (first_empty_page->is_valid()) {
     // Last used pages in space are empty. We can move allocation top backwards
     // to the beginning of first empty page.
     ASSERT(prev == space->AllocationTopPage());
 
     new_allocation_top = first_empty_page->ObjectAreaStart();
   }
 
   if (last_free_size > 0) {
     // There was a free ending area on the previous page.
     // Deallocate it without putting it into freelist and move allocation
     // top to the beginning of this free area.
     dealloc(last_free_start, last_free_size, false);
     new_allocation_top = last_free_start;
   }
 
   if (new_allocation_top != NULL) {
 #ifdef DEBUG
     Page* new_allocation_top_page = Page::FromAllocationTop(new_allocation_top);
-    ASSERT(((first_empty_page == NULL) &&
-            (new_allocation_top_page == space->AllocationTopPage())) ||
-           ((first_empty_page != NULL) && (last_free_size > 0) &&
-            (new_allocation_top_page == prec_first_empty_page)) ||
-           ((first_empty_page != NULL) && (last_free_size == 0) &&
-            (new_allocation_top_page == first_empty_page)));
+    if (!first_empty_page->is_valid()) {
+      ASSERT(new_allocation_top_page == space->AllocationTopPage());
+    } else if (last_free_size > 0) {
+      ASSERT(new_allocation_top_page == prec_first_empty_page);
+    } else {
+      ASSERT(new_allocation_top_page == first_empty_page);
+    }
 #endif
 
     space->SetTop(new_allocation_top);
   }
 }
 
 
 void MarkCompactCollector::DeallocateOldPointerBlock(Address start,
                                                      int size_in_bytes,
                                                      bool add_to_freelist) {
@@ skipping 891 matching lines @@
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (obj->IsCode()) {
     PROFILE(CodeDeleteEvent(obj->address()));
   } else if (obj->IsJSFunction()) {
     PROFILE(FunctionDeleteEvent(obj->address()));
   }
 #endif
 }
 
 } }  // namespace v8::internal