Swapped transition array and descriptor array.

src/objects-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 1868 matching lines @@
 }
 
 
 bool DescriptorArray::IsEmpty() {
   ASSERT(length() >= kFirstIndex ||
          this == HEAP->empty_descriptor_array());
   return length() < kFirstIndex;
 }
 
 
-bool DescriptorArray::MayContainTransitions() {
-  return !IsEmpty();
-}
-
-
-bool DescriptorArray::HasTransitionArray() {
-  return MayContainTransitions() && !get(kTransitionsIndex)->IsSmi();
-}
-
-
-Object* DescriptorArray::back_pointer_storage() {
-  return READ_FIELD(this, kBackPointerStorageOffset);
-}
-
-
-void DescriptorArray::set_back_pointer_storage(Object* value,
-                                               WriteBarrierMode mode) {
-  ASSERT(length() > kBackPointerStorageIndex);
-  Heap* heap = GetHeap();
-  WRITE_FIELD(this, kBackPointerStorageOffset, value);
-  CONDITIONAL_WRITE_BARRIER(heap, this, kBackPointerStorageOffset, value, mode);
-}
-
-
 void DescriptorArray::NoIncrementalWriteBarrierSwap(FixedArray* array,
                                                     int first,
                                                     int second) {
   Object* tmp = array->get(first);
   NoIncrementalWriteBarrierSet(array, first, array->get(second));
   NoIncrementalWriteBarrierSet(array, second, tmp);
 }
 
 
 // Perform a binary search in a fixed array. Low and high are entry indices. If
@@ skipping 69 matching lines @@
   DescriptorLookupCache* cache = GetIsolate()->descriptor_lookup_cache();
   int number = cache->Lookup(this, name);
   if (number == DescriptorLookupCache::kAbsent) {
     number = internal::Search(this, name);
     cache->Update(this, name, number);
   }
   return number;
 }
 
 
-TransitionArray* DescriptorArray::transitions() {
-  ASSERT(MayContainTransitions());
-  Object* array = get(kTransitionsIndex);
-  return TransitionArray::cast(array);
-}
-
-
-void DescriptorArray::ClearTransitions() {
-  WRITE_FIELD(this, kTransitionsOffset, Smi::FromInt(0));
-}
-
-
-void DescriptorArray::set_transitions(TransitionArray* transitions_array,
-                                      WriteBarrierMode mode) {
-  Heap* heap = GetHeap();
-  WRITE_FIELD(this, kTransitionsOffset, transitions_array);
-  CONDITIONAL_WRITE_BARRIER(
-      heap, this, kTransitionsOffset, transitions_array, mode);
-}
-
-
 Object** DescriptorArray::GetKeySlot(int descriptor_number) {
   ASSERT(descriptor_number < number_of_descriptors());
   return HeapObject::RawField(
       reinterpret_cast<HeapObject*>(this),
       OffsetOfElementAt(ToKeyIndex(descriptor_number)));
 }
 
 
 String* DescriptorArray::GetKey(int descriptor_number) {
   ASSERT(descriptor_number < number_of_descriptors());
@@ skipping 1418 matching lines @@
 
 
 void Map::set_prototype(Object* value, WriteBarrierMode mode) {
   ASSERT(value->IsNull() || value->IsJSReceiver());
   WRITE_FIELD(this, kPrototypeOffset, value);
   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kPrototypeOffset, value, mode);
 }
 
 
 DescriptorArray* Map::instance_descriptors() {
-  Object* object = READ_FIELD(this, kInstanceDescriptorsOrBackPointerOffset);
-  if (!object->IsDescriptorArray()) {
-    ASSERT(object->IsMap() || object->IsUndefined());
-    return GetHeap()->empty_descriptor_array();
-  } else {
-    return DescriptorArray::cast(object);
-  }
+  if (!HasTransitionArray()) return GetHeap()->empty_descriptor_array();
+  return transitions()->descriptors();
 }
 
 
-void Map::set_instance_descriptors(DescriptorArray* value,
-                                   WriteBarrierMode mode) {
-  Heap* heap = GetHeap();
+// If the descriptor is using the empty transition array, install a new empty
+// transition array that will have place for an element transition.
+static MaybeObject* EnsureHasTransitionArray(Map* map) {
+  if (map->HasTransitionArray()) return map;
 
-  if (value == heap->empty_descriptor_array()) {
-    ClearDescriptorArray(heap, mode);
-    return;
-  }
-
-  Object* object = READ_FIELD(this, kInstanceDescriptorsOrBackPointerOffset);
-
-  if (object->IsDescriptorArray()) {
-    value->set_back_pointer_storage(
-        DescriptorArray::cast(object)->back_pointer_storage());
-  } else {
-    ASSERT(object->IsMap() || object->IsUndefined());
-    value->set_back_pointer_storage(object);
-  }
-
-  ASSERT(!is_shared());
-  WRITE_FIELD(this, kInstanceDescriptorsOrBackPointerOffset, value);
-  CONDITIONAL_WRITE_BARRIER(
-      heap, this, kInstanceDescriptorsOrBackPointerOffset, value, mode);
+  TransitionArray* transitions;
+  MaybeObject* maybe_transitions = TransitionArray::Allocate(0);
+  if (!maybe_transitions->To(&transitions)) return maybe_transitions;
+  map->set_transitions(transitions);
+  return transitions;
 }
 
 
-void Map::InitializeDescriptors(DescriptorArray* descriptors) {
+MaybeObject* Map::SetDescriptors(DescriptorArray* value,
+                                 WriteBarrierMode mode) {
+  ASSERT(!is_shared());
+  MaybeObject* maybe_failure = EnsureHasTransitionArray(this);
+  if (maybe_failure->IsFailure()) return maybe_failure;
+
+  transitions()->set_descriptors(value, mode);
+  return this;
+}
+
+
+MaybeObject* Map::InitializeDescriptors(DescriptorArray* descriptors) {
   int len = descriptors->number_of_descriptors();
   ASSERT(len <= DescriptorArray::kMaxNumberOfDescriptors);
   SLOW_ASSERT(descriptors->IsSortedNoDuplicates());
 
 #ifdef DEBUG
   bool used_indices[DescriptorArray::kMaxNumberOfDescriptors];
   for (int i = 0; i < len; ++i) used_indices[i] = false;
 
   // Ensure that all enumeration indexes between 1 and length occur uniquely in
   // the descriptor array.
   for (int i = 0; i < len; ++i) {
     int enum_index = descriptors->GetDetails(i).index() -
                      PropertyDetails::kInitialIndex;
     ASSERT(0 <= enum_index && enum_index < len);
     ASSERT(!used_indices[enum_index]);
     used_indices[enum_index] = true;
   }
 #endif
 
-  set_instance_descriptors(descriptors);
+  MaybeObject* maybe_failure = SetDescriptors(descriptors);
+  if (maybe_failure->IsFailure()) return maybe_failure;
 
   for (int i = 0; i < len; ++i) {
     if (descriptors->GetDetails(i).index() == len) {
       SetLastAdded(i);
-      break;
+      return this;
     }
   }
 
-  ASSERT((len == 0 && LastAdded() == kNoneAdded) ||
-         len == descriptors->GetDetails(LastAdded()).index());
+  ASSERT(len == 0 && LastAdded() == kNoneAdded);
+  return this;
 }
 
 
 SMI_ACCESSORS(Map, bit_field3, kBitField3Offset)
 
 
-void Map::ClearDescriptorArray(Heap* heap, WriteBarrierMode mode) {
+void Map::ClearTransitions(Heap* heap, WriteBarrierMode mode) {
   Object* back_pointer = GetBackPointer();
 #ifdef DEBUG
-  Object* object = READ_FIELD(this, kInstanceDescriptorsOrBackPointerOffset);
-  if (object->IsDescriptorArray()) {
+  Object* object = READ_FIELD(this, kTransitionsOrBackPointerOffset);
+  if (object->IsTransitionArray()) {
     ZapTransitions();
   } else {
     ASSERT(object->IsMap() || object->IsUndefined());
   }
 #endif
-  WRITE_FIELD(this, kInstanceDescriptorsOrBackPointerOffset, back_pointer);
+  WRITE_FIELD(this, kTransitionsOrBackPointerOffset, back_pointer);
   CONDITIONAL_WRITE_BARRIER(
-      heap, this, kInstanceDescriptorsOrBackPointerOffset, back_pointer, mode);
+      heap, this, kTransitionsOrBackPointerOffset, back_pointer, mode);
 }
 
 
 void Map::AppendDescriptor(Descriptor* desc,
                            const DescriptorArray::WhitenessWitness& witness) {
   DescriptorArray* descriptors = instance_descriptors();
   int set_descriptors = NumberOfSetDescriptors();
   int new_last_added = descriptors->Append(desc, witness, set_descriptors);
   SetLastAdded(new_last_added);
 }
 
 
 Object* Map::GetBackPointer() {
-  Object* object = READ_FIELD(this, kInstanceDescriptorsOrBackPointerOffset);
+  Object* object = READ_FIELD(this, kTransitionsOrBackPointerOffset);
   if (object->IsDescriptorArray()) {
-    return DescriptorArray::cast(object)->back_pointer_storage();
+    return TransitionArray::cast(object)->back_pointer_storage();
   } else {
     ASSERT(object->IsMap() || object->IsUndefined());
     return object;
   }
 }
 
 
 bool Map::HasElementsTransition() {
   return HasTransitionArray() && transitions()->HasElementsTransition();
 }
 
 
 bool Map::HasTransitionArray() {
-  return instance_descriptors()->HasTransitionArray();
+  Object* object = READ_FIELD(this, kTransitionsOrBackPointerOffset);
+  return object->IsTransitionArray();
 }
 
 
 Map* Map::elements_transition_map() {
   return transitions()->elements_transition();
 }
 
 
 bool Map::CanHaveMoreTransitions() {
   if (!HasTransitionArray()) return true;
   return FixedArray::SizeFor(transitions()->length() +
                              TransitionArray::kTransitionSize)
       <= Page::kMaxNonCodeHeapObjectSize;
 }
 
 
 MaybeObject* Map::AddTransition(String* key, Map* target) {
   if (HasTransitionArray()) return transitions()->CopyInsert(key, target);
   return TransitionArray::NewWith(key, target);
 }
 
 
 void Map::SetTransition(int transition_index, Map* target) {
   transitions()->SetTarget(transition_index, target);
 }
 
 
-// If the map is using the empty descriptor array, install a new empty
-// descriptor array that will contain an elements transition.
-static MaybeObject* AllowTransitions(Map* map) {
-  if (map->instance_descriptors()->MayContainTransitions()) return map;
-  DescriptorArray* descriptors;
-  MaybeObject* maybe_descriptors =
-      DescriptorArray::Allocate(0, DescriptorArray::CANNOT_BE_SHARED);
-  if (!maybe_descriptors->To(&descriptors)) return maybe_descriptors;
-  map->set_instance_descriptors(descriptors);
-  return descriptors;
-}
-
-
-// If the descriptor is using the empty transition array, install a new empty
-// transition array that will have place for an element transition.
-static MaybeObject* EnsureHasTransitionArray(Map* map) {
-  if (map->HasTransitionArray()) return map;
-
-  AllowTransitions(map);
-
-  TransitionArray* transitions;
-  MaybeObject* maybe_transitions = TransitionArray::Allocate(0);
-  if (!maybe_transitions->To(&transitions)) return maybe_transitions;
-  MaybeObject* added_transitions = map->set_transitions(transitions);
-  if (added_transitions->IsFailure()) return added_transitions;
-  return transitions;
-}
-
-
 MaybeObject* Map::set_elements_transition_map(Map* transitioned_map) {
   MaybeObject* allow_elements = EnsureHasTransitionArray(this);
   if (allow_elements->IsFailure()) return allow_elements;
   transitions()->set_elements_transition(transitioned_map);
   return this;
 }
 
 
 FixedArray* Map::GetPrototypeTransitions() {
   if (!HasTransitionArray()) return GetHeap()->empty_fixed_array();
@@ skipping 17 matching lines @@
   return this;
 }
 
 
 bool Map::HasPrototypeTransitions() {
   return HasTransitionArray() && transitions()->HasPrototypeTransitions();
 }
 
 
 TransitionArray* Map::transitions() {
-  return instance_descriptors()->transitions();
+  ASSERT(HasTransitionArray());
+  Object* object = READ_FIELD(this, kTransitionsOrBackPointerOffset);
+  return TransitionArray::cast(object);
 }
 
 
-void Map::ClearTransitions(Heap* heap, WriteBarrierMode mode) {
-#ifdef DEBUG
-  ZapTransitions();
-#endif
-  DescriptorArray* descriptors = instance_descriptors();
-  if (descriptors->number_of_descriptors() == 0) {
-    ClearDescriptorArray(heap, mode);
-  } else {
-    descriptors->ClearTransitions();
-  }
-}
-
-
-MaybeObject* Map::set_transitions(TransitionArray* transitions_array) {
-  MaybeObject* allow_transitions = AllowTransitions(this);
-  if (allow_transitions->IsFailure()) return allow_transitions;
+void Map::set_transitions(TransitionArray* transition_array,
+                          WriteBarrierMode mode) {
+  transition_array->set_descriptors(instance_descriptors());
+  transition_array->set_back_pointer_storage(GetBackPointer());
 #ifdef DEBUG
   if (HasTransitionArray()) {
-    ASSERT(transitions() != transitions_array);
+    ASSERT(transitions() != transition_array);
     ZapTransitions();
   }
 #endif
-  instance_descriptors()->set_transitions(transitions_array);
-  return this;
+
+  WRITE_FIELD(this, kTransitionsOrBackPointerOffset, transition_array);
+  CONDITIONAL_WRITE_BARRIER(
+      GetHeap(), this, kTransitionsOrBackPointerOffset, transition_array, mode);
 }
 
 
 void Map::init_back_pointer(Object* undefined) {
   ASSERT(undefined->IsUndefined());
-  WRITE_FIELD(this, kInstanceDescriptorsOrBackPointerOffset, undefined);
+  WRITE_FIELD(this, kTransitionsOrBackPointerOffset, undefined);
 }
 
 
 void Map::SetBackPointer(Object* value, WriteBarrierMode mode) {
   ASSERT(instance_type() >= FIRST_JS_RECEIVER_TYPE);
   ASSERT((value->IsUndefined() && GetBackPointer()->IsMap()) ||
          (value->IsMap() && GetBackPointer()->IsUndefined()));
-  Object* object = READ_FIELD(this, kInstanceDescriptorsOrBackPointerOffset);
-  if (object->IsDescriptorArray()) {
-    DescriptorArray::cast(object)->set_back_pointer_storage(value);
+  Object* object = READ_FIELD(this, kTransitionsOrBackPointerOffset);
+  if (object->IsTransitionArray()) {
+    TransitionArray::cast(object)->set_back_pointer_storage(value);
   } else {
-    WRITE_FIELD(this, kInstanceDescriptorsOrBackPointerOffset, value);
+    WRITE_FIELD(this, kTransitionsOrBackPointerOffset, value);
     CONDITIONAL_WRITE_BARRIER(
-        GetHeap(), this, kInstanceDescriptorsOrBackPointerOffset, value, mode);
+        GetHeap(), this, kTransitionsOrBackPointerOffset, value, mode);
   }
 }
 
 
 // Can either be Smi (no transitions), normal transition array, or a transition
 // array with the header overwritten as a Smi (thus iterating).
 TransitionArray* Map::unchecked_transition_array() {
-  ASSERT(HasTransitionArray());
-  Object* object = *HeapObject::RawField(instance_descriptors(),
-                                         DescriptorArray::kTransitionsOffset);
-  ASSERT(!object->IsSmi());
+  Object* object = *HeapObject::RawField(this,
+                                         Map::kTransitionsOrBackPointerOffset);
   TransitionArray* transition_array = static_cast<TransitionArray*>(object);
   return transition_array;
 }
 
 
 HeapObject* Map::UncheckedPrototypeTransitions() {
   ASSERT(HasTransitionArray());
   ASSERT(unchecked_transition_array()->HasPrototypeTransitions());
   return unchecked_transition_array()->UncheckedPrototypeTransitions();
 }
@@ skipping 1651 matching lines @@
 #undef WRITE_UINT32_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_