Handle CALLBACKS transitions in NormalizeProperties, CopyInsert and RemoveTransitions.

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 3397 matching lines @@
         Object* value = FastPropertyAt(descs->GetFieldIndex(i));
         Object* result;
         { MaybeObject* maybe_result =
               dictionary->Add(descs->GetKey(i), value, d);
           if (!maybe_result->ToObject(&result)) return maybe_result;
         }
         dictionary = StringDictionary::cast(result);
         break;
       }
       case CALLBACKS: {
-        PropertyDetails d =
-            PropertyDetails(details.attributes(), CALLBACKS, details.index());
-        Object* value = descs->GetCallbacksObject(i);
+        if (!descs->IsProperty(i)) break;
+        Descriptor desc;
+        { MaybeObject* result =
+              descs->GetDescriptorWithoutTransitions(i, &desc);
+          if (result->IsFailure()) return result;
+        }
         Object* result;
         { MaybeObject* maybe_result =
-              dictionary->Add(descs->GetKey(i), value, d);
+              dictionary->Add(desc.GetKey(),
+                              desc.GetValue(),
+                              desc.GetDetails());
           if (!maybe_result->ToObject(&result)) return maybe_result;
         }
         dictionary = StringDictionary::cast(result);
         break;
       }
       case MAP_TRANSITION:
       case CONSTANT_TRANSITION:
       case NULL_DESCRIPTOR:
       case INTERCEPTOR:
       case ELEMENTS_TRANSITION:
@@ skipping 2289 matching lines @@
     FixedArray::cast(bridge_storage)->
       set(kEnumCacheBridgeCacheIndex, new_cache);
     NoWriteBarrierSet(FixedArray::cast(bridge_storage),
                       kEnumCacheBridgeEnumIndex,
                       get(kEnumerationIndexIndex));
     set(kEnumerationIndexIndex, bridge_storage);
   }
 }
 
 
+MaybeObject* DescriptorArray::GetDescriptorWithoutTransitions(
+    int descriptor_number,
+    Descriptor* descriptor) {
+  PropertyDetails details(GetDetails(descriptor_number));
+  Object* value = GetValue(descriptor_number);
+  if (details.type() == CALLBACKS && value->IsAccessorPair()) {
+    MaybeObject* maybe_copy =
+        AccessorPair::cast(value)->CopyWithoutTransitions();
+    if (!maybe_copy->To(&value)) return maybe_copy;
+  }
+  descriptor->Init(GetKey(descriptor_number), value, details);
+  return Smi::FromInt(0);
+}
+
+
 static bool InsertionPointFound(String* key1, String* key2) {
   return key1->Hash() > key2->Hash() || key1 == key2;
 }
 
 
 MaybeObject* DescriptorArray::CopyInsert(Descriptor* descriptor,
                                          TransitionFlag transition_flag) {
   // Transitions are only kept when inserting another transition.
   // This precondition is not required by this function's implementation, but
   // is currently required by the semantics of maps, so we check it.
@@ skipping 68 matching lines @@
   int insertion_index = -1;
   int from_index = 0;
   while (from_index < number_of_descriptors()) {
     if (insertion_index < 0 &&
         InsertionPointFound(GetKey(from_index), descriptor->GetKey())) {
       insertion_index = to_index++;
       if (replacing) from_index++;
     } else {
       if (!(IsNullDescriptor(from_index) ||
             (remove_transitions && IsTransitionOnly(from_index)))) {
-        new_descriptors->CopyFrom(to_index++, this, from_index, witness);
+        Descriptor desc;
+        { MaybeObject* result =
+              GetDescriptorWithoutTransitions(from_index, &desc);
+          if (result->IsFailure()) return result;
+        }
+        new_descriptors->Set(to_index++, &desc, witness);
       }
       from_index++;
     }
   }
   if (insertion_index < 0) insertion_index = to_index++;
   new_descriptors->Set(insertion_index, descriptor, witness);
 
   ASSERT(to_index == new_descriptors->number_of_descriptors());
   SLOW_ASSERT(new_descriptors->IsSortedNoDuplicates());
 
   return new_descriptors;
 }
 
 
 MaybeObject* DescriptorArray::RemoveTransitions() {
   // Remove all transitions and null descriptors. Return a copy of the array
   // with all transitions removed, or a Failure object if the new array could
   // not be allocated.
 
-  // Compute the size of the map transition entries to be removed.
+  // Allocate the new descriptor array.
   int new_number_of_descriptors = 0;
   for (int i = 0; i < number_of_descriptors(); i++) {
     if (IsProperty(i)) new_number_of_descriptors++;
   }
-
-  // Allocate the new descriptor array.
   DescriptorArray* new_descriptors;
   { MaybeObject* maybe_result = Allocate(new_number_of_descriptors);
-    if (!maybe_result->To<DescriptorArray>(&new_descriptors)) {
-      return maybe_result;
-    }
+    if (!maybe_result->To(&new_descriptors)) return maybe_result;
   }
 
+  // Copy the content.
   DescriptorArray::WhitenessWitness witness(new_descriptors);
-
-  // Copy the content.
   int next_descriptor = 0;
   for (int i = 0; i < number_of_descriptors(); i++) {
     if (IsProperty(i)) {
-      new_descriptors->CopyFrom(next_descriptor++, this, i, witness);
+      Descriptor desc;
+      { MaybeObject* result = GetDescriptorWithoutTransitions(i, &desc);
+        if (result->IsFailure()) return result;
+      }
+      new_descriptors->Set(next_descriptor++, &desc, witness);
     }
   }
   ASSERT(next_descriptor == new_descriptors->number_of_descriptors());
 
   return new_descriptors;
 }
 
 
 void DescriptorArray::SortUnchecked(const WhitenessWitness& witness) {
   // In-place heap sort.
@@ skipping 92 matching lines @@
     if ((entry->Hash() == hash) &&
         name->Equals(entry) &&
         !is_null_descriptor(number)) {
       return number;
     }
   }
   return kNotFound;
 }
 
 
+MaybeObject* AccessorPair::CopyWithoutTransitions() {
+  Heap* heap = GetHeap();
+  AccessorPair* copy;
+  { MaybeObject* maybe_copy = heap->AllocateAccessorPair();
+    if (!maybe_copy->To(&copy)) return maybe_copy;
+  }
+  copy->set_getter(getter()->IsMap() ? heap->the_hole_value() : getter());
+  copy->set_setter(setter()->IsMap() ? heap->the_hole_value() : setter());
+  return copy;
+}
+
+
 MaybeObject* DeoptimizationInputData::Allocate(int deopt_entry_count,
                                                PretenureFlag pretenure) {
   ASSERT(deopt_entry_count > 0);
   return HEAP->AllocateFixedArray(LengthFor(deopt_entry_count),
                                   pretenure);
 }
 
 
 MaybeObject* DeoptimizationOutputData::Allocate(int number_of_deopt_points,
                                                 PretenureFlag pretenure) {
@@ skipping 7047 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single break point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 
 } }  // namespace v8::internal