Refactor how embedded pointers are visited.

src/mark-compact.cc

Index: src/mark-compact.cc
diff --git a/src/mark-compact.cc b/src/mark-compact.cc
index 6250e5439f17e52f129457dcd13b65ef45ece1a2..7fc0324065861802860047f425ebc0a8395896ca 100644
--- a/src/mark-compact.cc
+++ b/src/mark-compact.cc
@@ -847,10 +847,14 @@ class StaticMarkingVisitor : public StaticVisitorBase {
     heap->mark_compact_collector()->MarkObject(cell, mark);
   }
 
-  static inline void VisitEmbeddedPointer(Heap* heap, Code* host, Object** p) {
-    MarkObjectByPointer(heap->mark_compact_collector(),
-                        reinterpret_cast<Object**>(host),
-                        p);
+  static inline void VisitEmbeddedPointer(Heap* heap, RelocInfo* rinfo) {
+    ASSERT(rinfo->rmode() == RelocInfo::EMBEDDED_OBJECT);
+    // TODO(mstarzinger): We do not short-circuit cons strings here, verify
+    // that there can be no such embedded pointers and add assertion here.
+    HeapObject* object = HeapObject::cast(rinfo->target_object());
+    heap->mark_compact_collector()->RecordEmbeddedSlot(rinfo, object);
+    MarkBit mark = Marking::MarkBitFrom(object);
+    heap->mark_compact_collector()->MarkObject(object, mark);
   }
 
   static inline void VisitCodeTarget(Heap* heap, RelocInfo* rinfo) {
@@ -2458,8 +2462,11 @@ class PointersUpdatingVisitor: public ObjectVisitor {
     for (Object** p = start; p < end; p++) UpdatePointer(p);
   }
 
-  void VisitEmbeddedPointer(Code* host, Object** p) {
-    UpdatePointer(p);
+  void VisitEmbeddedPointer(RelocInfo* rinfo) {
+    ASSERT(rinfo->rmode() == RelocInfo::EMBEDDED_OBJECT);
+    Object* target = rinfo->target_object();
+    VisitPointer(&target);
+    rinfo->set_target_object(target);
   }
 
   void VisitCodeTarget(RelocInfo* rinfo) {
@@ -2773,6 +2780,11 @@ static inline void UpdateSlot(ObjectVisitor* v,
       if (rinfo.IsPatchedReturnSequence()) rinfo.Visit(v);
       break;
     }
+    case SlotsBuffer::EMBEDDED_OBJECT_SLOT: {
+      RelocInfo rinfo(addr, RelocInfo::EMBEDDED_OBJECT, 0, NULL);
+      rinfo.Visit(v);
+      break;
+    }
     default:
       UNREACHABLE();
       break;
@@ -3717,8 +3729,7 @@ static inline SlotsBuffer::SlotType SlotTypeForRMode(RelocInfo::Mode rmode) {
 
 
 void MarkCompactCollector::RecordRelocSlot(RelocInfo* rinfo, Code* target) {
-  Page* target_page = Page::FromAddress(
-      reinterpret_cast<Address>(target));
+  Page* target_page = Page::FromAddress(reinterpret_cast<Address>(target));
   if (target_page->IsEvacuationCandidate() &&
       (rinfo->host() == NULL ||
        !ShouldSkipEvacuationSlotRecording(rinfo->host()))) {
@@ -3734,8 +3745,7 @@ void MarkCompactCollector::RecordRelocSlot(RelocInfo* rinfo, Code* target) {
 
 
 void MarkCompactCollector::RecordCodeEntrySlot(Address slot, Code* target) {
-  Page* target_page = Page::FromAddress(
-      reinterpret_cast<Address>(target));
+  Page* target_page = Page::FromAddress(reinterpret_cast<Address>(target));
   if (target_page->IsEvacuationCandidate() &&
       !ShouldSkipEvacuationSlotRecording(reinterpret_cast<Object**>(slot))) {
     if (!SlotsBuffer::AddTo(&slots_buffer_allocator_,
@@ -3749,6 +3759,22 @@ void MarkCompactCollector::RecordCodeEntrySlot(Address slot, Code* target) {
 }
 
 
+void MarkCompactCollector::RecordEmbeddedSlot(RelocInfo* rinfo,

[Vyacheslav Egorov (Chromium), 2011/10/12 14:21:53]

Why not unify with RecordRelocSlot? seems almost identical.

[Michael Starzinger, 2011/10/12 15:38:36]

Done.

+                                              Object* target) {
+  Page* object_page = Page::FromAddress(reinterpret_cast<Address>(target));
+  if (object_page->IsEvacuationCandidate() &&
+      !ShouldSkipEvacuationSlotRecording(rinfo->host())) {
+    if (!SlotsBuffer::AddTo(&slots_buffer_allocator_,
+                            object_page->slots_buffer_address(),
+                            SlotsBuffer::EMBEDDED_OBJECT_SLOT,
+                            rinfo->pc(),
+                            SlotsBuffer::FAIL_ON_OVERFLOW)) {
+      EvictEvacuationCandidate(object_page);
+    }
+  }
+}
+
+
 static inline SlotsBuffer::SlotType DecodeSlotType(
     SlotsBuffer::ObjectSlot slot) {
   return static_cast<SlotsBuffer::SlotType>(reinterpret_cast<intptr_t>(slot));