Make the marking stack into a deque

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 322 matching lines @@
   }
 
   void set_owner(Space* space) {
     ASSERT((reinterpret_cast<intptr_t>(space) & kFailureTagMask) == 0);
     owner_ = reinterpret_cast<Address>(space) + kFailureTag;
     ASSERT((reinterpret_cast<intptr_t>(owner_) & kFailureTagMask) ==
            kFailureTag);
   }
 
   bool scan_on_scavenge() { return scan_on_scavenge_; }
+  bool in_new_space() { return in_new_space_; }

[Vyacheslav Egorov (Chromium), 2011/05/04 14:46:52]

please revert these unrelated changes.

   void initialize_scan_on_scavenge(bool scan) { scan_on_scavenge_ = scan; }
   inline void set_scan_on_scavenge(bool scan);
+  void set_in_new_space(bool in_new_space) { in_new_space_ = in_new_space; }
 
   int store_buffer_counter() { return store_buffer_counter_; }
   void set_store_buffer_counter(int counter) {
     store_buffer_counter_ = counter;
   }
 
   Address body() { return address() + kObjectStartOffset; }
 
   int body_size() { return size() - kObjectStartOffset; }
 
@@ skipping 87 matching lines @@
     return this->address() + (index << kPointerSizeLog2);
   }
 
   void InsertAfter(MemoryChunk* other);
   void Unlink();
 
   inline Heap* heap() { return heap_; }
 
   static const int kFlagsOffset = kPointerSize * 3;
   static const int kScanOnScavengeOffset = kPointerSize * 6;
+  static const int kInNewSpaceOffset = kPointerSize * 6 + 1;
 
  protected:
   MemoryChunk* next_chunk_;
   MemoryChunk* prev_chunk_;
   size_t size_;
   intptr_t flags_;
   // The identity of the owning space.  This is tagged as a failure pointer, but
   // no failure can be in an object, so this can be distinguished from any entry
   // in a fixed array.
   Address owner_;
   Heap* heap_;
   // This flag indicates that the page is not being tracked by the store buffer.
   // At any point where we have to iterate over pointers to new space, we must
   // search this page for pointers to new space.
-  bool scan_on_scavenge_;
+  byte scan_on_scavenge_;
+  byte in_new_space_;
   // Used by the store buffer to keep track of which pages to mark scan-on-
   // scavenge.
   int store_buffer_counter_;
 
   static MemoryChunk* Initialize(Heap* heap,
                                  Address base,
                                  size_t size,
                                  Executability executable,
                                  Space* owner);
 
@@ skipping 1740 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_