TransitionArray now uses <is_data_property, name, attributes> tuple as a key, which allows to have …

src/transitions-inl.h

 // 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.
 
 #ifndef V8_TRANSITIONS_INL_H_
 #define V8_TRANSITIONS_INL_H_
 
 #include "src/transitions.h"
 
 namespace v8 {
@@ skipping 16 matching lines @@
   }
 
 
 TransitionArray* TransitionArray::cast(Object* object) {
   DCHECK(object->IsTransitionArray());
   return reinterpret_cast<TransitionArray*>(object);
 }
 
 
 bool TransitionArray::HasElementsTransition() {
-  return Search(GetHeap()->elements_transition_symbol()) != kNotFound;
+  return SearchSpecial(GetHeap()->elements_transition_symbol()) != kNotFound;
 }
 
 
 Object* TransitionArray::back_pointer_storage() {
   return get(kBackPointerStorageIndex);
 }
 
 
 void TransitionArray::set_back_pointer_storage(Object* back_pointer,
                                                WriteBarrierMode mode) {
@@ skipping 85 matching lines @@
   return map->GetLastDescriptorDetails();
 }
 
 
 Object* TransitionArray::GetTargetValue(int transition_number) {
   Map* map = GetTarget(transition_number);
   return map->instance_descriptors()->GetValue(map->LastAdded());
 }
 
 
-int TransitionArray::Search(Name* name) {
+int TransitionArray::SearchFirst(Name* name) {
   if (IsSimpleTransition()) {
     Name* key = GetKey(kSimpleTransitionIndex);
     if (key->Equals(name)) return kSimpleTransitionIndex;
     return kNotFound;
   }
   return internal::Search<ALL_ENTRIES>(this, name);
 }
 
 
+bool TransitionArray::IsSpecialTransition(Name* name) {

[Toon Verwaest, 2014/10/24 06:43:34]

Please get rid of this method; instead make it dependent on how the search is
called.

Even for "IsSorted.." you shouldn't need it. There should never be multiple
entries for SpecialTransition names, so we shouldn't ensure that the details are
different.

[Igor Sheludko, 2014/11/04 10:05:01]

Done. Now I'm using SimpleTransitionFlag as a to detect the kind of transition
and this method is left here only for checking purposes (DEBUG mode only).

+  if (!name->IsSymbol()) return false;
+  Heap* heap = name->GetHeap();
+  return name == heap->frozen_symbol() ||
+         name == heap->elements_transition_symbol() ||
+         name == heap->observed_symbol();
+}
+
+
+PropertyDetails TransitionArray::GetTargetDetails(Name* name, Map* target) {
+  DCHECK(!IsSpecialTransition(name));
+  int descriptor = target->LastAdded();
+  DescriptorArray* descriptors = target->instance_descriptors();
+  if (!descriptors->GetKey(descriptor)->Equals(name)) {
+    descriptor = descriptors->SearchWithCache(name, target);
+    DCHECK_NE(kNotFound, descriptor);
+  }
+  return descriptors->GetDetails(descriptor);
+}
+
+
 void TransitionArray::NoIncrementalWriteBarrierSet(int transition_number,
                                                    Name* key,
                                                    Map* target) {
   FixedArray::NoIncrementalWriteBarrierSet(
       this, ToKeyIndex(transition_number), key);
   FixedArray::NoIncrementalWriteBarrierSet(
       this, ToTargetIndex(transition_number), target);
 }
 
 
 #undef FIELD_ADDR
 #undef WRITE_FIELD
 #undef CONDITIONAL_WRITE_BARRIER
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TRANSITIONS_INL_H_