Adding GC hooks to support LiveObjectList functionality.

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 15 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
 #include "compilation-cache.h"
 #include "execution.h"
 #include "heap-profiler.h"
 #include "gdb-jit.h"
 #include "global-handles.h"
 #include "ic-inl.h"
+#include "liveobjectlist-inl.h"
 #include "mark-compact.h"
 #include "objects-visiting.h"
 #include "stub-cache.h"
 
 namespace v8 {
 namespace internal {
 
 // -------------------------------------------------------------------------
 // MarkCompactCollector
 
@@ skipping 1607 matching lines @@
         EncodeFreeRegion(free_start, static_cast<int>(current - free_start));
         is_prev_alive = true;
       }
     } else {  // Non-live object.
       object_size = object->Size();
       ProcessNonLive(object);
       if (is_prev_alive) {  // Transition from live to non-live.
         free_start = current;
         is_prev_alive = false;
       }
+      LiveObjectList::ProcessNonLive(object);
     }
   }
 
   // If we ended on a free region, mark it.
   if (!is_prev_alive) {
     EncodeFreeRegion(free_start, static_cast<int>(end - free_start));
   }
 }
 
 
@@ skipping 200 matching lines @@
 
       // Promotion failed. Just migrate object to another semispace.
       // Allocation cannot fail at this point: semispaces are of equal size.
       Object* target = space->AllocateRaw(size)->ToObjectUnchecked();
 
       MigrateObject(HeapObject::cast(target)->address(),
                     current,
                     size,
                     false);
     } else {
+      // Process the dead object before we write a NULL into its header.
+      LiveObjectList::ProcessNonLive(object);
+
       size = object->Size();
       Memory::Address_at(current) = NULL;
     }
   }
 
   // Second pass: find pointers to new space and update them.
   PointersToNewGenUpdatingVisitor updating_visitor;
 
   // Update pointers in to space.
   Address current = space->bottom();
   while (current < space->top()) {
     HeapObject* object = HeapObject::FromAddress(current);
     current +=
         StaticPointersToNewGenUpdatingVisitor::IterateBody(object->map(),
                                                            object);
   }
 
   // Update roots.
   Heap::IterateRoots(&updating_visitor, VISIT_ALL_IN_SCAVENGE);
+  LiveObjectList::IterateElements(&updating_visitor);
 
   // Update pointers in old spaces.
   Heap::IterateDirtyRegions(Heap::old_pointer_space(),
                             &Heap::IteratePointersInDirtyRegion,
                             &UpdatePointerToNewGen,
                             Heap::WATERMARK_SHOULD_BE_VALID);
 
   Heap::lo_space()->IterateDirtyRegions(&UpdatePointerToNewGen);
 
   // Update pointers from cells.
@@ skipping 67 matching lines @@
                                  static_cast<int>(current - free_start),
                                  true);
           is_previous_alive = true;
         }
       } else {
         MarkCompactCollector::ReportDeleteIfNeeded(object);
         if (is_previous_alive) {  // Transition from live to free.
           free_start = current;
           is_previous_alive = false;
         }
+        LiveObjectList::ProcessNonLive(object);
       }
       // The object is now unmarked for the call to Size() at the top of the
       // loop.
     }
 
     bool page_is_empty = (p->ObjectAreaStart() == p->AllocationTop())
         || (!is_previous_alive && free_start == p->ObjectAreaStart());
 
     if (page_is_empty) {
       // This page is empty. Check whether we are in the middle of
@@ skipping 158 matching lines @@
     }
 
 #ifdef DEBUG
     CheckNoMapsToEvacuate();
 #endif
   }
 
   void UpdateMapPointersInRoots() {
     Heap::IterateRoots(&map_updating_visitor_, VISIT_ONLY_STRONG);
     GlobalHandles::IterateWeakRoots(&map_updating_visitor_);
+    LiveObjectList::IterateElements(&map_updating_visitor_);
   }
 
   void UpdateMapPointersInPagedSpace(PagedSpace* space) {
     ASSERT(space != Heap::map_space());
 
     PageIterator it(space, PageIterator::PAGES_IN_USE);
     while (it.has_next()) {
       Page* p = it.next();
       UpdateMapPointersInRange(p->ObjectAreaStart(), p->AllocationTop());
     }
@@ skipping 349 matching lines @@
   ASSERT(state_ == ENCODE_FORWARDING_ADDRESSES);
   state_ = UPDATE_POINTERS;
 #endif
   UpdatingVisitor updating_visitor;
   Heap::IterateRoots(&updating_visitor, VISIT_ONLY_STRONG);
   GlobalHandles::IterateWeakRoots(&updating_visitor);
 
   // Update the pointer to the head of the weak list of global contexts.
   updating_visitor.VisitPointer(&Heap::global_contexts_list_);
 
+  LiveObjectList::IterateElements(&updating_visitor);
+
   int live_maps_size = IterateLiveObjects(Heap::map_space(),
                                           &UpdatePointersInOldObject);
   int live_pointer_olds_size = IterateLiveObjects(Heap::old_pointer_space(),
                                                   &UpdatePointersInOldObject);
   int live_data_olds_size = IterateLiveObjects(Heap::old_data_space(),
                                                &UpdatePointersInOldObject);
   int live_codes_size = IterateLiveObjects(Heap::code_space(),
                                            &UpdatePointersInOldObject);
   int live_cells_size = IterateLiveObjects(Heap::cell_space(),
                                            &UpdatePointersInOldObject);
@@ skipping 389 matching lines @@
 }
 
 
 void MarkCompactCollector::Initialize() {
   StaticPointersToNewGenUpdatingVisitor::Initialize();
   StaticMarkingVisitor::Initialize();
 }
 
 
 } }  // namespace v8::internal