Reland "Replace ad-hoc weakness in prototype transitions with WeakCell."

src/transitions.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/objects.h"
 #include "src/transitions-inl.h"
 #include "src/utils.h"
 
@@ skipping 215 matching lines @@
   Object* raw_transitions = map->raw_transitions();
   if (IsFullTransitionArray(raw_transitions)) {
     TransitionArray* transitions = TransitionArray::cast(raw_transitions);
     return transitions->number_of_transitions() < kMaxNumberOfTransitions;
   }
   return true;
 }
 
 
 // static
-Handle<Map> TransitionArray::PutPrototypeTransition(Handle<Map> map,
-                                                    Handle<Object> prototype,
-                                                    Handle<Map> target_map) {
+void TransitionArray::PutPrototypeTransition(Handle<Map> map,
+                                             Handle<Object> prototype,
+                                             Handle<Map> target_map) {
   DCHECK(HeapObject::cast(*prototype)->map()->IsMap());
   // Don't cache prototype transition if this map is either shared, or a map of
   // a prototype.
-  if (map->is_prototype_map()) return map;
-  if (map->is_dictionary_map() || !FLAG_cache_prototype_transitions) return map;
+  if (map->is_prototype_map()) return;
+  if (map->is_dictionary_map() || !FLAG_cache_prototype_transitions) return;
 
   const int header = kProtoTransitionHeaderSize;
 
+  Handle<WeakCell> target_cell = Map::WeakCellForMap(target_map);
+
   Handle<FixedArray> cache(GetPrototypeTransitions(*map));
   int capacity = cache->length() - header;
   int transitions = NumberOfPrototypeTransitions(*cache) + 1;
 
   if (transitions > capacity) {
     // Grow array by factor 2 up to MaxCachedPrototypeTransitions.
     int new_capacity = Min(kMaxCachedPrototypeTransitions, transitions * 2);
-    if (new_capacity == capacity) return map;
+    if (new_capacity == capacity) return;
 
     cache = FixedArray::CopySize(cache, header + new_capacity);
     if (capacity < 0) {
       // There was no prototype transitions array before, so the size
       // couldn't be copied. Initialize it explicitly.
       SetNumberOfPrototypeTransitions(*cache, 0);
     }
 
     SetPrototypeTransitions(map, cache);
   }
 
   // Reload number of transitions as GC might shrink them.
   int last = NumberOfPrototypeTransitions(*cache);
   int entry = header + last;
 
-  cache->set(entry, *target_map);
+  cache->set(entry, *target_cell);
   SetNumberOfPrototypeTransitions(*cache, last + 1);
-
-  return map;
 }
 
 
 // static
 Handle<Map> TransitionArray::GetPrototypeTransition(Handle<Map> map,
                                                     Handle<Object> prototype) {
   DisallowHeapAllocation no_gc;
   FixedArray* cache = GetPrototypeTransitions(*map);
   int number_of_transitions = NumberOfPrototypeTransitions(cache);
   for (int i = 0; i < number_of_transitions; i++) {
-    Map* target = Map::cast(cache->get(kProtoTransitionHeaderSize + i));
-    if (target->prototype() == *prototype) return handle(target);
+    WeakCell* target_cell =
+        WeakCell::cast(cache->get(kProtoTransitionHeaderSize + i));
+    if (!target_cell->cleared() &&
+        Map::cast(target_cell->value())->prototype() == *prototype) {
+      return handle(Map::cast(target_cell->value()));
+    }
   }
   return Handle<Map>();
 }
 
 
 // static
 FixedArray* TransitionArray::GetPrototypeTransitions(Map* map) {
   Object* raw_transitions = map->raw_transitions();
   Heap* heap = map->GetHeap();
   if (!IsFullTransitionArray(raw_transitions)) {
@@ skipping 133 matching lines @@
 void TransitionArray::TraverseTransitionTreeInternal(Map* map,
                                                      TraverseCallback callback,
                                                      void* data) {
   Object* raw_transitions = map->raw_transitions();
   if (IsFullTransitionArray(raw_transitions)) {
     TransitionArray* transitions = TransitionArray::cast(raw_transitions);
     if (transitions->HasPrototypeTransitions()) {
       FixedArray* proto_trans = transitions->GetPrototypeTransitions();
       for (int i = 0; i < NumberOfPrototypeTransitions(proto_trans); ++i) {
         int index = TransitionArray::kProtoTransitionHeaderSize + i;
-        TraverseTransitionTreeInternal(Map::cast(proto_trans->get(index)),
-                                       callback, data);
+        WeakCell* cell = WeakCell::cast(proto_trans->get(index));
+        TraverseTransitionTreeInternal(Map::cast(cell->value()), callback,
+                                       data);
       }
     }
     for (int i = 0; i < transitions->number_of_transitions(); ++i) {
       TraverseTransitionTreeInternal(transitions->GetTarget(i), callback, data);
     }
   } else if (IsSimpleTransition(raw_transitions)) {
     TraverseTransitionTreeInternal(GetSimpleTransition(raw_transitions),
                                    callback, data);
   }
   callback(map, data);
@@ skipping 57 matching lines @@
                             PropertyAttributes attributes,
                             int* out_insertion_index) {
   int transition = SearchName(name, out_insertion_index);
   if (transition == kNotFound) {
     return kNotFound;
   }
   return SearchDetails(transition, kind, attributes, out_insertion_index);
 }
 }  // namespace internal
 }  // namespace v8