Create a new paged heap space for global property cells. The new...

src/mark-compact.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 275 matching lines @@
   // number of live objects.
   static int IterateLiveObjectsInRange(Address start, Address end,
                                        HeapObjectCallback size_func);
 
   // Callback functions for deallocating non-live blocks in the old
   // generation.
   static void DeallocateOldPointerBlock(Address start, int size_in_bytes);
   static void DeallocateOldDataBlock(Address start, int size_in_bytes);
   static void DeallocateCodeBlock(Address start, int size_in_bytes);
   static void DeallocateMapBlock(Address start, int size_in_bytes);
+  static void DeallocateCellBlock(Address start, int size_in_bytes);
 
   // If we are not compacting the heap, we simply sweep the spaces except
   // for the large object space, clearing mark bits and adding unmarked
   // regions to each space's free list.
   static void SweepSpaces();
 
   // -----------------------------------------------------------------------
   // Phase 3: Updating pointers in live objects.
   //
   //  Before: Same as after phase 2 (compacting collection).
@@ skipping 39 matching lines @@
   // address to target happens in the marking phase.
   static int ConvertCodeICTargetToAddress(HeapObject* obj);
 
   // Relocate a map object.
   static int RelocateMapObject(HeapObject* obj);
 
   // Relocates an old object.
   static int RelocateOldPointerObject(HeapObject* obj);
   static int RelocateOldDataObject(HeapObject* obj);
 
+  // Relocate a property cell object.
+  static int RelocateCellObject(HeapObject* obj);
+
   // Helper function.
-  static inline int RelocateOldNonCodeObject(HeapObject* obj, OldSpace* space);
+  static inline int RelocateOldNonCodeObject(HeapObject* obj, PagedSpace* space);
 
   // Relocates an object in the code space.
   static int RelocateCodeObject(HeapObject* obj);
 
   // Copy a new object.
   static int RelocateNewObject(HeapObject* obj);
 
   // -----------------------------------------------------------------------
   // Phase 5: Rebuilding remembered sets.
   //
@@ skipping 19 matching lines @@
 
   // Number of live objects in Heap::old_data_space_.
   static int live_old_data_objects_;
 
   // Number of live objects in Heap::code_space_.
   static int live_code_objects_;
 
   // Number of live objects in Heap::map_space_.
   static int live_map_objects_;
 
+  // Number of live objects in Heap::cell_space_.
+  static int live_cell_objects_;
+
   // Number of live objects in Heap::lo_space_.
   static int live_lo_objects_;
 
   // Number of live bytes in this collection.
   static int live_bytes_;
 
   friend class MarkObjectVisitor;
   static void VisitObject(HeapObject* obj);
 
   friend class UnmarkObjectVisitor;
   static void UnmarkObject(HeapObject* obj);
 #endif
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_MARK_COMPACT_H_