Make embedded maps in optimized code weak.

src/objects-visiting-inl.h

 // Copyright 2012 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 243 matching lines @@
 void StaticMarkingVisitor<StaticVisitor>::VisitMap(
     Map* map, HeapObject* object) {
   Heap* heap = map->GetHeap();
   Map* map_object = Map::cast(object);
 
   // Clears the cache of ICs related to this map.
   if (FLAG_cleanup_code_caches_at_gc) {
     map_object->ClearCodeCache(heap);
   }
 
-  // When map collection is enabled we have to mark through map's
-  // transitions and back pointers in a special way to make these links
-  // weak.  Only maps for subclasses of JSReceiver can have transitions.
-  STATIC_ASSERT(LAST_TYPE == LAST_JS_RECEIVER_TYPE);
-  if (FLAG_collect_maps &&
-      map_object->instance_type() >= FIRST_JS_RECEIVER_TYPE) {
+  // When map collection is enabled we have to mark through map's transitions
+  // and back pointers in a special way to make these links weak.
+  if (FLAG_collect_maps && map_object->CanTransition()) {
     MarkMapContents(heap, map_object);
   } else {
     StaticVisitor::VisitPointers(heap,
         HeapObject::RawField(object, Map::kPointerFieldsBeginOffset),
         HeapObject::RawField(object, Map::kPointerFieldsEndOffset));
   }
 }
 
 
 template<typename StaticVisitor>
@@ skipping 107 matching lines @@
   // array slot, since it will be implicitly recorded when the pointer
   // fields of this map are visited.
   TransitionArray* transitions = map->unchecked_transition_array();
   if (transitions->IsTransitionArray()) {
     MarkTransitionArray(heap, transitions);
   } else {
     // Already marked by marking map->GetBackPointer() above.
     ASSERT(transitions->IsMap() || transitions->IsUndefined());
   }
 
+  // Mark prototype dependent codes array but do not push it onto marking
+  // stack, this will make references from it weak. We will clean dead
+  // dead codes when we iterate over maps in ClearNonLiveTransitions.
+  Object** slot = HeapObject::RawField(reinterpret_cast<HeapObject*>(map),
+                                       Map::kDependentCodesOffset);
+  HeapObject* obj = HeapObject::cast(*slot);
+  heap->mark_compact_collector()->RecordSlot(slot, slot, obj);
+  StaticVisitor::MarkObjectWithoutPush(heap, obj);
+
   // Mark the pointer fields of the Map. Since the transitions array has
   // been marked already, it is fine that one of these fields contains a
   // pointer to it.
   StaticVisitor::VisitPointers(heap,
       HeapObject::RawField(map, Map::kPointerFieldsBeginOffset),
       HeapObject::RawField(map, Map::kPointerFieldsEndOffset));
 }
 
 
 template<typename StaticVisitor>
@@ skipping 231 matching lines @@
                   RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY);
 
   // There are two places where we iterate code bodies: here and the
   // templated CodeIterateBody (below).  They should be kept in sync.
   IteratePointer(v, kRelocationInfoOffset);
   IteratePointer(v, kHandlerTableOffset);
   IteratePointer(v, kDeoptimizationDataOffset);
   IteratePointer(v, kTypeFeedbackInfoOffset);
 
   RelocIterator it(this, mode_mask);
-  for (; !it.done(); it.next()) {
-    it.rinfo()->Visit(v);
+  if (kind() == OPTIMIZED_FUNCTION) {
+    // Treat embedded maps in optimized code as weak.

[Michael Starzinger, 2012/12/14 14:15:26]

I think this is the wrong place to skip embedded maps because this visitor is
used in other places (e.g. HeapObject::IterateBody) as well. And there you don't
want to skip embedded maps. So this has to be specific to the
StaticMarkingVisitor. We already talked about this offline.

[ulan, 2013/01/17 09:35:10]

Done.

+    for (; !it.done(); it.next()) {
+      RelocInfo* info = it.rinfo();
+      if (!RelocInfo::IsEmbeddedObject(info->rmode()) ||
+          !info->target_object()->IsMap() ||
+          !Map::cast(info->target_object())->CanTransition()) {
+        info->Visit(v);
+      }
+    }
+  } else {
+    for (; !it.done(); it.next()) {
+      it.rinfo()->Visit(v);
+    }
   }
 }
 
 
 template<typename StaticVisitor>
 void Code::CodeIterateBody(Heap* heap) {
   int mode_mask = RelocInfo::kCodeTargetMask |
                   RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
                   RelocInfo::ModeMask(RelocInfo::GLOBAL_PROPERTY_CELL) |
                   RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) |
@@ skipping 10 matching lines @@
       heap,
       reinterpret_cast<Object**>(this->address() + kHandlerTableOffset));
   StaticVisitor::VisitPointer(
       heap,
       reinterpret_cast<Object**>(this->address() + kDeoptimizationDataOffset));
   StaticVisitor::VisitPointer(
       heap,
       reinterpret_cast<Object**>(this->address() + kTypeFeedbackInfoOffset));
 
   RelocIterator it(this, mode_mask);
-  for (; !it.done(); it.next()) {
-    it.rinfo()->template Visit<StaticVisitor>(heap);
+  if (kind() == OPTIMIZED_FUNCTION) {
+    // Treat embedded maps in optimized code as weak.

[Michael Starzinger, 2012/12/14 14:15:26]

Likewise.

[ulan, 2013/01/17 09:35:10]

Done.

+    for (; !it.done(); it.next()) {
+      RelocInfo* info = it.rinfo();
+      if (!RelocInfo::IsEmbeddedObject(info->rmode()) ||
+          !info->target_object()->IsMap() ||
+          !Map::cast(info->target_object())->CanTransition()) {
+        it.rinfo()->template Visit<StaticVisitor>(heap);
+      }
+    }
+  } else {
+    for (; !it.done(); it.next()) {
+      it.rinfo()->template Visit<StaticVisitor>(heap);
+    }
   }
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_VISITING_INL_H_