Fix bugs introduced by r4475:...

src/spaces.h

 // 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 909 matching lines @@
 
   // Checks whether page is currently in use by this space.
   bool IsUsed(Page* page);
 
   // Clears remembered sets of pages in this space.
   void ClearRSet();
 
   // Prepares for a mark-compact GC.
   virtual void PrepareForMarkCompact(bool will_compact);
 
-  virtual Address PageAllocationTop(Page* page) = 0;
+  // The top of allocation in a page in this space. Undefined if page is unused.
+  Address PageAllocationTop(Page* page) {
+    return page == TopPageOf(allocation_info_) ? top()
+        : PageAllocationLimit(page);
+  }
+
+  // The limit of allocation for a page in this space.
+  virtual Address PageAllocationLimit(Page* page) = 0;
 
   // Current capacity without growing (Size() + Available() + Waste()).
   int Capacity() { return accounting_stats_.Capacity(); }
 
   // Total amount of memory committed for this space.  For paged
   // spaces this equals the capacity.
   int CommittedMemory() { return Capacity(); }
 
   // Available bytes without growing.
   int Available() { return accounting_stats_.Available(); }
@@ skipping 22 matching lines @@
   virtual bool ReserveSpace(int bytes);
 
   // Used by ReserveSpace.
   virtual void PutRestOfCurrentPageOnFreeList(Page* current_page) = 0;
 
   // Free all pages in range from prev (exclusive) to last (inclusive).
   // Freed pages are moved to the end of page list.
   void FreePages(Page* prev, Page* last);
 
   // Set space allocation info.
-  void SetTop(Address top, Address limit) {
+  void SetTop(Address top) {
     allocation_info_.top = top;
-    allocation_info_.limit = limit;
+    allocation_info_.limit = PageAllocationLimit(Page::FromAllocationTop(top));
   }
 
   // ---------------------------------------------------------------------------
   // Mark-compact collection support functions
 
   // Set the relocation point to the beginning of the space.
   void MCResetRelocationInfo();
 
   // Writes relocation info to the top page.
   void MCWriteRelocationInfoToPage() {
@@ skipping 731 matching lines @@
                     AllocationSpace id,
                     Executability executable)
       : PagedSpace(max_capacity, id, executable), free_list_(id) {
     page_extra_ = 0;
   }
 
   // The bytes available on the free list (ie, not above the linear allocation
   // pointer).
   int AvailableFree() { return free_list_.available(); }
 
-  // The top of allocation in a page in this space. Undefined if page is unused.
-  virtual Address PageAllocationTop(Page* page) {
-    return page == TopPageOf(allocation_info_) ? top() : page->ObjectAreaEnd();
+  // The limit of allocation for a page in this space.
+  virtual Address PageAllocationLimit(Page* page) {
+    return page->ObjectAreaEnd();
   }
 
   // Give a block of memory to the space's free list.  It might be added to
   // the free list or accounted as waste.
   // If add_to_freelist is false then just accounting stats are updated and
   // no attempt to add area to free list is made.
   void Free(Address start, int size_in_bytes, bool add_to_freelist) {
     accounting_stats_.DeallocateBytes(size_in_bytes);
 
     if (add_to_freelist) {
@@ skipping 45 matching lines @@
              AllocationSpace id,
              int object_size_in_bytes,
              const char* name)
       : PagedSpace(max_capacity, id, NOT_EXECUTABLE),
         object_size_in_bytes_(object_size_in_bytes),
         name_(name),
         free_list_(id, object_size_in_bytes) {
     page_extra_ = Page::kObjectAreaSize % object_size_in_bytes;
   }
 
-  // The top of allocation in a page in this space. Undefined if page is unused.
-  virtual Address PageAllocationTop(Page* page) {
-    return page == TopPageOf(allocation_info_) ? top()
-        : page->ObjectAreaEnd() - page_extra_;
+  // The limit of allocation for a page in this space.
+  virtual Address PageAllocationLimit(Page* page) {
+    return page->ObjectAreaEnd() - page_extra_;
   }
 
   int object_size_in_bytes() { return object_size_in_bytes_; }
 
   // Give a fixed sized block of memory to the space's free list.
   // If add_to_freelist is false then just accounting stats are updated and
   // no attempt to add area to free list is made.
   void Free(Address start, bool add_to_freelist) {
     if (add_to_freelist) {
       free_list_.Free(start);
@@ skipping 342 matching lines @@
 
  private:
   LargeObjectChunk* current_;
   HeapObjectCallback size_func_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_