[Isolates] Merge r 6300:6500 from bleeding_edge to isolates.

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 12 matching lines @@
 // 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.
 
 #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 72 matching lines @@
   ASSERT(!FLAG_always_compact || !FLAG_never_compact);
 
   compacting_collection_ =
       FLAG_always_compact || force_compaction_ || compact_on_next_gc_;
   compact_on_next_gc_ = false;
 
   if (FLAG_never_compact) compacting_collection_ = false;
   if (!HEAP->map_space()->MapPointersEncodable())
       compacting_collection_ = false;
   if (FLAG_collect_maps) CreateBackPointers();
+#ifdef ENABLE_GDB_JIT_INTERFACE
+  if (FLAG_gdbjit) {
+    // If GDBJIT interface is active disable compaction.
+    compacting_collection_ = false;
+  }
+#endif
 
   PagedSpaces spaces;
   for (PagedSpace* space = spaces.next();
        space != NULL; space = spaces.next()) {
     space->PrepareForMarkCompact(compacting_collection_);
   }
 
 #ifdef DEBUG
   live_bytes_ = 0;
   live_young_objects_size_ = 0;
@@ skipping 1563 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 211 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(heap,
                     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(heap);
 
   // 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 {
         heap->mark_compact_collector()->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 160 matching lines @@
 
 #ifdef DEBUG
     CheckNoMapsToEvacuate();
 #endif
   }
 
   void UpdateMapPointersInRoots() {
     MapUpdatingVisitor map_updating_visitor;
     heap_->IterateRoots(&map_updating_visitor, VISIT_ONLY_STRONG);
     heap_->isolate_->global_handles()->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(heap_, p->ObjectAreaStart(), p->AllocationTop());
     }
@@ skipping 352 matching lines @@
   ASSERT(state_ == ENCODE_FORWARDING_ADDRESSES);
   state_ = UPDATE_POINTERS;
 #endif
   UpdatingVisitor updating_visitor(heap_);
   heap_->IterateRoots(&updating_visitor, VISIT_ONLY_STRONG);
   heap_->isolate_->global_handles()->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(), &MarkCompactCollector::UpdatePointersInOldObject);
   int live_pointer_olds_size = IterateLiveObjects(
       heap_->old_pointer_space(),
       &MarkCompactCollector::UpdatePointersInOldObject);
   int live_data_olds_size = IterateLiveObjects(
       heap_->old_data_space(),
       &MarkCompactCollector::UpdatePointersInOldObject);
   int live_codes_size = IterateLiveObjects(
       heap_->code_space(), &MarkCompactCollector::UpdatePointersInOldObject);
@@ skipping 375 matching lines @@
     code_flusher_ = new CodeFlusher(heap_->isolate());
   } else {
     if (code_flusher_ == NULL) return;
     delete code_flusher_;
     code_flusher_ = NULL;
   }
 }
 
 
 void MarkCompactCollector::ReportDeleteIfNeeded(HeapObject* obj) {
+#ifdef ENABLE_GDB_JIT_INTERFACE
+  if (obj->IsCode()) {
+    GDBJITInterface::RemoveCode(reinterpret_cast<Code*>(obj));
+  }
+#endif
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (obj->IsCode()) {
     PROFILE(CodeDeleteEvent(obj->address()));
   } else if (obj->IsJSFunction()) {
     PROFILE(FunctionDeleteEvent(obj->address()));
   }
 #endif
 }
 
 
 int MarkCompactCollector::SizeOfMarkedObject(HeapObject* obj) {
   MapWord map_word = obj->map_word();
   map_word.ClearMark();
   return obj->SizeFromMap(map_word.ToMap());
 }
 
 
 void MarkCompactCollector::Initialize() {
   StaticPointersToNewGenUpdatingVisitor::Initialize();
   StaticMarkingVisitor::Initialize();
 }
 
 
 } }  // namespace v8::internal