Use page header information to test for InNewSpace.

src/spaces.h

 // Copyright 2011 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 357 matching lines @@
     return addr >= body() && addr < address() + size();
   }
 
   enum MemoryChunkFlags {
     IS_EXECUTABLE,
     WAS_SWEPT_CONSERVATIVELY,
     CONTAINS_ONLY_DATA,
     POINTERS_TO_HERE_ARE_INTERESTING,
     POINTERS_FROM_HERE_ARE_INTERESTING,
     SCAN_ON_SCAVENGE,
+    IN_NEW_SPACE,
     NUM_MEMORY_CHUNK_FLAGS
   };
 
   void SetFlag(int flag) {
     flags_ |= 1 << flag;
   }
 
   void ClearFlag(int flag) {
     flags_ &= ~(1 << flag);
   }
@@ skipping 26 matching lines @@
   size_t size() const { return size_; }
 
   Executability executable() {
     return IsFlagSet(IS_EXECUTABLE) ? EXECUTABLE : NOT_EXECUTABLE;
   }
 
   bool ContainsOnlyData() {
     return IsFlagSet(CONTAINS_ONLY_DATA);
   }
 
+  bool InNewSpace() {
+    return IsFlagSet(IN_NEW_SPACE);
+  }
+
   // ---------------------------------------------------------------------
   // Markbits support
 
   inline Bitmap* markbits() {
     return Bitmap::FromAddress(address() + kHeaderSize);
   }
 
   void PrintMarkbits() { markbits()->Print(); }
 
   inline uint32_t AddressToMarkbitIndex(Address addr) {
@@ skipping 1248 matching lines @@
 
   // Grow the capacity of the semispaces.  Assumes that they are not at
   // their maximum capacity.
   void Grow();
 
   // Shrink the capacity of the semispaces.
   void Shrink();
 
   // True if the address or object lies in the address range of either
   // semispace (not necessarily below the allocation pointer).
+  // Must be a pointer into a heap page, and if it's a large object
+  // page, it must be a pointer into the beginning of it.

[Erik Corry, 2011/05/19 07:22:32]

Comment should be moved down to the function to which it applies.

[Lasse Reichstein, 2011/05/19 08:40:40]

Moved.

   bool Contains(Address a) {
     return (reinterpret_cast<uintptr_t>(a) & address_mask_)
         == reinterpret_cast<uintptr_t>(start_);
   }
+
+  bool PageContains(Address a) {
+    if ((reinterpret_cast<intptr_t>(a) & ~kHeapObjectTagMask) ==
+        static_cast<intptr_t>(0)) {
+      // Tagged zero-page pointers are not real heap pointers.
+      return false;

[Erik Corry, 2011/05/19 07:22:32]

Can we add a TODO to remove this?

[Lasse Reichstein, 2011/05/19 08:40:40]

Done.

+    }
+    return MemoryChunk::FromAddress(a)->InNewSpace();
+  }
+
   bool Contains(Object* o) {
     return (reinterpret_cast<uintptr_t>(o) & object_mask_) == object_expected_;
   }
 
+  bool PageContains(Object* o) {
+    if (o->IsSmi()) return false;
+    if ((reinterpret_cast<uintptr_t>(o) & ~kHeapObjectTagMask) ==

[Erik Corry, 2011/05/19 07:22:32]

And this

[Lasse Reichstein, 2011/05/19 08:40:40]

And done.

+        static_cast<uintptr_t>(0)) {
+      return false;
+    }
+    Address a = HeapObject::cast(o)->address();
+    return MemoryChunk::FromAddress(a)->InNewSpace();
+  }
+
   // Return the allocated bytes in the active semispace.
   virtual intptr_t Size() { return static_cast<int>(top() - bottom()); }
   // The same, but returning an int.  We have to have the one that returns
   // intptr_t because it is inherited, but if we know we are dealing with the
   // new space, which can't get as big as the other spaces then this is useful:
   int SizeAsInt() { return static_cast<int>(Size()); }
 
   // Return the current capacity of a semispace.
   intptr_t Capacity() {
     ASSERT(to_space_.Capacity() == from_space_.Capacity());
@@ skipping 543 matching lines @@
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_