Make InToSpace/InFromSpace use the page header.

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 358 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,
+    IN_FROM_SPACE,  // Mutually exclusive with IN_TO_SPACE.
+    IN_TO_SPACE,    // All pages in new space has one of these two set.
     NUM_MEMORY_CHUNK_FLAGS
   };
 
   void SetFlag(int flag) {
-    flags_ |= 1 << flag;
+    flags_ |= (1 << flag);
   }
 
   void ClearFlag(int flag) {
     flags_ &= ~(1 << flag);
   }
 
+  void SetFlagTo(int flag, bool value) {
+    if (value) {
+      SetFlag(flag);
+    } else {
+      ClearFlag(flag);
+    }
+  }
+
   bool IsFlagSet(int flag) {
     return (flags_ & (1 << flag)) != 0;
   }
 
-  void CopyFlagsFrom(MemoryChunk* chunk) {
-    flags_ = chunk->flags_;
+  // Set or clear multiple flags at a time. The flags in the mask
+  // are set to the value in "flags", the rest retain the current value
+  // in flags_.
+  void SetFlags(intptr_t flags, intptr_t mask) {
+    flags_ = (flags_ & ~mask) | (flags & mask);
   }
 
+  // Return all current flags.
+  intptr_t GetFlags() { return flags_; }
+
   static const intptr_t kAlignment = (1 << kPageSizeBits);
 
   static const intptr_t kAlignmentMask = kAlignment - 1;
 
   static const size_t kHeaderSize = kPointerSize + kPointerSize + kPointerSize +
     kPointerSize + kPointerSize + kPointerSize + kPointerSize + kPointerSize;
 
   static const int kBodyOffset =
     CODE_POINTER_ALIGN(MAP_POINTER_ALIGN(kHeaderSize + Bitmap::kSize));
 
   // The start offset of the object area in a page. Aligned to both maps and
   // code alignment to be suitable for both.  Also aligned to 32 words because
   // the marking bitmap is arranged in 32 bit chunks.
   static const int kObjectStartAlignment = 32 * kPointerSize;
   static const int kObjectStartOffset = kBodyOffset - 1 +
       (kObjectStartAlignment - (kBodyOffset - 1) % kObjectStartAlignment);
 
   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);
+    return (flags_ & ((1 << IN_FROM_SPACE) | (1 << IN_TO_SPACE))) != 0;
+  }
+
+  bool InToSpace() {
+    return IsFlagSet(IN_TO_SPACE);
+  }
+
+  bool InFromSpace() {
+    return IsFlagSet(IN_FROM_SPACE);
   }
 
   // ---------------------------------------------------------------------
   // Markbits support
 
   inline Bitmap* markbits() {
     return Bitmap::FromAddress(address() + kHeaderSize);
   }
 
   void PrintMarkbits() { markbits()->Print(); }
@@ skipping 1001 matching lines @@
 
   const char* name() { return name_; }
   void set_name(const char* name) { name_ = name; }
 
  private:
   const char* name_;
 };
 #endif
 
 
+enum SemiSpaceId {
+  kFromSpace = 0,
+  kToSpace = 1
+};
+
+
 class NewSpacePage : public MemoryChunk {
  public:
+  // GC related flags copied from from-space to to-space when
+  // flipping semispaces.
+  static const intptr_t kCopyOnFlipFlagsMask =
+    (1 << MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING) |
+    (1 << MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING) |
+    (1 << MemoryChunk::SCAN_ON_SCAVENGE);
+
   inline NewSpacePage* next_page() const {
     return static_cast<NewSpacePage*>(next_chunk());
   }
 
   inline void set_next_page(NewSpacePage* page) {
     set_next_chunk(page);
   }
  private:
   // Finds the NewSpacePage containg the given address.
   static NewSpacePage* FromAddress(Address address_in_page) {
     Address page_start =
         reinterpret_cast<Address>(reinterpret_cast<uintptr_t>(address_in_page) &
                                   ~Page::kPageAlignmentMask);
     return reinterpret_cast<NewSpacePage*>(page_start);
   }
 
-  static NewSpacePage* Initialize(Heap* heap, Address start);
+  static NewSpacePage* Initialize(Heap* heap,
+                                  Address start,
+                                  SemiSpaceId semispace);
 
   friend class SemiSpace;
   friend class SemiSpaceIterator;
 };
 
 
 // -----------------------------------------------------------------------------
 // SemiSpace in young generation
 //
 // A semispace is a contiguous chunk of memory holding page-like memory
 // chunks. The mark-compact collector  uses the memory of the first page in
 // the from space as a marking stack when tracing live objects.
 
 class SemiSpace : public Space {
  public:
   // Constructor.
-  explicit SemiSpace(Heap* heap) : Space(heap, NEW_SPACE, NOT_EXECUTABLE) {
-    start_ = NULL;
-    age_mark_ = NULL;
-  }
+  SemiSpace(Heap* heap, SemiSpaceId semispace)
+    : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
+      start_(NULL),
+      age_mark_(NULL),
+      id_(semispace) { }
 
   // Sets up the semispace using the given chunk.
   bool Setup(Address start, int initial_capacity, int maximum_capacity);
 
   // Tear down the space.  Heap memory was not allocated by the space, so it
   // is not deallocated here.
   void TearDown();
 
   // True if the space has been set up but not torn down.
   bool HasBeenSetup() { return start_ != NULL; }
 
   // Grow the size of the semispace by committing extra virtual memory.
   // Assumes that the caller has checked that the semispace has not reached
   // its maximum capacity (and thus there is space available in the reserved
   // address range to grow).
   bool Grow();
 
   // Grow the semispace to the new capacity.  The new capacity
   // requested must be larger than the current capacity.
   bool GrowTo(int new_capacity);
 
   // Shrinks the semispace to the new capacity.  The new capacity
   // requested must be more than the amount of used memory in the
   // semispace and less than the current capacity.
   bool ShrinkTo(int new_capacity);
 
+  // Flips the semispace between being from-space and to-space.
+  // Copies the flags into the masked positions on all pages in the space.
+  void Flip(intptr_t flags, intptr_t flag_mask);
+
   // Returns the start address of the space.
   Address low() {
     return NewSpacePage::FromAddress(start_)->body();
   }
 
   // Returns one past the end address of the space.
   Address high() {
     // TODO(gc): Change when there is more than one page.
     return current_page_->body() + current_page_->body_size();
   }
 
   // Age mark accessors.
   Address age_mark() { return age_mark_; }
   void set_age_mark(Address mark) { age_mark_ = mark; }
 
-  // True if the address is in the address range of this semispace (not
-  // necessarily below the allocation pointer).
-  bool Contains(Address a) {
-    return (reinterpret_cast<uintptr_t>(a) & address_mask_)
-           == reinterpret_cast<uintptr_t>(start_);
-  }
-
-  // True if the object is a heap object in the address range of this
-  // semispace (not necessarily below the allocation pointer).
-  bool Contains(Object* o) {
-    return (reinterpret_cast<uintptr_t>(o) & object_mask_) == object_expected_;
-  }
-
   // The offset of an address from the beginning of the space.
   int SpaceOffsetForAddress(Address addr) {
     return static_cast<int>(addr - low());
   }
 
   // If we don't have these here then SemiSpace will be abstract.  However
   // they should never be called.
   virtual intptr_t Size() {
     UNREACHABLE();
     return 0;
@@ skipping 41 matching lines @@
   Address start_;
   // Used to govern object promotion during mark-compact collection.
   Address age_mark_;
 
   // Masks and comparison values to test for containment in this semispace.
   uintptr_t address_mask_;
   uintptr_t object_mask_;
   uintptr_t object_expected_;
 
   bool committed_;
+  SemiSpaceId id_;
 
   NewSpacePage* current_page_;
 
  public:
   TRACK_MEMORY("SemiSpace")
 };
 
 
 // A SemiSpaceIterator is an ObjectIterator that iterates over the active
 // semispace of the heap's new space.  It iterates over the objects in the
@@ skipping 48 matching lines @@
 // The young generation space.
 //
 // The new space consists of a contiguous pair of semispaces.  It simply
 // forwards most functions to the appropriate semispace.
 
 class NewSpace : public Space {
  public:
   // Constructor.
   explicit NewSpace(Heap* heap)
     : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
-      to_space_(heap),
-      from_space_(heap) {}
+      to_space_(heap, kToSpace),
+      from_space_(heap, kFromSpace) {}
 
   // Sets up the new space using the given chunk.
   bool Setup(int max_semispace_size);
 
   // Tears down the space.  Heap memory was not allocated by the space, so it
   // is not deallocated here.
   void TearDown();
 
   // True if the space has been set up but not torn down.
   bool HasBeenSetup() {
     return to_space_.HasBeenSetup() && from_space_.HasBeenSetup();
   }
 
   // Flip the pair of spaces.
   void Flip();
 
   // 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).
   bool Contains(Address a) {
+    // TODO(gc): Replace by PageContains when we stop passing
+    // pointers to non-paged space.
     return (reinterpret_cast<uintptr_t>(a) & address_mask_)
         == reinterpret_cast<uintptr_t>(start_);
   }
 
   // True if the address or object lies on a NewSpacePage.
   // 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.
   // TODO(gc): When every call to Contains is converted to PageContains,
   //           remove Contains and rename PageContains to Contains.
   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.
-      // TODO(gc): Remove when we no longer have tagged zero-page
-      // pointers intermingled with real heap object pointers.
-      return false;
-    }
-    return MemoryChunk::FromAddress(a)->InNewSpace();
+    MemoryChunk* page = MemoryChunk::FromAddress(a);
+    // Tagged zero-page pointers are not real heap pointers.
+    // TODO(gc): Remove when we no longer have tagged zero-page
+    // pointers intermingled with real heap object pointers.
+    if (!page->is_valid()) return false;
+    return page->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) ==
-        static_cast<uintptr_t>(0)) {
-      // Tagged zero-page pointers are not real heap pointers.
-      // TODO(gc): Remove when we no longer have tagged zero-page
-      // pointers intermingled with real heap object pointers.
-      return false;
-    }
-    Address a = HeapObject::cast(o)->address();
-    return MemoryChunk::FromAddress(a)->InNewSpace();
+    Address a = reinterpret_cast<Address>(o);
+    MemoryChunk* page = MemoryChunk::FromAddress(a);
+    if (!page->is_valid()) return false;
+    return page->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.
@@ skipping 82 matching lines @@
   Address ToSpaceHigh() { return to_space_.high(); }
 
   // Offsets from the beginning of the semispaces.
   int ToSpaceOffsetForAddress(Address a) {
     return to_space_.SpaceOffsetForAddress(a);
   }
   int FromSpaceOffsetForAddress(Address a) {
     return from_space_.SpaceOffsetForAddress(a);
   }
 
+  inline bool ToSpaceContains(Address address) {
+    MemoryChunk* page = MemoryChunk::FromAddress(address);
+    return page->is_valid() && page->InToSpace();
+  }
+
+  inline bool FromSpaceContains(Address address) {
+    MemoryChunk* page = MemoryChunk::FromAddress(address);
+    return page->is_valid() && page->InFromSpace();
+  }
+
   // True if the object is a heap object in the address range of the
   // respective semispace (not necessarily below the allocation pointer of the
   // semispace).
-  bool ToSpaceContains(Object* o) { return to_space_.Contains(o); }
-  bool FromSpaceContains(Object* o) { return from_space_.Contains(o); }
+  bool ToSpaceContains(Object* o) {
+    if (o->IsSmi()) return false;
+    Address address = reinterpret_cast<Address>(o);
+    return ToSpaceContains(address);
+  }
 
-  bool ToSpaceContains(Address a) { return to_space_.Contains(a); }
-  bool FromSpaceContains(Address a) { return from_space_.Contains(a); }
+  bool FromSpaceContains(Object* o) {
+    if (o->IsSmi()) return false;
+    Address address = reinterpret_cast<Address>(o);
+    return FromSpaceContains(address);
+  }
 
   virtual bool ReserveSpace(int bytes);
 
   // Resizes a sequential string which must be the most recent thing that was
   // allocated in new space.
   template <typename StringType>
   inline void ShrinkStringAtAllocationBoundary(String* string, int len);
 
 #ifdef ENABLE_HEAP_PROTECTION
   // Protect/unprotect the space by marking it read-only/writable.
@@ skipping 435 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_