Remember and reuse derived map for external arrays

src/objects.cc

 // Copyright 2010 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 1762 matching lines @@
     DescriptorLookupCache::Update(descriptors, name, number);
   }
   if (number != DescriptorArray::kNotFound) {
     result->DescriptorResult(holder, descriptors->GetDetails(number), number);
   } else {
     result->NotFound();
   }
 }
 
 
+MaybeObject* Map::GetExternalArrayElementsMap(ExternalArrayType array_type) {
+  DescriptorArray* descriptors = instance_descriptors();
+  String* external_array_sentinel_name = Heap::empty_string();

[Mads Ager (chromium), 2011/03/21 08:32:40]

The empty string is a valid property name (every string is using the bracket
notation: o[""] = 42). Therefore, we need deal with SetProperty for this type of
transition as well. If there is this type of transitions I guess we can just
drop this transition and replace it with a property instead. I guess that will
mean treating this transition the same a null descriptor in SetProperty. 

We should add a cctest for that case.

+
+  // Check if the external array transition already exists.
+  int index = DescriptorLookupCache::Lookup(descriptors,
+                                            external_array_sentinel_name);
+  if (index == DescriptorLookupCache::kAbsent) {
+    index = descriptors->Search(external_array_sentinel_name);
+    DescriptorLookupCache::Update(descriptors,
+                                  external_array_sentinel_name,
+                                  index);
+  }
+
+  // If the transition already exists, check the type. If thee is a match,

[Mads Ager (chromium), 2011/03/21 08:32:40]

thee -> there

+  // return it.
+  if (index != DescriptorArray::kNotFound) {
+    PropertyDetails details(PropertyDetails(descriptors->GetDetails(index)));
+    if (details.type() == EXTERNAL_ARRAY_TRANSITION &&
+        details.array_type() == array_type) {
+      return descriptors->GetValue(index);
+    }
+  }
+
+  // No transition to an existing external array map. Make a new one.
+  Object* obj;
+  { MaybeObject* maybe_map = CopyDropTransitions();
+    if (!maybe_map->ToObject(&obj)) return maybe_map;
+  }
+  Map* new_map = Map::cast(obj);
+
+  new_map->set_has_fast_elements(false);
+  new_map->set_has_external_array_elements(true);
+  Counters::map_to_external_array_elements.Increment();
+
+  // Only remember the map transition if the object's map is NOT equal to the
+  // global object_function's map and there is not an already existing
+  // non-matching external array transition.
+  bool allow_map_transition =
+      index == DescriptorArray::kNotFound &&
+      (Top::context()->global_context()->object_function()->map() != map());
+  if (allow_map_transition) {
+    // Allocate new instance descriptors for the old map with map transition.
+    ExternalArrayTransitionDescriptor desc(external_array_sentinel_name,
+                                           Map::cast(new_map),
+                                           array_type);
+    Object* new_descriptors;
+    MaybeObject* maybe_new_descriptors = descriptors->CopyInsert(
+        &desc,
+        KEEP_TRANSITIONS);
+    if (!maybe_new_descriptors->ToObject(&new_descriptors)) {
+      return maybe_new_descriptors;
+    }
+    descriptors = DescriptorArray::cast(new_descriptors);
+    set_instance_descriptors(descriptors);
+  }
+
+  return new_map;
+}
+
+
 void JSObject::LocalLookupRealNamedProperty(String* name,
                                             LookupResult* result) {
   if (IsJSGlobalProxy()) {
     Object* proto = GetPrototype();
     if (proto->IsNull()) return result->NotFound();
     ASSERT(proto->IsJSGlobalObject());
     return JSObject::cast(proto)->LocalLookupRealNamedProperty(name, result);
   }
 
   if (HasFastProperties()) {
@@ skipping 4478 matching lines @@
 
 
 const char* Code::PropertyType2String(PropertyType type) {
   switch (type) {
     case NORMAL: return "NORMAL";
     case FIELD: return "FIELD";
     case CONSTANT_FUNCTION: return "CONSTANT_FUNCTION";
     case CALLBACKS: return "CALLBACKS";
     case INTERCEPTOR: return "INTERCEPTOR";
     case MAP_TRANSITION: return "MAP_TRANSITION";
+    case EXTERNAL_ARRAY_TRANSITION: return "EXTERNAL_ARRAY_TRANSITION";
     case CONSTANT_TRANSITION: return "CONSTANT_TRANSITION";
     case NULL_DESCRIPTOR: return "NULL_DESCRIPTOR";
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 void Code::PrintExtraICState(FILE* out, Kind kind, ExtraICState extra) {
   const char* name = NULL;
@@ skipping 3751 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif
 
 
 } }  // namespace v8::internal