Fix numerous bugs introduced by reducing Page::kMaxHeapObjectSize.

src/spaces.h

 // Copyright 2006-2010 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 296 matching lines @@
   static const intptr_t kPageAlignmentMask = (1 << kPageSizeBits) - 1;
 
   // The start offset of the object area in a page. Aligned to both maps and
   // code alignment to be suitable for both.
   static const int kObjectStartOffset = kBodyOffset;
 
   // Object area size in bytes.
   static const int kObjectAreaSize = kPageSize - kObjectStartOffset;
 
   // Maximum object size that fits in a page.
-  static const int kMaxHeapObjectSize = kObjectAreaSize >> 4;
+  static const int kMaxHeapObjectSize =
+    OBJECT_POINTER_ALIGN(kObjectAreaSize >> 4);
+
+  STATIC_ASSERT((kMaxHeapObjectSize & kObjectAlignmentMask) == 0);
 
 #ifdef ENABLE_CARDMARKING_WRITE_BARRIER
   static const int kDirtyFlagOffset = 2 * kPointerSize;
   static const int kRegionSizeLog2 = 8;
   static const int kRegionSize = 1 << kRegionSizeLog2;
   static const intptr_t kRegionAlignmentMask = (kRegionSize - 1);
 
   STATIC_CHECK(kRegionSize == kPageSize / kBitsPerInt);
 #endif
 
@@ skipping 1403 matching lines @@
 
   // The bytes available on the free list (ie, not above the linear allocation
   // pointer).
   intptr_t AvailableFree() { return free_list_.available(); }
 
   // The limit of allocation for a page in this space.
   virtual Address PageAllocationLimit(Page* page) {
     return page->ObjectAreaEnd();
   }
 
+  void AddToFreeList(Address start, int size_in_bytes) {
+    // TODO(gc) instead of putting large chunks into free list try to
+    // reuse them for linear allocation.
+    int wasted_bytes = 0;
+
+    while (size_in_bytes >= Page::kMaxHeapObjectSize) {
+      wasted_bytes += free_list_.Free(start, Page::kMaxHeapObjectSize);
+      start += Page::kMaxHeapObjectSize;
+      size_in_bytes -= Page::kMaxHeapObjectSize;
+    }
+
+    if (size_in_bytes > 0) {
+      wasted_bytes += free_list_.Free(start, size_in_bytes);
+    }
+
+    accounting_stats_.WasteBytes(wasted_bytes);
+  }
+
   // 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) {
-      int wasted_bytes = free_list_.Free(start, size_in_bytes);
-      accounting_stats_.WasteBytes(wasted_bytes);
-    }
+    if (add_to_freelist) AddToFreeList(start, size_in_bytes);
   }
 
   virtual void DeallocateBlock(Address start,
                                int size_in_bytes,
                                bool add_to_freelist);
 
   // Prepare for full garbage collection.  Resets the relocation pointer and
   // clears the free list.
   virtual void PrepareForMarkCompact(bool will_compact);
 
@@ skipping 331 matching lines @@
 
  private:
   LargePage* current_;
   HeapObjectCallback size_func_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_