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

src/heap/heap.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HEAP_HEAP_H_
 #define V8_HEAP_HEAP_H_
 
 #include <cmath>
 #include <map>
 
@@ skipping 869 matching lines @@
   bool HasBeenSetUp();
 
   // ===========================================================================
   // Getters for spaces. =======================================================
   // ===========================================================================
 
   // Return the starting address and a mask for the new space.  And-masking an
   // 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_; }
   OldSpace* old_space() { return old_space_; }
   OldSpace* code_space() { return code_space_; }
   MapSpace* map_space() { return map_space_; }
   LargeObjectSpace* lo_space() { return lo_space_; }
 
   PagedSpace* paged_space(int idx) {
     switch (idx) {
@@ skipping 176 matching lines @@
 
   void IterateAndMarkPointersToFromSpace(HeapObject* object, Address start,
                                          Address end, bool record_slots,
                                          ObjectSlotCallback callback);
 
   // ===========================================================================
   // Store buffer API. =========================================================
   // ===========================================================================
 
   // 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]);
   }
 
   // ===========================================================================
   // Incremental marking API. ==================================================
   // ===========================================================================
 
   // Start incremental marking and ensure that idle time handler can perform
@@ skipping 23 matching lines @@
   // Finalizes an external string by deleting the associated external
   // data and clearing the resource pointer.
   inline void FinalizeExternalString(String* string);
 
   // ===========================================================================
   // Methods checking/returning the space of a given object/address. ===========
   // ===========================================================================
 
   // 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);
   inline bool InOldSpace(Object* object);
 
   // Checks whether an address/object in the heap (including auxiliary
   // area and unused area).
   bool Contains(Address addr);

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

Can we delete Contains(Address addr)? It seems like we are able to survive with
the heap object interface (I did a quick check over the code base...).

Overall, it would be good to get rid of as many Address interfaces as possible.

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

"Done." See general description above.

   bool Contains(HeapObject* value);
 
   // Checks whether an address/object in a space.
   // Currently used by tests, serialization and heap verification only.
   bool InSpace(Address addr, AllocationSpace space);
   bool InSpace(HeapObject* value, AllocationSpace space);
 
   // ===========================================================================
   // Object statistics tracking. ===============================================
   // ===========================================================================
@@ skipping 1498 matching lines @@
 
  private:
   friend class NewSpace;
   DISALLOW_COPY_AND_ASSIGN(InlineAllocationObserver);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_HEAP_H_