[heap] Move to page lookups for SemiSpace, NewSpace, and Heap containment methods

src/heap/heap.h

Index: src/heap/heap.h
diff --git a/src/heap/heap.h b/src/heap/heap.h
index f4c8ef3f1e696fcd2f78924245b15480cbe2a46b..4dfac4faf0501a25969dc06f861675d11cffdd37 100644
--- a/src/heap/heap.h
+++ b/src/heap/heap.h
@@ -887,7 +887,6 @@ class Heap {
   // address with the mask will result in the start address of the new space
   // for all addresses in either semispace.
   Address NewSpaceStart() { return new_space_.start(); }
-  uintptr_t NewSpaceMask() { return new_space_.mask(); }
   Address NewSpaceTop() { return new_space_.top(); }
 
   NewSpace* new_space() { return &new_space_; }
@@ -1084,10 +1083,10 @@ class Heap {
   // ===========================================================================
 
   // Write barrier support for address[offset] = o.
-  INLINE(void RecordWrite(Address address, int offset));
+  inline void RecordWriteSlow(Address address, int offset);

[Hannes Payer (out of office), 2016/02/08 16:05:40]

As discussed offline, this one should become Object... or disappear if not
necessary anymore.

[Michael Lippautz, 2016/02/08 18:00:38]

The only remaining interface now is
  // Write barrier support for object[offset] = o;
  inline void RecordWrite(Object* object, int offset, Object* o);

 
-  // Write barrier support for address[start : start + len[ = o.
-  INLINE(void RecordWrites(Address address, int start, int len));
+  // Write barrier support for object[offset] = o;
+  inline void RecordWrite(Object* object, int offset);
 
   Address* store_buffer_top_address() {
     return reinterpret_cast<Address*>(&roots_[kStoreBufferTopRootIndex]);
@@ -1131,10 +1130,9 @@ class Heap {
 
   // Returns whether the object resides in new space.
   inline bool InNewSpace(Object* object);
-  inline bool InNewSpace(Address address);
-  inline bool InNewSpacePage(Address address);
   inline bool InFromSpace(Object* object);
   inline bool InToSpace(Object* object);
+  inline bool InNewSpaceSlow(Address address);

[Hannes Payer (out of office), 2016/02/08 16:05:40]

InNewSpaceSlow seems to be not necessary anymore. It's only caller is in
RemoveInvalidSlots (after removing the serializer caller). There you cast to
address, but you have object. Just call the object version.

[Michael Lippautz, 2016/02/08 18:00:38]

Unfortunately I think this one needs to stay right now because
RemoveInvalidSlots only checks for whether the slot is contained in a live
object later on. So I think we do not have an Object there but in fact just any
Address (potentially an unboxed double).

[Hannes Payer (out of office), 2016/02/08 21:33:51]

I think you mentioned this already last week: if you re-arrange the new space
and live object check then you know for sure that it must be an object. Hence,
you can get rid of the address interface. 

[Michael Lippautz, 2016/02/09 08:03:06]

Done. The live object check is quite expensive (although it has a lot of
bailouts and only operates on mark bits. It's probably still faster than doing
different page lookups (in the slow version).

 
   // Returns whether the object resides in old space.
   inline bool InOldSpace(Address address);