Replace ad-hoc weakness in transition array 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"
 
 namespace v8 {
 namespace internal {
 
 
 // static
 void TransitionArray::Insert(Handle<Map> map, Handle<Name> name,
                              Handle<Map> target, SimpleTransitionFlag flag) {
   Isolate* isolate = map->GetIsolate();
   target->SetBackPointer(*map);
+  Handle<WeakCell> cell = Map::WeakCellForMap(target);
 
   // If the map doesn't have any transitions at all yet, install the new one.
   if (CanStoreSimpleTransition(map->raw_transitions())) {
     if (flag == SIMPLE_PROPERTY_TRANSITION) {
-      Handle<WeakCell> cell = Map::WeakCellForMap(target);
       ReplaceTransitions(map, *cell);
       return;
     }
     // If the flag requires a full TransitionArray, allocate one.
     Handle<TransitionArray> result = Allocate(isolate, 0, 1);
     ReplaceTransitions(map, *result);
   }
 
   bool is_special_transition = flag == SPECIAL_TRANSITION;
   // If the map has a simple transition, check if it should be overwritten.
   if (IsSimpleTransition(map->raw_transitions())) {
     Map* old_target = GetSimpleTransition(map->raw_transitions());
     Name* key = GetSimpleTransitionKey(old_target);
     PropertyDetails old_details = GetSimpleTargetDetails(old_target);
     PropertyDetails new_details = is_special_transition
                                       ? PropertyDetails::Empty()
                                       : GetTargetDetails(*name, *target);
     if (flag == SIMPLE_PROPERTY_TRANSITION && key->Equals(*name) &&
         old_details.kind() == new_details.kind() &&
         old_details.attributes() == new_details.attributes()) {
-      Handle<WeakCell> cell = Map::WeakCellForMap(target);
       ReplaceTransitions(map, *cell);
       return;
     }
     // Otherwise allocate a full TransitionArray with slack for a new entry.
     Handle<TransitionArray> result = Allocate(isolate, 1, 1);
     // Re-read existing data; the allocation might have caused it to be cleared.
     if (IsSimpleTransition(map->raw_transitions())) {
       old_target = GetSimpleTransition(map->raw_transitions());
-      result->NoIncrementalWriteBarrierSet(
-          0, GetSimpleTransitionKey(old_target), old_target);
+      result->Set(0, GetSimpleTransitionKey(old_target),
+                  GetSimpleTransitionCell(map->raw_transitions()));
     } else {
       result->SetNumberOfTransitions(0);
     }
     ReplaceTransitions(map, *result);
   }
 
   // At this point, we know that the map has a full TransitionArray.
   DCHECK(IsFullTransitionArray(map->raw_transitions()));
 
   int number_of_transitions = 0;
@@ skipping 10 matching lines @@
     number_of_transitions = array->number_of_transitions();
     new_nof = number_of_transitions;
 
     int index =
         is_special_transition
             ? array->SearchSpecial(Symbol::cast(*name), &insertion_index)
             : array->Search(details.kind(), *name, details.attributes(),
                             &insertion_index);
     // If an existing entry was found, overwrite it and return.
     if (index != kNotFound) {
-      array->SetTarget(index, *target);
+      array->SetTargetCell(index, *cell);
       return;
     }
 
     ++new_nof;
     CHECK(new_nof <= kMaxNumberOfTransitions);
     DCHECK(insertion_index >= 0 && insertion_index <= number_of_transitions);
 
     // If there is enough capacity, insert new entry into the existing array.
     if (new_nof <= Capacity(array)) {
       array->SetNumberOfTransitions(new_nof);
       for (index = number_of_transitions; index > insertion_index; --index) {
         array->SetKey(index, array->GetKey(index - 1));
-        array->SetTarget(index, array->GetTarget(index - 1));
+        array->SetTargetCell(index, array->GetTargetCell(index - 1));
       }
       array->SetKey(index, *name);
-      array->SetTarget(index, *target);
+      array->SetTargetCell(index, *cell);
       SLOW_DCHECK(array->IsSortedNoDuplicates());
       return;
     }
   }
 
   // We're gonna need a bigger TransitionArray.
   Handle<TransitionArray> result = Allocate(
       map->GetIsolate(), new_nof,
       Map::SlackForArraySize(number_of_transitions, kMaxNumberOfTransitions));
 
@@ skipping 25 matching lines @@
     result->Shrink(ToKeyIndex(new_nof));
     result->SetNumberOfTransitions(new_nof);
   }
 
   if (array->HasPrototypeTransitions()) {
     result->SetPrototypeTransitions(array->GetPrototypeTransitions());
   }
 
   DCHECK_NE(kNotFound, insertion_index);
   for (int i = 0; i < insertion_index; ++i) {
-    result->NoIncrementalWriteBarrierCopyFrom(array, i, i);
+    result->CopyFrom(array, i, i);
   }
-  result->NoIncrementalWriteBarrierSet(insertion_index, *name, *target);
+  result->Set(insertion_index, *name, *cell);
   for (int i = insertion_index; i < number_of_transitions; ++i) {
-    result->NoIncrementalWriteBarrierCopyFrom(array, i, i + 1);
+    result->CopyFrom(array, i, i + 1);
   }
 
   SLOW_DCHECK(result->IsSortedNoDuplicates());
   ReplaceTransitions(map, *result);
 }
 
 
 // static
 Map* TransitionArray::SearchTransition(Map* map, PropertyKind kind, Name* name,
                                        PropertyAttributes attributes) {
@@ skipping 179 matching lines @@
                                                   int number_of_transitions,
                                                   int slack) {
   Handle<FixedArray> array = isolate->factory()->NewFixedArray(
       LengthFor(number_of_transitions + slack));
   array->set(kPrototypeTransitionsIndex, Smi::FromInt(0));
   array->set(kTransitionLengthIndex, Smi::FromInt(number_of_transitions));
   return Handle<TransitionArray>::cast(array);
 }
 
 
-void TransitionArray::NoIncrementalWriteBarrierCopyFrom(TransitionArray* origin,
-                                                        int origin_transition,
-                                                        int target_transition) {
-  NoIncrementalWriteBarrierSet(target_transition,
-                               origin->GetKey(origin_transition),
-                               origin->GetTarget(origin_transition));
+void TransitionArray::CopyFrom(TransitionArray* origin, int origin_transition,
+                               int target_transition) {
+  Set(target_transition, origin->GetKey(origin_transition),
+      origin->GetTargetCell(origin_transition));
 }
 
 
 static void ZapTransitionArray(TransitionArray* transitions) {
   MemsetPointer(transitions->data_start(),
                 transitions->GetHeap()->the_hole_value(),
                 transitions->length());
 }
 
 
@@ skipping 47 matching lines @@
   Handle<TransitionArray> result = Allocate(map->GetIsolate(), nof);
   DisallowHeapAllocation no_gc;
   // Reload pointer after the allocation that just happened.
   raw_transitions = map->raw_transitions();
   int new_nof = IsSimpleTransition(raw_transitions) ? 1 : 0;
   if (new_nof != nof) {
     DCHECK(new_nof == 0);
     result->Shrink(ToKeyIndex(0));
     result->SetNumberOfTransitions(0);
   } else if (nof == 1) {
-    Map* target = GetSimpleTransition(raw_transitions);
-    Name* key = GetSimpleTransitionKey(target);
-    result->NoIncrementalWriteBarrierSet(0, key, target);
+    WeakCell* target_cell = GetSimpleTransitionCell(raw_transitions);
+    Name* key = GetSimpleTransitionKey(Map::cast(target_cell->value()));
+    result->Set(0, key, target_cell);
   }
   ReplaceTransitions(map, *result);
 }
 
 
 void TransitionArray::TraverseTransitionTreeInternal(Map* map,
                                                      TraverseCallback callback,
                                                      void* data) {
   Object* raw_transitions = map->raw_transitions();
   if (IsFullTransitionArray(raw_transitions)) {
@@ skipping 75 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