Do not follow accessor map transitions when marking descriptor arrays.

src/mark-compact.cc

Index: src/mark-compact.cc
diff --git a/src/mark-compact.cc b/src/mark-compact.cc
index 93614aceba272263c529d86ed1982be323c68c74..1af1b632ab2a672c526d5e0de252a47fe7cfbcba 100644
--- a/src/mark-compact.cc
+++ b/src/mark-compact.cc
@@ -1672,6 +1672,32 @@ void MarkCompactCollector::MarkMapContents(Map* map) {
 }
 
 
+bool MarkCompactCollector::MarkUnmarked(Object* value) {

[Michael Starzinger, 2012/01/24 13:28:30]

The name is kind of misleading, because it not only handles unmarked objects,
but marked ones as well.

My suggestion is rename this to use a different signature and also to move it to
mark-compact-inl.h. Proposed new signature is:

void MarkCompactCollector::MarkObject(HeapObject* obj);

+  HeapObject* object = HeapObject::cast(value);
+  MarkBit mark = Marking::MarkBitFrom(object);
+  bool old_mark = mark.Get();
+  if (!old_mark) SetMark(object, mark);
+  return old_mark;
+}
+
+
+bool MarkCompactCollector::MarkUnmarkedAndPush(Object* value) {

[Michael Starzinger, 2012/01/24 13:28:30]

Boolean return value is never used, can we drop it?

Can we also move this to mark-compact-inl.h and rename it to
MarkObjectAndPush()?

+  bool old_mark = MarkUnmarked(value);
+  if (!old_mark) marking_deque_.PushBlack(HeapObject::cast(value));
+  return old_mark;
+}
+
+
+void MarkCompactCollector::MarkAccessorPairSlot(AccessorPair* accessors,
+                                                int offset) {
+  Object** slot = HeapObject::RawField(accessors, offset);
+  Object* accessor = *slot;
+  if (accessor->IsMap()) return;
+  RecordSlot(slot, slot, accessor);
+  MarkUnmarkedAndPush(accessor);
+}
+
+
 void MarkCompactCollector::MarkDescriptorArray(
     DescriptorArray* descriptors) {
   MarkBit descriptors_mark = Marking::MarkBitFrom(descriptors);
@@ -1704,22 +1730,33 @@ void MarkCompactCollector::MarkDescriptorArray(
 
     RecordSlot(slot, slot, *slot);
 
-    if (details.IsProperty()) {
-      HeapObject* object = HeapObject::cast(value);
-      MarkBit mark = Marking::MarkBitFrom(HeapObject::cast(object));
-      if (!mark.Get()) {
-        SetMark(HeapObject::cast(object), mark);
-        marking_deque_.PushBlack(object);
-      }
-    } else if (details.type() == ELEMENTS_TRANSITION && value->IsFixedArray()) {
-      // For maps with multiple elements transitions, the transition maps are
-      // stored in a FixedArray. Keep the fixed array alive but not the maps
-      // that it refers to.
-      HeapObject* object = HeapObject::cast(value);
-      MarkBit mark = Marking::MarkBitFrom(HeapObject::cast(object));
-      if (!mark.Get()) {
-        SetMark(HeapObject::cast(object), mark);
-      }
+    switch (details.type()) {
+      case NORMAL:
+      case FIELD:
+      case CONSTANT_FUNCTION:
+      case HANDLER:
+      case INTERCEPTOR:
+        MarkUnmarkedAndPush(value);
+        break;
+      case CALLBACKS:
+        if (!value->IsAccessorPair()) {
+          MarkUnmarkedAndPush(value);
+        } else if (!MarkUnmarked(value)) {
+          AccessorPair* accessors = AccessorPair::cast(value);
+          MarkAccessorPairSlot(accessors, AccessorPair::kGetterOffset);
+          MarkAccessorPairSlot(accessors, AccessorPair::kSetterOffset);
+        }
+        break;
+      case ELEMENTS_TRANSITION:
+        // For maps with multiple elements transitions, the transition maps are
+        // stored in a FixedArray. Keep the fixed array alive but not the maps
+        // that it refers to.
+        if (value->IsFixedArray()) MarkUnmarked(value);
+        break;
+      case MAP_TRANSITION:
+      case CONSTANT_TRANSITION:
+      case NULL_DESCRIPTOR:
+        break;
     }
   }
   // The DescriptorArray descriptors contains a pointer to its contents array,