[Isolates] Add heap pointer to all maps and use map->heap() more.

src/spaces.cc

 // Copyright 2006-2008 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 753 matching lines @@
   }
 
   return last_page;
 }
 
 
 
 // -----------------------------------------------------------------------------
 // PagedSpace implementation
 
-PagedSpace::PagedSpace(int max_capacity,
+PagedSpace::PagedSpace(Heap* heap,
+                       int max_capacity,
                        AllocationSpace id,
                        Executability executable)
-    : Space(id, executable) {
+    : Space(heap, id, executable) {
   max_capacity_ = (RoundDown(max_capacity, Page::kPageSize) / Page::kPageSize)
                   * Page::kObjectAreaSize;
   accounting_stats_.Clear();
 
   allocation_info_.top = NULL;
   allocation_info_.limit = NULL;
 
   mc_forwarding_info_.top = NULL;
   mc_forwarding_info_.limit = NULL;
 }
@@ skipping 83 matching lines @@
   PageIterator it(this, PageIterator::ALL_PAGES);
   while (it.has_next()) {
     it.next()->SetRegionMarks(Page::kAllRegionsCleanMarks);
   }
 }
 
 
 Object* PagedSpace::FindObject(Address addr) {
   // Note: this function can only be called before or after mark-compact GC
   // because it accesses map pointers.
-  ASSERT(!HEAP->mark_compact_collector()->in_use());
+  ASSERT(!heap()->mark_compact_collector()->in_use());
 
   if (!Contains(addr)) return Failure::Exception();
 
   Page* p = Page::FromAddress(addr);
   ASSERT(IsUsed(p));
   Address cur = p->ObjectAreaStart();
   Address end = p->AllocationTop();
   while (cur < end) {
     HeapObject* obj = HeapObject::FromAddress(cur);
     Address next = cur + obj->Size();
@@ skipping 95 matching lines @@
   if (Capacity() == max_capacity_) return false;
 
   ASSERT(Capacity() < max_capacity_);
   // Last page must be valid and its next page is invalid.
   ASSERT(last_page->is_valid() && !last_page->next_page()->is_valid());
 
   int available_pages = (max_capacity_ - Capacity()) / Page::kObjectAreaSize;
   if (available_pages <= 0) return false;
 
   int desired_pages = Min(available_pages, MemoryAllocator::kPagesPerChunk);
-  Page* p = Isolate::Current()->memory_allocator()->AllocatePages(
+  Page* p = heap()->isolate()->memory_allocator()->AllocatePages(
       desired_pages, &desired_pages, this);
   if (!p->is_valid()) return false;
 
   accounting_stats_.ExpandSpace(desired_pages * Page::kObjectAreaSize);
   ASSERT(Capacity() <= max_capacity_);
 
-  Isolate::Current()->memory_allocator()->SetNextPage(last_page, p);
+  heap()->isolate()->memory_allocator()->SetNextPage(last_page, p);
 
   // Sequentially clear region marks of new pages and and cache the
   // new last page in the space.
   while (p->is_valid()) {
     p->SetRegionMarks(Page::kAllRegionsCleanMarks);
     last_page_ = p;
     p = p->next_page();
   }
 
   return true;
@@ skipping 22 matching lines @@
   Page* top_page = AllocationTopPage();
   ASSERT(top_page->is_valid());
 
   // Count the number of pages we would like to free.
   int pages_to_free = 0;
   for (Page* p = top_page->next_page(); p->is_valid(); p = p->next_page()) {
     pages_to_free++;
   }
 
   // Free pages after top_page.
-  Page* p = Isolate::Current()->memory_allocator()->
+  Page* p = heap()->isolate()->memory_allocator()->
       FreePages(top_page->next_page());
-  Isolate::Current()->memory_allocator()->SetNextPage(top_page, p);
+  heap()->isolate()->memory_allocator()->SetNextPage(top_page, p);
 
   // Find out how many pages we failed to free and update last_page_.
   // Please note pages can only be freed in whole chunks.
   last_page_ = top_page;
   for (Page* p = top_page->next_page(); p->is_valid(); p = p->next_page()) {
     pages_to_free--;
     last_page_ = p;
   }
 
   accounting_stats_.ShrinkSpace(pages_to_free * Page::kObjectAreaSize);
   ASSERT(Capacity() == CountTotalPages() * Page::kObjectAreaSize);
 }
 
 
 bool PagedSpace::EnsureCapacity(int capacity) {
   if (Capacity() >= capacity) return true;
 
   // Start from the allocation top and loop to the last page in the space.
   Page* last_page = AllocationTopPage();
   Page* next_page = last_page->next_page();
   while (next_page->is_valid()) {
-    last_page = Isolate::Current()->memory_allocator()->
+    last_page = heap()->isolate()->memory_allocator()->
         FindLastPageInSameChunk(next_page);
     next_page = last_page->next_page();
   }
 
   // Expand the space until it has the required capacity or expansion fails.
   do {
     if (!Expand(last_page)) return false;
     ASSERT(last_page->next_page()->is_valid());
     last_page =
-        Isolate::Current()->memory_allocator()->FindLastPageInSameChunk(
+        heap()->isolate()->memory_allocator()->FindLastPageInSameChunk(
             last_page->next_page());
   } while (Capacity() < capacity);
 
   return true;
 }
 
 
 #ifdef DEBUG
 void PagedSpace::Print() { }
 #endif
 
 
 #ifdef DEBUG
 // We do not assume that the PageIterator works, because it depends on the
 // invariants we are checking during verification.
 void PagedSpace::Verify(ObjectVisitor* visitor) {
   // The allocation pointer should be valid, and it should be in a page in the
   // space.
   ASSERT(allocation_info_.VerifyPagedAllocation());
   Page* top_page = Page::FromAllocationTop(allocation_info_.top);
-  ASSERT(Isolate::Current()->memory_allocator()->IsPageInSpace(top_page, this));
+  ASSERT(heap()->isolate()->memory_allocator()->IsPageInSpace(top_page, this));
 
   // Loop over all the pages.
   bool above_allocation_top = false;
   Page* current_page = first_page_;
   while (current_page->is_valid()) {
     if (above_allocation_top) {
       // We don't care what's above the allocation top.
     } else {
       Address top = current_page->AllocationTop();
       if (current_page == top_page) {
         ASSERT(top == allocation_info_.top);
         // The next page will be above the allocation top.
         above_allocation_top = true;
       }
 
       // It should be packed with objects from the bottom to the top.
       Address current = current_page->ObjectAreaStart();
       while (current < top) {
         HeapObject* object = HeapObject::FromAddress(current);
 
         // The first word should be a map, and we expect all map pointers to
         // be in map space.
         Map* map = object->map();
         ASSERT(map->IsMap());
-        ASSERT(HEAP->map_space()->Contains(map));
+        ASSERT(heap()->map_space()->Contains(map));
 
         // Perform space-specific object verification.
         VerifyObject(object);
 
         // The object itself should look OK.
         object->Verify();
 
         // All the interior pointers should be contained in the heap and
         // have page regions covering intergenerational references should be
         // marked dirty.
@@ skipping 15 matching lines @@
 
 // -----------------------------------------------------------------------------
 // NewSpace implementation
 
 
 bool NewSpace::Setup(Address start, int size) {
   // Setup new space based on the preallocated memory block defined by
   // start and size. The provided space is divided into two semi-spaces.
   // To support fast containment testing in the new space, the size of
   // this chunk must be a power of two and it must be aligned to its size.
-  int initial_semispace_capacity = HEAP->InitialSemiSpaceSize();
-  int maximum_semispace_capacity = HEAP->MaxSemiSpaceSize();
+  int initial_semispace_capacity = heap()->InitialSemiSpaceSize();
+  int maximum_semispace_capacity = heap()->MaxSemiSpaceSize();
 
   ASSERT(initial_semispace_capacity <= maximum_semispace_capacity);
   ASSERT(IsPowerOf2(maximum_semispace_capacity));
 
   // Allocate and setup the histogram arrays if necessary.
 #if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
   allocated_histogram_ = NewArray<HistogramInfo>(LAST_TYPE + 1);
   promoted_histogram_ = NewArray<HistogramInfo>(LAST_TYPE + 1);
 
 #define SET_NAME(name) allocated_histogram_[name].set_name(#name); \
                        promoted_histogram_[name].set_name(#name);
   INSTANCE_TYPE_LIST(SET_NAME)
 #undef SET_NAME
 #endif
 
-  ASSERT(size == 2 * HEAP->ReservedSemiSpaceSize());
+  ASSERT(size == 2 * heap()->ReservedSemiSpaceSize());
   ASSERT(IsAddressAligned(start, size, 0));
 
   if (!to_space_.Setup(start,
                        initial_semispace_capacity,
                        maximum_semispace_capacity)) {
     return false;
   }
   if (!from_space_.Setup(start + maximum_semispace_capacity,
                          initial_semispace_capacity,
                          maximum_semispace_capacity)) {
@@ skipping 34 matching lines @@
   mc_forwarding_info_.limit = NULL;
 
   to_space_.TearDown();
   from_space_.TearDown();
 }
 
 
 #ifdef ENABLE_HEAP_PROTECTION
 
 void NewSpace::Protect() {
-  Isolate::Current()->memory_allocator()->Protect(ToSpaceLow(), Capacity());
-  Isolate::Current()->memory_allocator()->Protect(FromSpaceLow(), Capacity());
+  heap()->isolate()->memory_allocator()->Protect(ToSpaceLow(), Capacity());
+  heap()->isolate()->memory_allocator()->Protect(FromSpaceLow(), Capacity());
 }
 
 
 void NewSpace::Unprotect() {
-  Isolate::Current()->memory_allocator()->Unprotect(ToSpaceLow(), Capacity(),
-                                                    to_space_.executable());
-  Isolate::Current()->memory_allocator()->Unprotect(FromSpaceLow(), Capacity(),
-                                                    from_space_.executable());
+  heap()->isolate()->memory_allocator()->Unprotect(ToSpaceLow(), Capacity(),
+                                                   to_space_.executable());
+  heap()->isolate()->memory_allocator()->Unprotect(FromSpaceLow(), Capacity(),
+                                                   from_space_.executable());
 }
 
 #endif
 
 
 void NewSpace::Flip() {
   SemiSpace tmp = from_space_;
   from_space_ = to_space_;
   to_space_ = tmp;
 }
@@ skipping 73 matching lines @@
   // There should be objects packed in from the low address up to the
   // allocation pointer.
   Address current = to_space_.low();
   while (current < top()) {
     HeapObject* object = HeapObject::FromAddress(current);
 
     // The first word should be a map, and we expect all map pointers to
     // be in map space.
     Map* map = object->map();
     ASSERT(map->IsMap());
-    ASSERT(HEAP->map_space()->Contains(map));
+    ASSERT(heap()->map_space()->Contains(map));
 
     // The object should not be code or a map.
     ASSERT(!object->IsMap());
     ASSERT(!object->IsCode());
 
     // The object itself should look OK.
     object->Verify();
 
     // All the interior pointers should be contained in the heap.
     VerifyPointersVisitor visitor;
     int size = object->Size();
     object->IterateBody(map->instance_type(), size, &visitor);
 
     current += size;
   }
 
   // The allocation pointer should not be in the middle of an object.
   ASSERT(current == top());
 }
 #endif
 
 
 bool SemiSpace::Commit() {
   ASSERT(!is_committed());
-  if (!Isolate::Current()->memory_allocator()->CommitBlock(
+  if (!heap()->isolate()->memory_allocator()->CommitBlock(
       start_, capacity_, executable())) {
     return false;
   }
   committed_ = true;
   return true;
 }
 
 
 bool SemiSpace::Uncommit() {
   ASSERT(is_committed());
-  if (!Isolate::Current()->memory_allocator()->UncommitBlock(
+  if (!heap()->isolate()->memory_allocator()->UncommitBlock(
       start_, capacity_)) {
     return false;
   }
   committed_ = false;
   return true;
 }
 
 
 // -----------------------------------------------------------------------------
 // SemiSpace implementation
@@ skipping 26 matching lines @@
   start_ = NULL;
   capacity_ = 0;
 }
 
 
 bool SemiSpace::Grow() {
   // Double the semispace size but only up to maximum capacity.
   int maximum_extra = maximum_capacity_ - capacity_;
   int extra = Min(RoundUp(capacity_, static_cast<int>(OS::AllocateAlignment())),
                   maximum_extra);
-  if (!Isolate::Current()->memory_allocator()->CommitBlock(
+  if (!heap()->isolate()->memory_allocator()->CommitBlock(
       high(), extra, executable())) {
     return false;
   }
   capacity_ += extra;
   return true;
 }
 
 
 bool SemiSpace::GrowTo(int new_capacity) {
   ASSERT(new_capacity <= maximum_capacity_);
   ASSERT(new_capacity > capacity_);
   size_t delta = new_capacity - capacity_;
   ASSERT(IsAligned(delta, OS::AllocateAlignment()));
-  if (!Isolate::Current()->memory_allocator()->CommitBlock(
+  if (!heap()->isolate()->memory_allocator()->CommitBlock(
       high(), delta, executable())) {
     return false;
   }
   capacity_ = new_capacity;
   return true;
 }
 
 
 bool SemiSpace::ShrinkTo(int new_capacity) {
   ASSERT(new_capacity >= initial_capacity_);
   ASSERT(new_capacity < capacity_);
   size_t delta = capacity_ - new_capacity;
   ASSERT(IsAligned(delta, OS::AllocateAlignment()));
-  if (!Isolate::Current()->memory_allocator()->UncommitBlock(
+  if (!heap()->isolate()->memory_allocator()->UncommitBlock(
       high() - delta, delta)) {
     return false;
   }
   capacity_ = new_capacity;
   return true;
 }
 
 
 #ifdef DEBUG
 void SemiSpace::Print() { }
@@ skipping 569 matching lines @@
   }
 
   Page* first = NULL;
 
   // Remove pages from the list.
   if (prev == NULL) {
     first = first_page_;
     first_page_ = last->next_page();
   } else {
     first = prev->next_page();
-    Isolate::Current()->memory_allocator()->SetNextPage(
+    heap()->isolate()->memory_allocator()->SetNextPage(
         prev, last->next_page());
   }
 
   // Attach it after the last page.
-  Isolate::Current()->memory_allocator()->SetNextPage(last_page_, first);
+  heap()->isolate()->memory_allocator()->SetNextPage(last_page_, first);
   last_page_ = last;
-  Isolate::Current()->memory_allocator()->SetNextPage(last, NULL);
+  heap()->isolate()->memory_allocator()->SetNextPage(last, NULL);
 
   // Clean them up.
   do {
     first->InvalidateWatermark(true);
     first->SetAllocationWatermark(first->ObjectAreaStart());
     first->SetCachedAllocationWatermark(first->ObjectAreaStart());
     first->SetRegionMarks(Page::kAllRegionsCleanMarks);
     first = first->next_page();
   } while (first != NULL);
 
@@ skipping 18 matching lines @@
     if (p == last_in_use) {
       // We passed a page containing allocation top. All consequent
       // pages are not used.
       in_use = false;
     }
   }
 
   if (page_list_is_chunk_ordered_) return;
 
   Page* new_last_in_use = Page::FromAddress(NULL);
-  Isolate::Current()->memory_allocator()->RelinkPageListInChunkOrder(
+  heap()->isolate()->memory_allocator()->RelinkPageListInChunkOrder(
       this, &first_page_, &last_page_, &new_last_in_use);
   ASSERT(new_last_in_use->is_valid());
 
   if (new_last_in_use != last_in_use) {
     // Current allocation top points to a page which is now in the middle
     // of page list. We should move allocation top forward to the new last
     // used page so various object iterators will continue to work properly.
     int size_in_bytes = static_cast<int>(PageAllocationLimit(last_in_use) -
                                          last_in_use->AllocationTop());
 
     last_in_use->SetAllocationWatermark(last_in_use->AllocationTop());
     if (size_in_bytes > 0) {
       Address start = last_in_use->AllocationTop();
       if (deallocate_blocks) {
         accounting_stats_.AllocateBytes(size_in_bytes);
         DeallocateBlock(start, size_in_bytes, add_to_freelist);
       } else {
-        HEAP->CreateFillerObjectAt(start, size_in_bytes);
+        heap()->CreateFillerObjectAt(start, size_in_bytes);
       }
     }
 
     // New last in use page was in the middle of the list before
     // sorting so it full.
     SetTop(new_last_in_use->AllocationTop());
 
     ASSERT(AllocationTopPage() == new_last_in_use);
     ASSERT(AllocationTopPage()->WasInUseBeforeMC());
   }
 
   PageIterator pages_in_use_iterator(this, PageIterator::PAGES_IN_USE);
   while (pages_in_use_iterator.has_next()) {
     Page* p = pages_in_use_iterator.next();
     if (!p->WasInUseBeforeMC()) {
       // Empty page is in the middle of a sequence of used pages.
       // Allocate it as a whole and deallocate immediately.
       int size_in_bytes = static_cast<int>(PageAllocationLimit(p) -
                                            p->ObjectAreaStart());
 
       p->SetAllocationWatermark(p->ObjectAreaStart());
       Address start = p->ObjectAreaStart();
       if (deallocate_blocks) {
         accounting_stats_.AllocateBytes(size_in_bytes);
         DeallocateBlock(start, size_in_bytes, add_to_freelist);
       } else {
-        HEAP->CreateFillerObjectAt(start, size_in_bytes);
+        heap()->CreateFillerObjectAt(start, size_in_bytes);
       }
     }
   }
 
   page_list_is_chunk_ordered_ = true;
 }
 
 
 void PagedSpace::PrepareForMarkCompact(bool will_compact) {
   if (will_compact) {
     RelinkPageListInChunkOrder(false);
   }
 }
 
 
 bool PagedSpace::ReserveSpace(int bytes) {
   Address limit = allocation_info_.limit;
   Address top = allocation_info_.top;
   if (limit - top >= bytes) return true;
 
   // There wasn't enough space in the current page.  Lets put the rest
   // of the page on the free list and start a fresh page.
   PutRestOfCurrentPageOnFreeList(TopPageOf(allocation_info_));
 
   Page* reserved_page = TopPageOf(allocation_info_);
   int bytes_left_to_reserve = bytes;
   while (bytes_left_to_reserve > 0) {
     if (!reserved_page->next_page()->is_valid()) {
-      if (HEAP->OldGenerationAllocationLimitReached()) return false;
+      if (heap()->OldGenerationAllocationLimitReached()) return false;
       Expand(reserved_page);
     }
     bytes_left_to_reserve -= Page::kPageSize;
     reserved_page = reserved_page->next_page();
     if (!reserved_page->is_valid()) return false;
   }
   ASSERT(TopPageOf(allocation_info_)->next_page()->is_valid());
   TopPageOf(allocation_info_)->next_page()->InvalidateWatermark(true);
   SetAllocationInfo(&allocation_info_,
                     TopPageOf(allocation_info_)->next_page());
   return true;
 }
 
 
 // You have to call this last, since the implementation from PagedSpace
 // doesn't know that memory was 'promised' to large object space.
 bool LargeObjectSpace::ReserveSpace(int bytes) {
-  return HEAP->OldGenerationSpaceAvailable() >= bytes;
+  return heap()->OldGenerationSpaceAvailable() >= bytes;
 }
 
 
 // Slow case for normal allocation.  Try in order: (1) allocate in the next
 // page in the space, (2) allocate off the space's free list, (3) expand the
 // space, (4) fail.
 HeapObject* OldSpace::SlowAllocateRaw(int size_in_bytes) {
   // Linear allocation in this space has failed.  If there is another page
   // in the space, move to that page and allocate there.  This allocation
   // should succeed (size_in_bytes should not be greater than a page's
   // object area size).
   Page* current_page = TopPageOf(allocation_info_);
   if (current_page->next_page()->is_valid()) {
     return AllocateInNextPage(current_page, size_in_bytes);
   }
 
   // There is no next page in this space.  Try free list allocation unless that
   // is currently forbidden.
-  if (!HEAP->linear_allocation()) {
+  if (!heap()->linear_allocation()) {
     int wasted_bytes;
     Object* result = free_list_.Allocate(size_in_bytes, &wasted_bytes);
     accounting_stats_.WasteBytes(wasted_bytes);
     if (!result->IsFailure()) {
       accounting_stats_.AllocateBytes(size_in_bytes);
 
       HeapObject* obj = HeapObject::cast(result);
       Page* p = Page::FromAddress(obj->address());
 
       if (obj->address() >= p->AllocationWatermark()) {
         // There should be no hole between the allocation watermark
         // and allocated object address.
         // Memory above the allocation watermark was not swept and
         // might contain garbage pointers to new space.
         ASSERT(obj->address() == p->AllocationWatermark());
         p->SetAllocationWatermark(obj->address() + size_in_bytes);
       }
 
       return obj;
     }
   }
 
   // Free list allocation failed and there is no next page.  Fail if we have
   // hit the old generation size limit that should cause a garbage
   // collection.
-  if (!HEAP->always_allocate() && HEAP->OldGenerationAllocationLimitReached()) {
+  if (!heap()->always_allocate() &&
+      heap()->OldGenerationAllocationLimitReached()) {
     return NULL;
   }
 
   // Try to expand the space and allocate in the new next page.
   ASSERT(!current_page->next_page()->is_valid());
   if (Expand(current_page)) {
     return AllocateInNextPage(current_page, size_in_bytes);
   }
 
   // Finally, fail.
@@ skipping 141 matching lines @@
     it->next();
   }
   EnterComment(isolate, comment_txt, flat_delta);
 }
 
 
 // Collects code size statistics:
 // - by code kind
 // - by code comment
 void PagedSpace::CollectCodeStatistics() {
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = heap()->isolate();
   HeapObjectIterator obj_it(this);
   for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       isolate->code_kind_statistics()[code->kind()] += code->Size();
       RelocIterator it(code);
       int delta = 0;
       const byte* prev_pc = code->instruction_start();
       while (!it.done()) {
         if (it.rinfo()->rmode() == RelocInfo::COMMENT) {
@@ skipping 92 matching lines @@
   // in the space, move to that page and allocate there.  This allocation
   // should succeed.
   Page* current_page = TopPageOf(allocation_info_);
   if (current_page->next_page()->is_valid()) {
     return AllocateInNextPage(current_page, size_in_bytes);
   }
 
   // There is no next page in this space.  Try free list allocation unless
   // that is currently forbidden.  The fixed space free list implicitly assumes
   // that all free blocks are of the fixed size.
-  if (!HEAP->linear_allocation()) {
+  if (!heap()->linear_allocation()) {
     Object* result = free_list_.Allocate();
     if (!result->IsFailure()) {
       accounting_stats_.AllocateBytes(size_in_bytes);
       HeapObject* obj = HeapObject::cast(result);
       Page* p = Page::FromAddress(obj->address());
 
       if (obj->address() >= p->AllocationWatermark()) {
         // There should be no hole between the allocation watermark
         // and allocated object address.
         // Memory above the allocation watermark was not swept and
         // might contain garbage pointers to new space.
         ASSERT(obj->address() == p->AllocationWatermark());
         p->SetAllocationWatermark(obj->address() + size_in_bytes);
       }
 
       return obj;
     }
   }
 
   // Free list allocation failed and there is no next page.  Fail if we have
   // hit the old generation size limit that should cause a garbage
   // collection.
-  if (!HEAP->always_allocate() && HEAP->OldGenerationAllocationLimitReached()) {
+  if (!heap()->always_allocate() &&
+      heap()->OldGenerationAllocationLimitReached()) {
     return NULL;
   }
 
   // Try to expand the space and allocate in the new next page.
   ASSERT(!current_page->next_page()->is_valid());
   if (Expand(current_page)) {
     return AllocateInNextPage(current_page, size_in_bytes);
   }
 
   // Finally, fail.
@@ skipping 79 matching lines @@
 #endif
 
 
 // -----------------------------------------------------------------------------
 // GlobalPropertyCellSpace implementation
 
 #ifdef DEBUG
 void CellSpace::VerifyObject(HeapObject* object) {
   // The object should be a global object property cell or a free-list node.
   ASSERT(object->IsJSGlobalPropertyCell() ||
-         object->map() == HEAP->two_pointer_filler_map());
+         object->map() == heap()->two_pointer_filler_map());
 }
 #endif
 
 
 // -----------------------------------------------------------------------------
 // LargeObjectIterator
 
 LargeObjectIterator::LargeObjectIterator(LargeObjectSpace* space) {
   current_ = space->first_chunk_;
   size_func_ = NULL;
@@ skipping 44 matching lines @@
 int LargeObjectChunk::ChunkSizeFor(int size_in_bytes) {
   int os_alignment = static_cast<int>(OS::AllocateAlignment());
   if (os_alignment < Page::kPageSize)
     size_in_bytes += (Page::kPageSize - os_alignment);
   return size_in_bytes + Page::kObjectStartOffset;
 }
 
 // -----------------------------------------------------------------------------
 // LargeObjectSpace
 
-LargeObjectSpace::LargeObjectSpace(AllocationSpace id)
-    : Space(id, NOT_EXECUTABLE),  // Managed on a per-allocation basis
+LargeObjectSpace::LargeObjectSpace(Heap* heap, AllocationSpace id)
+    : Space(heap, id, NOT_EXECUTABLE),  // Managed on a per-allocation basis
       first_chunk_(NULL),
       size_(0),
       page_count_(0) {}
 
 
 bool LargeObjectSpace::Setup() {
   first_chunk_ = NULL;
   size_ = 0;
   page_count_ = 0;
   return true;
 }
 
 
 void LargeObjectSpace::TearDown() {
   while (first_chunk_ != NULL) {
     LargeObjectChunk* chunk = first_chunk_;
     first_chunk_ = first_chunk_->next();
     LOG(DeleteEvent("LargeObjectChunk", chunk->address()));
     Page* page = Page::FromAddress(RoundUp(chunk->address(), Page::kPageSize));
     Executability executable =
         page->IsPageExecutable() ? EXECUTABLE : NOT_EXECUTABLE;
     ObjectSpace space = kObjectSpaceLoSpace;
     if (executable == EXECUTABLE) space = kObjectSpaceCodeSpace;
     size_t size = chunk->size();
-    Isolate::Current()->memory_allocator()->FreeRawMemory(chunk->address(),
-                                                          size,
-                                                          executable);
-    Isolate::Current()->memory_allocator()->PerformAllocationCallback(
+    heap()->isolate()->memory_allocator()->FreeRawMemory(chunk->address(),
+                                                         size,
+                                                         executable);
+    heap()->isolate()->memory_allocator()->PerformAllocationCallback(
         space, kAllocationActionFree, size);
   }
 
   size_ = 0;
   page_count_ = 0;
 }
 
 
 #ifdef ENABLE_HEAP_PROTECTION
 
 void LargeObjectSpace::Protect() {
   LargeObjectChunk* chunk = first_chunk_;
   while (chunk != NULL) {
-    Isolate::Current()->memory_allocator()->Protect(chunk->address(),
-                                                    chunk->size());
+    heap()->isolate()->memory_allocator()->Protect(chunk->address(),
+                                                   chunk->size());
     chunk = chunk->next();
   }
 }
 
 
 void LargeObjectSpace::Unprotect() {
   LargeObjectChunk* chunk = first_chunk_;
   while (chunk != NULL) {
     bool is_code = chunk->GetObject()->IsCode();
-    Isolate::Current()->memory_allocator()->Unprotect(chunk->address(),
+    heap()->isolate()->memory_allocator()->Unprotect(chunk->address(),
         chunk->size(), is_code ? EXECUTABLE : NOT_EXECUTABLE);
     chunk = chunk->next();
   }
 }
 
 #endif
 
 
 Object* LargeObjectSpace::AllocateRawInternal(int requested_size,
                                               int object_size,
                                               Executability executable) {
   ASSERT(0 < object_size && object_size <= requested_size);
 
   // Check if we want to force a GC before growing the old space further.
   // If so, fail the allocation.
-  if (!HEAP->always_allocate() && HEAP->OldGenerationAllocationLimitReached()) {
+  if (!heap()->always_allocate() &&
+      heap()->OldGenerationAllocationLimitReached()) {
     return Failure::RetryAfterGC(requested_size, identity());
   }
 
   size_t chunk_size;
   LargeObjectChunk* chunk =
       LargeObjectChunk::New(requested_size, &chunk_size, executable);
   if (chunk == NULL) {
     return Failure::RetryAfterGC(requested_size, identity());
   }
 
@@ skipping 86 matching lines @@
         // regions (modulo 32). So we treat a large page as a sequence of
         // normal pages of size Page::kPageSize having same dirty marks
         // and subsequently iterate dirty regions on each of these pages.
         Address start = object->address();
         Address end = page->ObjectAreaEnd();
         Address object_end = start + object->Size();
 
         // Iterate regions of the first normal page covering object.
         uint32_t first_region_number = page->GetRegionNumberForAddress(start);
         newmarks |=
-            HEAP->IterateDirtyRegions(marks >> first_region_number,
-                                      start,
-                                      end,
-                                      &Heap::IteratePointersInDirtyRegion,
-                                      copy_object) << first_region_number;
+            heap()->IterateDirtyRegions(marks >> first_region_number,
+                                        start,
+                                        end,
+                                        &Heap::IteratePointersInDirtyRegion,
+                                        copy_object) << first_region_number;
 
         start = end;
         end = start + Page::kPageSize;
         while (end <= object_end) {
           // Iterate next 32 regions.
           newmarks |=
-              HEAP->IterateDirtyRegions(marks,
-                                        start,
-                                        end,
-                                        &Heap::IteratePointersInDirtyRegion,
-                                        copy_object);
+              heap()->IterateDirtyRegions(marks,
+                                          start,
+                                          end,
+                                          &Heap::IteratePointersInDirtyRegion,
+                                          copy_object);
           start = end;
           end = start + Page::kPageSize;
         }
 
         if (start != object_end) {
           // Iterate the last piece of an object which is less than
           // Page::kPageSize.
           newmarks |=
-              HEAP->IterateDirtyRegions(marks,
-                                        start,
-                                        object_end,
-                                        &Heap::IteratePointersInDirtyRegion,
-                                        copy_object);
+              heap()->IterateDirtyRegions(marks,
+                                          start,
+                                          object_end,
+                                          &Heap::IteratePointersInDirtyRegion,
+                                          copy_object);
         }
 
         page->SetRegionMarks(newmarks);
       }
     }
   }
 }
 
 
 void LargeObjectSpace::FreeUnmarkedObjects() {
   LargeObjectChunk* previous = NULL;
   LargeObjectChunk* current = first_chunk_;
   while (current != NULL) {
     HeapObject* object = current->GetObject();
     if (object->IsMarked()) {
       object->ClearMark();
-      HEAP->mark_compact_collector()->tracer()->decrement_marked_count();
+      heap()->mark_compact_collector()->tracer()->decrement_marked_count();
       previous = current;
       current = current->next();
     } else {
       Page* page = Page::FromAddress(RoundUp(current->address(),
                                      Page::kPageSize));
       Executability executable =
           page->IsPageExecutable() ? EXECUTABLE : NOT_EXECUTABLE;
       Address chunk_address = current->address();
       size_t chunk_size = current->size();
 
       // Cut the chunk out from the chunk list.
       current = current->next();
       if (previous == NULL) {
         first_chunk_ = current;
       } else {
         previous->set_next(current);
       }
 
       // Free the chunk.
-      HEAP->mark_compact_collector()->ReportDeleteIfNeeded(object);
+      heap()->mark_compact_collector()->ReportDeleteIfNeeded(object);
       size_ -= static_cast<int>(chunk_size);
       page_count_--;
       ObjectSpace space = kObjectSpaceLoSpace;
       if (executable == EXECUTABLE) space = kObjectSpaceCodeSpace;
-      Isolate::Current()->memory_allocator()->FreeRawMemory(chunk_address,
-                                                            chunk_size,
-                                                            executable);
-      Isolate::Current()->memory_allocator()->PerformAllocationCallback(
+      heap()->isolate()->memory_allocator()->FreeRawMemory(chunk_address,
+                                                           chunk_size,
+                                                           executable);
+      heap()->isolate()->memory_allocator()->PerformAllocationCallback(
           space, kAllocationActionFree, size_);
       LOG(DeleteEvent("LargeObjectChunk", chunk_address));
     }
   }
 }
 
 
 bool LargeObjectSpace::Contains(HeapObject* object) {
   Address address = object->address();
-  if (HEAP->new_space()->Contains(address)) {
+  if (heap()->new_space()->Contains(address)) {
     return false;
   }
   Page* page = Page::FromAddress(address);
 
   SLOW_ASSERT(!page->IsLargeObjectPage()
               || !FindObject(address)->IsFailure());
 
   return page->IsLargeObjectPage();
 }
 
 
 #ifdef DEBUG
 // We do not assume that the large object iterator works, because it depends
 // on the invariants we are checking during verification.
 void LargeObjectSpace::Verify() {
   for (LargeObjectChunk* chunk = first_chunk_;
        chunk != NULL;
        chunk = chunk->next()) {
     // Each chunk contains an object that starts at the large object page's
     // object area start.
     HeapObject* object = chunk->GetObject();
     Page* page = Page::FromAddress(object->address());
     ASSERT(object->address() == page->ObjectAreaStart());
 
     // The first word should be a map, and we expect all map pointers to be
     // in map space.
     Map* map = object->map();
     ASSERT(map->IsMap());
-    ASSERT(HEAP->map_space()->Contains(map));
+    ASSERT(heap()->map_space()->Contains(map));
 
     // We have only code, sequential strings, external strings
     // (sequential strings that have been morphed into external
     // strings), fixed arrays, and byte arrays in large object space.
     ASSERT(object->IsCode() || object->IsSeqString() ||
            object->IsExternalString() || object->IsFixedArray() ||
            object->IsByteArray());
 
     // The object itself should look OK.
     object->Verify();
 
     // Byte arrays and strings don't have interior pointers.
     if (object->IsCode()) {
       VerifyPointersVisitor code_visitor;
       object->IterateBody(map->instance_type(),
                           object->Size(),
                           &code_visitor);
     } else if (object->IsFixedArray()) {
       // We loop over fixed arrays ourselves, rather then using the visitor,
       // because the visitor doesn't support the start/offset iteration
       // needed for IsRegionDirty.
       FixedArray* array = FixedArray::cast(object);
       for (int j = 0; j < array->length(); j++) {
         Object* element = array->get(j);
         if (element->IsHeapObject()) {
           HeapObject* element_object = HeapObject::cast(element);
-          ASSERT(HEAP->Contains(element_object));
+          ASSERT(heap()->Contains(element_object));
           ASSERT(element_object->map()->IsMap());
-          if (HEAP->InNewSpace(element_object)) {
+          if (heap()->InNewSpace(element_object)) {
             Address array_addr = object->address();
             Address element_addr = array_addr + FixedArray::kHeaderSize +
                 j * kPointerSize;
 
             ASSERT(Page::FromAddress(array_addr)->IsRegionDirty(element_addr));
           }
         }
       }
     }
   }
@@ skipping 17 matching lines @@
     num_objects++;
     CollectHistogramInfo(obj);
   }
 
   PrintF("  number of objects %d\n", num_objects);
   if (num_objects > 0) ReportHistogram(false);
 }
 
 
 void LargeObjectSpace::CollectCodeStatistics() {
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = heap()->isolate();
   LargeObjectIterator obj_it(this);
   for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       isolate->code_kind_statistics()[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal