Merge (7265, 7271] from bleeding_edge to experimental/gc branch....

src/spaces-inl.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 10 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_SPACES_INL_H_
 #define V8_SPACES_INL_H_
 
+#include "isolate.h"
 #include "memory.h"
 #include "spaces.h"
 
 namespace v8 {
 namespace internal {
 
 
 // -----------------------------------------------------------------------------
 // PageIterator
 
@@ skipping 65 matching lines @@
   int id = GetChunkId(page);
   OS::Unprotect(chunks_[id].address(), chunks_[id].size(),
                 chunks_[id].owner()->executable() == EXECUTABLE);
 }
 
 #endif
 
 
 // --------------------------------------------------------------------------
 // PagedSpace
-Page* Page::Initialize(MemoryChunk* chunk,
+Page* Page::Initialize(Heap* heap,
+                       MemoryChunk* chunk,
                        Executability executable,
                        PagedSpace* owner) {
   Page* page = reinterpret_cast<Page*>(chunk);
-  MemoryChunk::Initialize(reinterpret_cast<Address>(chunk),
+  MemoryChunk::Initialize(heap,
+                          reinterpret_cast<Address>(chunk),
                           kPageSize,
                           executable,
                           owner);
   owner->IncreaseCapacity(Page::kObjectAreaSize);
   owner->Free(page->ObjectAreaStart(),
               page->ObjectAreaEnd() - page->ObjectAreaStart());
   return page;
 }
 
 
 bool PagedSpace::Contains(Address addr) {
   Page* p = Page::FromAddress(addr);
   if (!p->is_valid()) return false;
   return p->owner() == this;
 }
 
 
 MemoryChunk* MemoryChunk::FromAnyPointerAddress(Address addr) {
   MemoryChunk* maybe = reinterpret_cast<MemoryChunk*>(
       OffsetFrom(addr) & ~Page::kPageAlignmentMask);
   if (maybe->owner() != NULL) return maybe;
-  LargeObjectIterator iterator(Heap::lo_space());
+  // TODO(gc) ISOLATESMERGE HEAP
+  LargeObjectIterator iterator(HEAP->lo_space());
   for (HeapObject* o = iterator.next(); o != NULL; o = iterator.next()) {
     // Fixed arrays are the only pointer-containing objects in large object
     // space.
     if (o->IsFixedArray()) {
       MemoryChunk* chunk = MemoryChunk::FromAddress(o->address());
       if (chunk->Contains(addr)) {
         return chunk;
       }
     }
   }
   UNREACHABLE();
   return NULL;
 }
 
 
+// TODO(gc) ISOLATESMERGE HEAP
 PointerChunkIterator::PointerChunkIterator()
     : state_(kOldPointerState),
-      old_pointer_iterator_(Heap::old_pointer_space()),
-      map_iterator_(Heap::map_space()),
-      lo_iterator_(Heap::lo_space()) { }
+      old_pointer_iterator_(HEAP->old_pointer_space()),
+      map_iterator_(HEAP->map_space()),
+      lo_iterator_(HEAP->lo_space()) { }
 
 
 Page* Page::next_page() {
   ASSERT(next_chunk()->owner() == owner());
   return static_cast<Page*>(next_chunk());
 }
 
 
 Page* Page::prev_page() {
   ASSERT(prev_chunk()->owner() == owner());
@@ skipping 67 matching lines @@
       return AllocateRawInternal(size_in_bytes);
     }
     return Failure::RetryAfterGC();
   }
 
   Object* obj = HeapObject::FromAddress(allocation_info_.top);
   allocation_info_.top = new_top;
   ASSERT_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
 
   int bytes_allocated = new_top - top_on_previous_step_;
-  IncrementalMarking::Step(bytes_allocated);
+  heap()->incremental_marking()->Step(bytes_allocated);
   top_on_previous_step_ = new_top;
 
   return obj;
 }
 
 
+intptr_t LargeObjectSpace::Available() {
+  return ObjectSizeFor(heap()->isolate()->memory_allocator()->Available());
+}
+
+
 template <typename StringType>
 void NewSpace::ShrinkStringAtAllocationBoundary(String* string, int length) {
   ASSERT(length <= string->length());
   ASSERT(string->IsSeqString());
   ASSERT(string->address() + StringType::SizeFor(string->length()) ==
          allocation_info_.top);
   allocation_info_.top =
       string->address() + StringType::SizeFor(length);
   string->set_length(length);
 }
 
 
 bool FreeListNode::IsFreeListNode(HeapObject* object) {
-  return object->map() == Heap::raw_unchecked_free_space_map()
-      || object->map() == Heap::raw_unchecked_one_pointer_filler_map()
-      || object->map() == Heap::raw_unchecked_two_pointer_filler_map();
+  return object->map() == HEAP->raw_unchecked_free_space_map()

[Erik Corry, 2011/04/20 20:07:40]

I think this needs a todo

[Vyacheslav Egorov (Chromium), 2011/04/24 11:24:08]

Done.

+      || object->map() == HEAP->raw_unchecked_one_pointer_filler_map()
+      || object->map() == HEAP->raw_unchecked_two_pointer_filler_map();
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_INL_H_