Revert "TransitionArray::Search() now returns insertion index if the entry was not found."

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 23 matching lines @@
 
 void TransitionArray::NoIncrementalWriteBarrierCopyFrom(TransitionArray* origin,
                                                         int origin_transition,
                                                         int target_transition) {
   NoIncrementalWriteBarrierSet(target_transition,
                                origin->GetKey(origin_transition),
                                origin->GetTarget(origin_transition));
 }
 
 
+static bool InsertionPointFound(Name* key1, Name* key2) {
+  return key1->Hash() > key2->Hash();
+}
+
+
 Handle<TransitionArray> TransitionArray::NewWith(Handle<Map> map,
                                                  Handle<Name> name,
                                                  Handle<Map> target,
                                                  SimpleTransitionFlag flag) {
   Handle<TransitionArray> result;
   Isolate* isolate = name->GetIsolate();
 
   if (flag == SIMPLE_TRANSITION) {
     result = AllocateSimple(isolate, target);
   } else {
@@ skipping 33 matching lines @@
                                                 Handle<Name> name,
                                                 Handle<Map> target,
                                                 SimpleTransitionFlag flag) {
   if (!map->HasTransitionArray()) {
     return TransitionArray::NewWith(map, name, target, flag);
   }
 
   int number_of_transitions = map->transitions()->number_of_transitions();
   int new_nof = number_of_transitions;
 
-  int insertion_index = kNotFound;
-  int index = map->transitions()->Search(*name, &insertion_index);
-
-  if (index == kNotFound) {
-    ++new_nof;
-  } else {
-    insertion_index = index;
-  }
-  DCHECK(insertion_index >= 0 && insertion_index <= number_of_transitions);
-
+  int insertion_index = map->transitions()->Search(*name);
+  if (insertion_index == kNotFound) ++new_nof;
   CHECK(new_nof <= kMaxNumberOfTransitions);
 
   if (new_nof <= map->transitions()->number_of_transitions_storage()) {
     DisallowHeapAllocation no_gc;
     TransitionArray* array = map->transitions();
 
-    if (index != kNotFound) {
-      array->SetTarget(index, *target);
+    if (insertion_index != kNotFound) {
+      array->SetTarget(insertion_index, *target);
       return handle(array);
     }
 
     array->SetNumberOfTransitions(new_nof);
-    for (index = number_of_transitions; index > insertion_index; --index) {
-      Name* key = array->GetKey(index - 1);
-      DCHECK(key->Hash() > name->Hash());
-      array->SetKey(index, key);
-      array->SetTarget(index, array->GetTarget(index - 1));
+    uint32_t hash = name->Hash();
+    for (insertion_index = number_of_transitions; insertion_index > 0;
+         --insertion_index) {
+      Name* key = array->GetKey(insertion_index - 1);
+      if (key->Hash() <= hash) break;
+      array->SetKey(insertion_index, key);
+      array->SetTarget(insertion_index, array->GetTarget(insertion_index - 1));
     }
-    array->SetKey(index, *name);
-    array->SetTarget(index, *target);
+    array->SetKey(insertion_index, *name);
+    array->SetTarget(insertion_index, *target);
     return handle(array);
   }
 
   Handle<TransitionArray> result = Allocate(
       map->GetIsolate(), new_nof,
       Map::SlackForArraySize(number_of_transitions, kMaxNumberOfTransitions));
 
   // The map's transition array may grown smaller during the allocation above as
   // it was weakly traversed, though it is guaranteed not to disappear. Trim the
   // result copy if needed, and recompute variables.
   DCHECK(map->HasTransitionArray());
   DisallowHeapAllocation no_gc;
   TransitionArray* array = map->transitions();
   if (array->number_of_transitions() != number_of_transitions) {
     DCHECK(array->number_of_transitions() < number_of_transitions);
 
     number_of_transitions = array->number_of_transitions();
     new_nof = number_of_transitions;
 
-    insertion_index = kNotFound;
-    index = array->Search(*name, &insertion_index);
-    if (index == kNotFound) {
-      ++new_nof;
-    } else {
-      insertion_index = index;
-    }
-    DCHECK(insertion_index >= 0 && insertion_index <= number_of_transitions);
+    insertion_index = array->Search(*name);
+    if (insertion_index == kNotFound) ++new_nof;
 
     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);
+  insertion_index = 0;
+  for (; insertion_index < number_of_transitions; ++insertion_index) {
+    if (InsertionPointFound(array->GetKey(insertion_index), *name)) break;
+    result->NoIncrementalWriteBarrierCopyFrom(
+        array, insertion_index, insertion_index);
   }
+
   result->NoIncrementalWriteBarrierSet(insertion_index, *name, *target);
-  for (int i = insertion_index; i < number_of_transitions; ++i) {
-    result->NoIncrementalWriteBarrierCopyFrom(array, i, i + 1);
+
+  for (; insertion_index < number_of_transitions; ++insertion_index) {
+    result->NoIncrementalWriteBarrierCopyFrom(
+        array, insertion_index, insertion_index + 1);
   }
 
   result->set_back_pointer_storage(array->back_pointer_storage());
   return result;
 }
 
 
 } }  // namespace v8::internal