Move DescriptorArray into the map

src/objects.cc

 // 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 1746 matching lines @@
 
 MaybeObject* JSObject::ConvertTransitionToMapTransition(
     int transition_index,
     String* name,
     Object* new_value,
     PropertyAttributes attributes) {
   Map* old_map = map();
   Map* old_target = old_map->GetTransition(transition_index);
   Object* result;
 
-  // To sever a transition to a map with which the descriptors are shared, the
-  // larger map (more descriptors) needs to store its own descriptors array.
-  // Both sides of the severed chain need to have their own descriptors pointer
-  // to store distinct descriptor arrays.
-
-  // If the old_target did not yet store its own descriptors, the new
-  // descriptors pointer is created for the old_target by temporarily clearing
-  // the back pointer and setting its descriptor array.
-
-  // This phase is executed before creating the new map since it requires
-  // allocation that may fail.
-  if (!old_target->StoresOwnDescriptors()) {
-    DescriptorArray* old_descriptors = old_map->instance_descriptors();
-    MaybeObject* maybe_failure = old_target->SetDescriptors(old_descriptors);
-    if (maybe_failure->IsFailure()) return maybe_failure;
-  }
-
   MaybeObject* maybe_result =
       ConvertDescriptorToField(name, new_value, attributes);
   if (!maybe_result->To(&result)) return maybe_result;
 
   if (!HasFastProperties()) return result;
 
   // This method should only be used to convert existing transitions. Objects
   // with the map of "new Object()" cannot have transitions in the first place.
   Map* new_map = map();
   ASSERT(new_map != GetIsolate()->empty_object_map());
 
   // TODO(verwaest): From here on we lose existing map transitions, causing
   // invalid back pointers. This will change once we can store multiple
   // transitions with the same key.
 
   bool owned_descriptors = old_map->owns_descriptors();
   if (owned_descriptors ||
       old_target->instance_descriptors() == old_map->instance_descriptors()) {
     // Since the conversion above generated a new fast map with an additional
     // property which can be shared as well, install this descriptor pointer
-    // along the entire chain of smaller maps; and remove the transition array
-    // that is only in place to hold the descriptor array in the new map.
+    // along the entire chain of smaller maps.
     Map* map;
     DescriptorArray* new_descriptors = new_map->instance_descriptors();
     DescriptorArray* old_descriptors = old_map->instance_descriptors();
     for (Object* current = old_map;
          !current->IsUndefined();
          current = map->GetBackPointer()) {
       map = Map::cast(current);
-      if (!map->HasTransitionArray()) break;
-      TransitionArray* transitions = map->transitions();
-      if (transitions->descriptors() != old_descriptors) break;
+      if (map->instance_descriptors() != old_descriptors) break;
       map->SetEnumLength(Map::kInvalidEnumCache);
-      transitions->set_descriptors(new_descriptors);
+      map->set_instance_descriptors(new_descriptors);
     }
     old_map->set_owns_descriptors(false);
-    new_map->ClearTransitions(GetHeap());
   }
 
   old_map->SetTransition(transition_index, new_map);
   new_map->SetBackPointer(old_map);
   return result;
 }
 
 
 MaybeObject* JSObject::ConvertDescriptorToField(String* name,
                                                 Object* new_value,
@@ skipping 363 matching lines @@
   int number_of_descriptors = descriptors->number_of_descriptors();
   Isolate* isolate = map->GetIsolate();
   Handle<DescriptorArray> new_descriptors =
       isolate->factory()->NewDescriptorArray(number_of_descriptors, slack);
   DescriptorArray::WhitenessWitness witness(*new_descriptors);
 
   for (int i = 0; i < number_of_descriptors; ++i) {
     new_descriptors->CopyFrom(i, *descriptors, i, witness);
   }
 
-  Map::SetDescriptors(map, new_descriptors);
+  map->set_instance_descriptors(*new_descriptors);
 }
 
 
 void Map::AppendCallbackDescriptors(Handle<Map> map,
                                     Handle<Object> descriptors) {
   Isolate* isolate = map->GetIsolate();
   Handle<DescriptorArray> array(map->instance_descriptors());
   NeanderArray callbacks(descriptors);
   int nof_callbacks = callbacks.length();
 
@@ skipping 2007 matching lines @@
     ASSERT(!curr->HasNamedInterceptor());
     ASSERT(!curr->HasIndexedInterceptor());
     ASSERT(!curr->IsAccessCheckNeeded());
     if (curr->NumberOfEnumElements() > 0) return false;
     if (curr != this && enum_length != 0) return false;
   }
   return true;
 }
 
 
-void Map::SetDescriptors(Handle<Map> map,
-                         Handle<DescriptorArray> descriptors) {
-  Isolate* isolate = map->GetIsolate();
-  CALL_HEAP_FUNCTION_VOID(isolate, map->SetDescriptors(*descriptors));
-}
-
-
 int Map::NumberOfDescribedProperties(DescriptorFlag which,
                                      PropertyAttributes filter) {
   int result = 0;
   DescriptorArray* descs = instance_descriptors();
   int limit = which == ALL_DESCRIPTORS
       ? descs->number_of_descriptors()
       : NumberOfOwnDescriptors();
   for (int i = 0; i < limit; i++) {
     if ((descs->GetDetails(i).attributes() & filter) == 0) result++;
   }
@@ skipping 757 matching lines @@
 
     DescriptorArray::WhitenessWitness witness(new_descriptors);
 
     // Copy the descriptors, inserting a descriptor.
     for (int i = 0; i < old_size; ++i) {
       new_descriptors->CopyFrom(i, descriptors, i, witness);
     }
 
     new_descriptors->Append(descriptor, witness);
 
-    // If the source descriptors had an enum cache we copy it. This ensures that
-    // the maps to which we push the new descriptor array back can rely on a
-    // cache always being available once it is set. If the map has more
-    // enumerated descriptors than available in the original cache, the cache
-    // will be lazily replaced by the extended cache when needed.
-    if (descriptors->HasEnumCache()) {
-      new_descriptors->CopyEnumCacheFrom(descriptors);
+    if (old_size > 0) {
+      // If the source descriptors had an enum cache we copy it. This ensures
+      // that the maps to which we push the new descriptor array back can rely
+      // on a cache always being available once it is set. If the map has more
+      // enumerated descriptors than available in the original cache, the cache
+      // will be lazily replaced by the extended cache when needed.
+      if (descriptors->HasEnumCache()) {
+        new_descriptors->CopyEnumCacheFrom(descriptors);
+      }
+
+      Map* map;
+      // Replace descriptors by new_descriptors in all maps that share it.
+      for (Object* current = GetBackPointer();
+           !current->IsUndefined();
+           current = map->GetBackPointer()) {
+        map = Map::cast(current);
+        if (map->instance_descriptors() != descriptors) break;
+        map->set_instance_descriptors(new_descriptors);
+      }
+
+      set_instance_descriptors(new_descriptors);
     }
-
-    Map* map;
-    // Replace descriptors by new_descriptors in all maps that share it.
-    for (Object* current = GetBackPointer();
-         !current->IsUndefined();
-         current = map->GetBackPointer()) {
-      map = Map::cast(current);
-      if (!map->HasTransitionArray()) break;
-      TransitionArray* transitions = map->transitions();
-      if (transitions->descriptors() != descriptors) break;
-      transitions->set_descriptors(new_descriptors);
-    }
-
-    transitions->set_descriptors(new_descriptors);
   }
 
+  result->SetBackPointer(this);
+  result->InitializeDescriptors(new_descriptors);
+  ASSERT(result->NumberOfOwnDescriptors() == NumberOfOwnDescriptors() + 1);
+
   set_transitions(transitions);
-  result->SetBackPointer(this);
   set_owns_descriptors(false);
 
-  result->SetNumberOfOwnDescriptors(new_descriptors->number_of_descriptors());
-  ASSERT(result->NumberOfOwnDescriptors() == NumberOfOwnDescriptors() + 1);
-
   return result;
 }
 
 
 MaybeObject* Map::CopyReplaceDescriptors(DescriptorArray* descriptors,
                                          String* name,
                                          TransitionFlag flag,
                                          int descriptor_index) {
   ASSERT(descriptors->IsSortedNoDuplicates());
 
   Map* result;
   MaybeObject* maybe_result = CopyDropDescriptors();
   if (!maybe_result->To(&result)) return maybe_result;
 
-  // Unless we are creating a map with no descriptors and no back pointer, we
-  // insert the descriptor array locally.
-  if (!descriptors->IsEmpty()) {
-    MaybeObject* maybe_failure = result->SetDescriptors(descriptors);
-    if (maybe_failure->IsFailure()) return maybe_failure;
-    result->SetNumberOfOwnDescriptors(descriptors->number_of_descriptors());
-  }
+  result->InitializeDescriptors(descriptors);
 
   if (flag == INSERT_TRANSITION && CanHaveMoreTransitions()) {
     TransitionArray* transitions;
     SimpleTransitionFlag simple_flag =
         (descriptor_index == descriptors->number_of_descriptors() - 1)
          ? SIMPLE_TRANSITION
          : FULL_TRANSITION;
     MaybeObject* maybe_transitions = AddTransition(name, result, simple_flag);
     if (!maybe_transitions->To(&transitions)) return maybe_transitions;
 
-    if (descriptors->IsEmpty()) {
-      if (owns_descriptors()) {
-        // If the copied map has no added fields, and the parent map owns its
-        // descriptors, those descriptors have to be empty. In that case,
-        // transfer ownership of the descriptors to the new child.
-        ASSERT(instance_descriptors()->IsEmpty());
-        set_owns_descriptors(false);
-      } else {
-        // If the parent did not own its own descriptors, it may share a larger
-        // descriptors array already. In that case, force a split by setting
-        // the descriptor array of the new map to the empty descriptor array.
-        MaybeObject* maybe_failure =
-            result->SetDescriptors(GetHeap()->empty_descriptor_array());
-        if (maybe_failure->IsFailure()) return maybe_failure;
-      }
-    }
-
     set_transitions(transitions);
     result->SetBackPointer(this);
   }
 
   return result;
 }
 
 
 MaybeObject* Map::CopyAsElementsKind(ElementsKind kind, TransitionFlag flag) {
   if (flag == INSERT_TRANSITION) {
     ASSERT(!HasElementsTransition() ||
         ((elements_transition_map()->elements_kind() == DICTIONARY_ELEMENTS ||
           IsExternalArrayElementsKind(
               elements_transition_map()->elements_kind())) &&
          (kind == DICTIONARY_ELEMENTS ||
           IsExternalArrayElementsKind(kind))));
     ASSERT(!IsFastElementsKind(kind) ||
            IsMoreGeneralElementsKindTransition(elements_kind(), kind));
     ASSERT(kind != elements_kind());
   }
 
-  if (flag == INSERT_TRANSITION && owns_descriptors()) {
+  bool insert_transition =
+      flag == INSERT_TRANSITION && !HasElementsTransition();
+
+  if (insert_transition && owns_descriptors()) {
     // In case the map owned its own descriptors, share the descriptors and
     // transfer ownership to the new map.
     Map* new_map;
     MaybeObject* maybe_new_map = CopyDropDescriptors();
     if (!maybe_new_map->To(&new_map)) return maybe_new_map;
 
     MaybeObject* added_elements = set_elements_transition_map(new_map);
     if (added_elements->IsFailure()) return added_elements;
 
     new_map->set_elements_kind(kind);
+    new_map->InitializeDescriptors(instance_descriptors());
     new_map->SetBackPointer(this);
-    new_map->SetNumberOfOwnDescriptors(NumberOfOwnDescriptors());
     set_owns_descriptors(false);
     return new_map;
   }
 
   // In case the map did not own its own descriptors, a split is forced by
   // copying the map; creating a new descriptor array cell.
   // Create a new free-floating map only if we are not allowed to store it.
   Map* new_map;
   MaybeObject* maybe_new_map = Copy();
   if (!maybe_new_map->To(&new_map)) return maybe_new_map;
-  ASSERT(new_map->NumberOfOwnDescriptors() == NumberOfOwnDescriptors());
+
   new_map->set_elements_kind(kind);
 
-  if (flag == INSERT_TRANSITION && !HasElementsTransition()) {
-    // Map::Copy does not store the descriptor array in case it is empty, since
-    // it does not insert a back pointer; implicitly indicating that its
-    // descriptor array is empty. Since in this case we do want to insert a back
-    // pointer, we have to manually set the empty descriptor array to force a
-    // split.
-    if (!new_map->StoresOwnDescriptors()) {
-      ASSERT(new_map->NumberOfOwnDescriptors() == 0);
-      MaybeObject* maybe_failure =
-          new_map->SetDescriptors(GetHeap()->empty_descriptor_array());
-      if (maybe_failure->IsFailure()) return maybe_failure;
-    }
+  if (insert_transition) {
     MaybeObject* added_elements = set_elements_transition_map(new_map);
     if (added_elements->IsFailure()) return added_elements;
-
     new_map->SetBackPointer(this);
   }
 
   return new_map;
 }
 
 
 MaybeObject* Map::CopyWithPreallocatedFieldDescriptors() {
   if (pre_allocated_property_fields() == 0) return CopyDropDescriptors();
 
@@ skipping 2293 matching lines @@
   RightTrimFixedArray<FROM_GC>(heap, descriptors, to_trim);
   descriptors->SetNumberOfDescriptors(number_of_own_descriptors);
 
   if (descriptors->HasEnumCache()) TrimEnumCache(heap, map, descriptors);
   descriptors->Sort();
 }
 
 
 // Clear a possible back pointer in case the transition leads to a dead map.
 // Return true in case a back pointer has been cleared and false otherwise.
-static bool ClearBackPointer(Heap* heap,
-                             Map* target,
-                             DescriptorArray* descriptors,
-                             bool* descriptors_owner_died) {
+static bool ClearBackPointer(Heap* heap, Map* target) {
   if (Marking::MarkBitFrom(target).Get()) return false;
-  if (target->instance_descriptors() == descriptors) {
-    *descriptors_owner_died = true;
-  }
   target->SetBackPointer(heap->undefined_value(), SKIP_WRITE_BARRIER);
   return true;
 }
 
 
 // TODO(mstarzinger): This method should be moved into MarkCompactCollector,
 // because it cannot be called from outside the GC and we already have methods
 // depending on the transitions layout in the GC anyways.
 void Map::ClearNonLiveTransitions(Heap* heap) {
   // If there are no transitions to be cleared, return.
   // TODO(verwaest) Should be an assert, otherwise back pointers are not
   // properly cleared.
   if (!HasTransitionArray()) return;
 
   TransitionArray* t = transitions();
   MarkCompactCollector* collector = heap->mark_compact_collector();
 
   int transition_index = 0;
 
-  DescriptorArray* descriptors = t->descriptors();
+  DescriptorArray* descriptors = instance_descriptors();
   bool descriptors_owner_died = false;
 
   // Compact all live descriptors to the left.
   for (int i = 0; i < t->number_of_transitions(); ++i) {
     Map* target = t->GetTarget(i);
-    if (!ClearBackPointer(heap, target, descriptors, &descriptors_owner_died)) {
+    if (ClearBackPointer(heap, target)) {
+      if (target->instance_descriptors() == descriptors) {
+        descriptors_owner_died = true;
+        descriptors_owner_died = true;
+      }
+    } else {
       if (i != transition_index) {
         String* key = t->GetKey(i);
         t->SetKey(transition_index, key);
         Object** key_slot = t->GetKeySlot(transition_index);
         collector->RecordSlot(key_slot, key_slot, key);
         // Target slots do not need to be recorded since maps are not compacted.
         t->SetTarget(transition_index, t->GetTarget(i));
       }
       transition_index++;
     }
   }
 
   if (t->HasElementsTransition() &&
-      ClearBackPointer(heap,
-                       t->elements_transition(),
-                       descriptors,
-                       &descriptors_owner_died)) {
+      ClearBackPointer(heap, t->elements_transition())) {
+    if (t->elements_transition()->instance_descriptors() == descriptors) {
+      descriptors_owner_died = true;
+    }
     t->ClearElementsTransition();
   } else {
     // If there are no transitions to be cleared, return.
     // TODO(verwaest) Should be an assert, otherwise back pointers are not
     // properly cleared.
     if (transition_index == t->number_of_transitions()) return;
   }
 
   int number_of_own_descriptors = NumberOfOwnDescriptors();
 
   if (descriptors_owner_died) {
     if (number_of_own_descriptors > 0) {
       TrimDescriptorArray(heap, this, descriptors, number_of_own_descriptors);
       ASSERT(descriptors->number_of_descriptors() == number_of_own_descriptors);
     } else {
-      t->set_descriptors(heap->empty_descriptor_array());
+      ASSERT(descriptors == GetHeap()->empty_descriptor_array());
     }
   }
 
   int trim = t->number_of_transitions() - transition_index;
   if (trim > 0) {
     RightTrimFixedArray<FROM_GC>(heap, t, t->IsSimpleTransition()
         ? trim : trim * TransitionArray::kTransitionSize);
   }
 }
 
@@ skipping 5461 matching lines @@
         descriptors->Set(enumeration_index - 1, &d, witness);
       } else {
         UNREACHABLE();
       }
     }
   }
   ASSERT(current_offset == number_of_fields);
 
   descriptors->Sort();
 
-  MaybeObject* maybe_failure = new_map->InitializeDescriptors(descriptors);
-  if (maybe_failure->IsFailure()) return maybe_failure;
+  new_map->InitializeDescriptors(descriptors);
   new_map->set_unused_property_fields(unused_property_fields);
 
   // Transform the object.
   obj->set_map(new_map);
 
   obj->set_properties(fields);
   ASSERT(obj->IsJSObject());
 
   // Check that it really works.
   ASSERT(obj->HasFastProperties());
@@ skipping 499 matching lines @@
   set_year(Smi::FromInt(year), SKIP_WRITE_BARRIER);
   set_month(Smi::FromInt(month), SKIP_WRITE_BARRIER);
   set_day(Smi::FromInt(day), SKIP_WRITE_BARRIER);
   set_weekday(Smi::FromInt(weekday), SKIP_WRITE_BARRIER);
   set_hour(Smi::FromInt(hour), SKIP_WRITE_BARRIER);
   set_min(Smi::FromInt(min), SKIP_WRITE_BARRIER);
   set_sec(Smi::FromInt(sec), SKIP_WRITE_BARRIER);
 }
 
 } }  // namespace v8::internal