Separate markbits from heap object map words into bitmaps.

src/heap.h

 // Copyright 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 849 matching lines @@
   // Iterate pointers to new space found in memory interval from start to end.
   // This interval is considered to belong to the map space.
   // Return true if pointers to new space was found.
   static bool IteratePointersInDirtyMapsRegion(Address start,
                                                Address end,
                                                ObjectSlotCallback callback);
 
 
   // Returns whether the object resides in new space.
   static inline bool InNewSpace(Object* object);
+  static inline bool InNewSpace(Address addr);
   static inline bool InFromSpace(Object* object);
   static inline bool InToSpace(Object* object);
 
   // Checks whether an address/object in the heap (including auxiliary
   // area and unused area).
   static bool Contains(Address addr);
   static bool Contains(HeapObject* value);
 
   // Checks whether an address/object in a space.
   // Currently used by tests, serialization and heap verification only.
@@ skipping 1055 matching lines @@
 
   // True if the *previous* full GC cwas a compacting collection (will be
   // false if there has not been a previous full GC).
   bool previous_has_compacted_;
 
   // On a full GC, a count of the number of marked objects.  Incremented
   // when an object is marked and decremented when an object's mark bit is
   // cleared.  Will be zero on a scavenge collection.
   int marked_count_;
 
-  // The count from the end of the previous full GC.  Will be zero if there
-  // was no previous full GC.
-  int previous_marked_count_;
-
   // Amounts of time spent in different scopes during GC.
   double scopes_[Scope::kNumberOfScopes];
 
   // Total amount of space either wasted or contained in one of free lists
   // before the current GC.
   intptr_t in_free_list_or_wasted_before_gc_;
 
   // Difference between space used in the heap at the beginning of the current
   // collection and the end of the previous collection.
   intptr_t allocated_since_last_gc_;
@@ skipping 163 matching lines @@
   // Return whether this object should be retained. If NULL is returned the
   // object has no references. Otherwise the address of the retained object
   // should be returned as in some GC situations the object has been moved.
   virtual Object* RetainAs(Object* object) = 0;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_