[Isolates] Remove more HEAP macros from GC.

src/mark-compact.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 216 matching lines @@
   //   (ConsString::cast(object)->second() == HEAP->empty_string())
   // except the maps for the object and its possible substrings might be
   // marked.
   HeapObject* object = HeapObject::cast(*p);
   MapWord map_word = object->map_word();
   map_word.ClearMark();
   InstanceType type = map_word.ToMap()->instance_type();
   if ((type & kShortcutTypeMask) != kShortcutTypeTag) return object;
 
   Object* second = reinterpret_cast<ConsString*>(object)->unchecked_second();
-  if (second != HEAP->raw_unchecked_empty_string()) {
+  Heap* heap = map_word.ToMap()->heap();
+  if (second != heap->raw_unchecked_empty_string()) {
     return object;
   }
 
   // Since we don't have the object's start, it is impossible to update the
   // page dirty marks. Therefore, we only replace the string with its left
   // substring when page dirty marks do not change.
   Object* first = reinterpret_cast<ConsString*>(object)->unchecked_first();
-  if (!HEAP->InNewSpace(object) && HEAP->InNewSpace(first)) return object;
+  if (!heap->InNewSpace(object) && heap->InNewSpace(first)) return object;
 
   *p = first;
   return HeapObject::cast(first);
 }
 
 
 class StaticMarkingVisitor : public StaticVisitorBase {
  public:
   static inline void IterateBody(Map* map, HeapObject* obj) {
     table_.GetVisitor(map)(map, obj);
@@ skipping 1001 matching lines @@
       Memory::Address_at(free_start + offset) = kZapValue;
     }
   }
 #endif
 }
 
 
 // Try to promote all objects in new space.  Heap numbers and sequential
 // strings are promoted to the code space, large objects to large object space,
 // and all others to the old space.
-inline Object* MCAllocateFromNewSpace(HeapObject* object, int object_size) {
+inline Object* MCAllocateFromNewSpace(Heap* heap,
+                                      HeapObject* object,
+                                      int object_size) {
   Object* forwarded;
-  if (object_size > HEAP->MaxObjectSizeInPagedSpace()) {
+  if (object_size > heap->MaxObjectSizeInPagedSpace()) {
     forwarded = Failure::Exception();
   } else {
-    OldSpace* target_space = HEAP->TargetSpace(object);
-    ASSERT(target_space == HEAP->old_pointer_space() ||
-           target_space == HEAP->old_data_space());
+    OldSpace* target_space = heap->TargetSpace(object);
+    ASSERT(target_space == heap->old_pointer_space() ||
+           target_space == heap->old_data_space());
     forwarded = target_space->MCAllocateRaw(object_size);
   }
   if (forwarded->IsFailure()) {
-    forwarded = HEAP->new_space()->MCAllocateRaw(object_size);
+    forwarded = heap->new_space()->MCAllocateRaw(object_size);
   }
   return forwarded;
 }
 
 
 // Allocation functions for the paged spaces call the space's MCAllocateRaw.
-inline Object* MCAllocateFromOldPointerSpace(HeapObject* ignore,
+inline Object* MCAllocateFromOldPointerSpace(Heap* heap,
+                                             HeapObject* ignore,
                                              int object_size) {
-  return HEAP->old_pointer_space()->MCAllocateRaw(object_size);
+  return heap->old_pointer_space()->MCAllocateRaw(object_size);
 }
 
 
-inline Object* MCAllocateFromOldDataSpace(HeapObject* ignore, int object_size) {
-  return HEAP->old_data_space()->MCAllocateRaw(object_size);
+inline Object* MCAllocateFromOldDataSpace(Heap* heap,
+                                          HeapObject* ignore,
+                                          int object_size) {
+  return heap->old_data_space()->MCAllocateRaw(object_size);
 }
 
 
-inline Object* MCAllocateFromCodeSpace(HeapObject* ignore, int object_size) {
-  return HEAP->code_space()->MCAllocateRaw(object_size);
+inline Object* MCAllocateFromCodeSpace(Heap* heap,
+                                       HeapObject* ignore,
+                                       int object_size) {
+  return heap->code_space()->MCAllocateRaw(object_size);
 }
 
 
-inline Object* MCAllocateFromMapSpace(HeapObject* ignore, int object_size) {
-  return HEAP->map_space()->MCAllocateRaw(object_size);
+inline Object* MCAllocateFromMapSpace(Heap* heap,
+                                      HeapObject* ignore,
+                                      int object_size) {
+  return heap->map_space()->MCAllocateRaw(object_size);
 }
 
 
-inline Object* MCAllocateFromCellSpace(HeapObject* ignore, int object_size) {
-  return HEAP->cell_space()->MCAllocateRaw(object_size);
+inline Object* MCAllocateFromCellSpace(Heap* heap,
+                                       HeapObject* ignore,
+                                       int object_size) {
+  return heap->cell_space()->MCAllocateRaw(object_size);
 }
 
 
 // The forwarding address is encoded at the same offset as the current
 // to-space object, but in from space.
-inline void EncodeForwardingAddressInNewSpace(HeapObject* old_object,
+inline void EncodeForwardingAddressInNewSpace(Heap* heap,
+                                              HeapObject* old_object,
                                               int object_size,
                                               Object* new_object,
                                               int* ignored) {
   int offset =
-      HEAP->new_space()->ToSpaceOffsetForAddress(old_object->address());
-  Memory::Address_at(HEAP->new_space()->FromSpaceLow() + offset) =
+      heap->new_space()->ToSpaceOffsetForAddress(old_object->address());
+  Memory::Address_at(heap->new_space()->FromSpaceLow() + offset) =
       HeapObject::cast(new_object)->address();
 }
 
 
 // The forwarding address is encoded in the map pointer of the object as an
 // offset (in terms of live bytes) from the address of the first live object
 // in the page.
-inline void EncodeForwardingAddressInPagedSpace(HeapObject* old_object,
+inline void EncodeForwardingAddressInPagedSpace(Heap* heap,
+                                                HeapObject* old_object,
                                                 int object_size,
                                                 Object* new_object,
                                                 int* offset) {
   // Record the forwarding address of the first live object if necessary.
   if (*offset == 0) {
     Page::FromAddress(old_object->address())->mc_first_forwarded =
         HeapObject::cast(new_object)->address();
   }
 
   MapWord encoding =
@@ skipping 36 matching lines @@
   bool is_prev_alive = true;
 
   int object_size;  // Will be set on each iteration of the loop.
   for (Address current = start; current < end; current += object_size) {
     HeapObject* object = HeapObject::FromAddress(current);
     if (object->IsMarked()) {
       object->ClearMark();
       collector->tracer()->decrement_marked_count();
       object_size = object->Size();
 
-      Object* forwarded = Alloc(object, object_size);
+      Object* forwarded = Alloc(collector->heap(), object, object_size);
       // Allocation cannot fail, because we are compacting the space.
       ASSERT(!forwarded->IsFailure());
-      Encode(object, object_size, forwarded, offset);
+      Encode(collector->heap(), object, object_size, forwarded, offset);
 
 #ifdef DEBUG
       if (FLAG_gc_verbose) {
         PrintF("forward %p -> %p.\n", object->address(),
                HeapObject::cast(forwarded)->address());
       }
 #endif
       if (!is_prev_alive) {  // Transition from non-live to live.
         EncodeFreeRegion(free_start, static_cast<int>(current - free_start));
         is_prev_alive = true;
@@ skipping 15 matching lines @@
 }
 
 
 // Functions to encode the forwarding pointers in each compactable space.
 void MarkCompactCollector::EncodeForwardingAddressesInNewSpace() {
   int ignored;
   EncodeForwardingAddressesInRange<MCAllocateFromNewSpace,
                                    EncodeForwardingAddressInNewSpace,
                                    IgnoreNonLiveObject>(
       this,
-      HEAP->new_space()->bottom(),
-      HEAP->new_space()->top(),
+      heap_->new_space()->bottom(),
+      heap_->new_space()->top(),
       &ignored);
 }
 
 
 template<MarkCompactCollector::AllocationFunction Alloc,
          MarkCompactCollector::ProcessNonLiveFunction ProcessNonLive>
 void MarkCompactCollector::EncodeForwardingAddressesInPagedSpace(
     PagedSpace* space) {
   PageIterator it(space, PageIterator::PAGES_IN_USE);
   while (it.has_next()) {
@@ skipping 389 matching lines @@
     space->SetTop(new_allocation_top);
   }
 }
 
 
 void MarkCompactCollector::EncodeForwardingAddresses() {
   ASSERT(state_ == ENCODE_FORWARDING_ADDRESSES);
   // Objects in the active semispace of the young generation may be
   // relocated to the inactive semispace (if not promoted).  Set the
   // relocation info to the beginning of the inactive semispace.
-  HEAP->new_space()->MCResetRelocationInfo();
+  heap_->new_space()->MCResetRelocationInfo();
 
   // Compute the forwarding pointers in each space.
   EncodeForwardingAddressesInPagedSpace<MCAllocateFromOldPointerSpace,
                                         ReportDeleteIfNeeded>(
-      HEAP->old_pointer_space());
+      heap_->old_pointer_space());
 
   EncodeForwardingAddressesInPagedSpace<MCAllocateFromOldDataSpace,
                                         IgnoreNonLiveObject>(
-      HEAP->old_data_space());
+      heap_->old_data_space());
 
   EncodeForwardingAddressesInPagedSpace<MCAllocateFromCodeSpace,
                                         ReportDeleteIfNeeded>(
-      HEAP->code_space());
+      heap_->code_space());
 
   EncodeForwardingAddressesInPagedSpace<MCAllocateFromCellSpace,
                                         IgnoreNonLiveObject>(
-      HEAP->cell_space());
+      heap_->cell_space());
 
 
   // Compute new space next to last after the old and code spaces have been
   // compacted.  Objects in new space can be promoted to old or code space.
   EncodeForwardingAddressesInNewSpace();
 
   // Compute map space last because computing forwarding addresses
   // overwrites non-live objects.  Objects in the other spaces rely on
   // non-live map pointers to get the sizes of non-live objects.
   EncodeForwardingAddressesInPagedSpace<MCAllocateFromMapSpace,
                                         IgnoreNonLiveObject>(
-      HEAP->map_space());
+      heap_->map_space());
 
   // Write relocation info to the top page, so we can use it later.  This is
   // done after promoting objects from the new space so we get the correct
   // allocation top.
-  HEAP->old_pointer_space()->MCWriteRelocationInfoToPage();
-  HEAP->old_data_space()->MCWriteRelocationInfoToPage();
-  HEAP->code_space()->MCWriteRelocationInfoToPage();
-  HEAP->map_space()->MCWriteRelocationInfoToPage();
-  HEAP->cell_space()->MCWriteRelocationInfoToPage();
+  heap_->old_pointer_space()->MCWriteRelocationInfoToPage();
+  heap_->old_data_space()->MCWriteRelocationInfoToPage();
+  heap_->code_space()->MCWriteRelocationInfoToPage();
+  heap_->map_space()->MCWriteRelocationInfoToPage();
+  heap_->cell_space()->MCWriteRelocationInfoToPage();
 }
 
 
 class MapIterator : public HeapObjectIterator {
  public:
   MapIterator() : HeapObjectIterator(HEAP->map_space(), &SizeCallback) { }
 
   explicit MapIterator(Address start)
       : HeapObjectIterator(HEAP->map_space(), start, &SizeCallback) { }
 
@@ skipping 122 matching lines @@
     ASSERT(map->IsMap());
     return map;
   }
 
   static void EvacuateMap(Map* vacant_map, Map* map_to_evacuate) {
     ASSERT(FreeListNode::IsFreeListNode(vacant_map));
     ASSERT(map_to_evacuate->IsMap());
 
     ASSERT(Map::kSize % 4 == 0);
 
-    HEAP->CopyBlockToOldSpaceAndUpdateRegionMarks(vacant_map->address(),
-                                                  map_to_evacuate->address(),
-                                                  Map::kSize);
+    map_to_evacuate->heap()->CopyBlockToOldSpaceAndUpdateRegionMarks(
+        vacant_map->address(), map_to_evacuate->address(), Map::kSize);
 
     ASSERT(vacant_map->IsMap());  // Due to memcpy above.
 
     MapWord forwarding_map_word = MapWord::FromMap(vacant_map);
     forwarding_map_word.SetOverflow();
     map_to_evacuate->set_map_word(forwarding_map_word);
 
     ASSERT(map_to_evacuate->map_word().IsOverflowed());
     ASSERT(GetForwardedMap(map_to_evacuate->map_word()) == vacant_map);
   }
@@ skipping 647 matching lines @@
 }
 
 
 void MarkCompactCollector::Initialize() {
   StaticPointersToNewGenUpdatingVisitor::Initialize();
   StaticMarkingVisitor::Initialize();
 }
 
 
 } }  // namespace v8::internal