In-object double fields unboxing (for 64-bit only).

src/objects.cc

 // Copyright 2013 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/accessors.h"
 #include "src/allocation-site-scopes.h"
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 2202 matching lines @@
   for (int i = 0; i < old_nof; i++) {
     PropertyDetails details = new_descriptors->GetDetails(i);
     if (details.type() != FIELD) continue;
     PropertyDetails old_details = old_descriptors->GetDetails(i);
     if (old_details.type() == CALLBACKS) {
       ASSERT(details.representation().IsTagged());
       continue;
     }
     ASSERT(old_details.type() == CONSTANT ||
            old_details.type() == FIELD);
-    Object* raw_value = old_details.type() == CONSTANT
-        ? old_descriptors->GetValue(i)
-        : object->RawFastPropertyAt(FieldIndex::ForDescriptor(*old_map, i));
-    Handle<Object> value(raw_value, isolate);
+    Handle<Object> value;
+    if (old_details.type() == CONSTANT) {
+      value = handle(old_descriptors->GetValue(i), isolate);
+    } else {
+      FieldIndex index = FieldIndex::ForDescriptor(*old_map, i);
+      // TODO(ishell): avoid boxing if copying to unboxed double.
+      value = RawFastBoxedPropertyAt(object, index);
+    }
     if (!old_details.representation().IsDouble() &&
         details.representation().IsDouble()) {
       if (old_details.representation().IsNone()) {
         value = handle(Smi::FromInt(0), isolate);
       }
       value = Object::NewStorageFor(isolate, value, details.representation());
     } else if (old_details.representation().IsDouble() &&
                !details.representation().IsDouble()) {
       value = Object::WrapForRead(isolate, value, old_details.representation());
     }
@@ skipping 18 matching lines @@
   }
 
   // From here on we cannot fail and we shouldn't GC anymore.
   DisallowHeapAllocation no_allocation;
 
   // Copy (real) inobject properties. If necessary, stop at number_of_fields to
   // avoid overwriting |one_pointer_filler_map|.
   int limit = Min(inobject, number_of_fields);
   for (int i = 0; i < limit; i++) {
     FieldIndex index = FieldIndex::ForPropertyIndex(*new_map, i);
-    object->FastPropertyAtPut(index, array->get(external + i));
+    object->FastPropertyAtPut(*new_map, index, array->get(external + i));
   }
 
   Heap* heap = isolate->heap();
 
   // If there are properties in the new backing store, trim it to the correct
   // size and install the backing store into the object.
   if (external > 0) {
     RightTrimFixedArray<Heap::FROM_MUTATOR>(heap, *array, inobject);
     object->set_properties(*array);
   }
@@ skipping 113 matching lines @@
   deprecate();
   dependent_code()->DeoptimizeDependentCodeGroup(
       GetIsolate(), DependentCode::kTransitionGroup);
   NotifyLeafMapLayoutChange();
 }
 
 
 // Invalidates a transition target at |key|, and installs |new_descriptors| over
 // the current instance_descriptors to ensure proper sharing of descriptor
 // arrays.
-void Map::DeprecateTarget(Name* key, DescriptorArray* new_descriptors) {
+void Map::DeprecateTarget(Handle<Name> key,
+                          Handle<DescriptorArray> new_descriptors) {
   if (HasTransitionArray()) {
     TransitionArray* transitions = this->transitions();
-    int transition = transitions->Search(key);
+    int transition = transitions->Search(*key);
     if (transition != TransitionArray::kNotFound) {
       transitions->GetTarget(transition)->DeprecateTransitionTree();
     }
   }
 
   // Don't overwrite the empty descriptor array.
   if (NumberOfOwnDescriptors() == 0) return;
 
+  Handle<LayoutDescriptor> new_layout_descriptor =
+      LayoutDescriptor::New(new_descriptors);
   DescriptorArray* to_replace = instance_descriptors();
   Map* current = this;
   GetHeap()->incremental_marking()->RecordWrites(to_replace);
   while (current->instance_descriptors() == to_replace) {
     current->SetEnumLength(kInvalidEnumCacheSentinel);
-    current->set_instance_descriptors(new_descriptors);
+    current->InitializeDescriptors(*new_descriptors, *new_layout_descriptor);
     Object* next = current->GetBackPointer();
     if (next->IsUndefined()) break;
     current = Map::cast(next);
   }
 
   set_owns_descriptors(false);
 }
 
 
 Map* Map::FindRootMap() {
@@ skipping 60 matching lines @@
 
 
 void Map::UpdateDescriptor(int descriptor_number, Descriptor* desc) {
   DisallowHeapAllocation no_allocation;
   if (HasTransitionArray()) {
     TransitionArray* transitions = this->transitions();
     for (int i = 0; i < transitions->number_of_transitions(); ++i) {
       transitions->GetTarget(i)->UpdateDescriptor(descriptor_number, desc);
     }
   }
-  instance_descriptors()->Replace(descriptor_number, desc);;
+  instance_descriptors()->Replace(descriptor_number, desc);
 }
 
 
 // static
 Handle<HeapType> Map::GeneralizeFieldType(Handle<HeapType> type1,
                                           Handle<HeapType> type2,
                                           Isolate* isolate) {
   static const int kMaxClassesPerFieldType = 5;
   if (type1->NowIs(type2)) return type2;
   if (type2->NowIs(type1)) return type1;
@@ skipping 229 matching lines @@
   ASSERT(new_descriptors->length() > target_descriptors->length() ||
          new_descriptors->NumberOfSlackDescriptors() > 0 ||
          new_descriptors->number_of_descriptors() ==
          old_descriptors->number_of_descriptors());
   ASSERT(new_descriptors->number_of_descriptors() == old_nof);
 
   // 0 -> |root_nof|
   int current_offset = 0;
   for (int i = 0; i < root_nof; ++i) {
     PropertyDetails old_details = old_descriptors->GetDetails(i);
-    if (old_details.type() == FIELD) current_offset++;
+    if (old_details.type() == FIELD) {
+      current_offset += old_details.field_width_in_words();
+    }
     Descriptor d(handle(old_descriptors->GetKey(i), isolate),
                  handle(old_descriptors->GetValue(i), isolate),
                  old_details);
     new_descriptors->Set(i, &d);
   }
 
   // |root_nof| -> |target_nof|
   for (int i = root_nof; i < target_nof; ++i) {
     Handle<Name> target_key(target_descriptors->GetKey(i), isolate);
     PropertyDetails old_details = old_descriptors->GetDetails(i);
@@ skipping 17 matching lines @@
       Handle<HeapType> target_field_type = (target_details.type() == FIELD)
           ? handle(target_descriptors->GetFieldType(i), isolate)
           : target_descriptors->GetValue(i)->OptimalType(
               isolate, target_details.representation());
       target_field_type = GeneralizeFieldType(
           target_field_type, old_field_type, isolate);
       if (modify_index == i) {
         target_field_type = GeneralizeFieldType(
             target_field_type, new_field_type, isolate);
       }
-      FieldDescriptor d(target_key,
-                        current_offset++,
-                        target_field_type,
+      FieldDescriptor d(target_key, current_offset, target_field_type,
                         target_details.attributes(),
                         target_details.representation());
+      current_offset += d.GetDetails().field_width_in_words();
       new_descriptors->Set(i, &d);
     } else {
       ASSERT_NE(FIELD, target_details.type());
       Descriptor d(target_key,
                    handle(target_descriptors->GetValue(i), isolate),
                    target_details);
       new_descriptors->Set(i, &d);
     }
   }
 
   // |target_nof| -> |old_nof|
   for (int i = target_nof; i < old_nof; ++i) {
     PropertyDetails old_details = old_descriptors->GetDetails(i);
     Handle<Name> old_key(old_descriptors->GetKey(i), isolate);
     if (modify_index == i) {
       old_details = old_details.CopyWithRepresentation(
           new_representation.generalize(old_details.representation()));
     }
     if (old_details.type() == FIELD) {
       Handle<HeapType> old_field_type(
           old_descriptors->GetFieldType(i), isolate);
       if (modify_index == i) {
         old_field_type = GeneralizeFieldType(
             old_field_type, new_field_type, isolate);
       }
-      FieldDescriptor d(old_key,
-                        current_offset++,
-                        old_field_type,
-                        old_details.attributes(),
-                        old_details.representation());
+      FieldDescriptor d(old_key, current_offset, old_field_type,
+                        old_details.attributes(), old_details.representation());
+      current_offset += d.GetDetails().field_width_in_words();
       new_descriptors->Set(i, &d);
     } else {
       ASSERT(old_details.type() == CONSTANT || old_details.type() == CALLBACKS);
       if (modify_index == i && store_mode == FORCE_FIELD) {
-        FieldDescriptor d(old_key,
-                          current_offset++,
-                          GeneralizeFieldType(
-                              old_descriptors->GetValue(i)->OptimalType(
-                                  isolate, old_details.representation()),
-                              new_field_type, isolate),
-                          old_details.attributes(),
-                          old_details.representation());
+        FieldDescriptor d(
+            old_key, current_offset,
+            GeneralizeFieldType(old_descriptors->GetValue(i)->OptimalType(
+                                    isolate, old_details.representation()),
+                                new_field_type, isolate),
+            old_details.attributes(), old_details.representation());
+        current_offset += d.GetDetails().field_width_in_words();
         new_descriptors->Set(i, &d);
       } else {
         ASSERT_NE(FIELD, old_details.type());
         Descriptor d(old_key,
                      handle(old_descriptors->GetValue(i), isolate),
                      old_details);
         new_descriptors->Set(i, &d);
       }
     }
   }
 
   new_descriptors->Sort();
 
   ASSERT(store_mode != FORCE_FIELD ||
          new_descriptors->GetDetails(modify_index).type() == FIELD);
 
   Handle<Map> split_map(root_map->FindLastMatchMap(
           root_nof, old_nof, *new_descriptors), isolate);
   int split_nof = split_map->NumberOfOwnDescriptors();
   ASSERT_NE(old_nof, split_nof);
 
   split_map->DeprecateTarget(
-      old_descriptors->GetKey(split_nof), *new_descriptors);
+      handle(old_descriptors->GetKey(split_nof), isolate), new_descriptors);
 
   if (FLAG_trace_generalization) {
     PropertyDetails old_details = old_descriptors->GetDetails(modify_index);
     PropertyDetails new_details = new_descriptors->GetDetails(modify_index);
     Handle<HeapType> old_field_type = (old_details.type() == FIELD)
         ? handle(old_descriptors->GetFieldType(modify_index), isolate)
         : HeapType::Constant(handle(old_descriptors->GetValue(modify_index),
                                     isolate), isolate);
     Handle<HeapType> new_field_type = (new_details.type() == FIELD)
         ? handle(new_descriptors->GetFieldType(modify_index), isolate)
@@ skipping 257 matching lines @@
   // Only supports adding slack to owned descriptors.
   ASSERT(map->owns_descriptors());
 
   Handle<DescriptorArray> descriptors(map->instance_descriptors());
   int old_size = map->NumberOfOwnDescriptors();
   if (slack <= descriptors->NumberOfSlackDescriptors()) return;
 
   Handle<DescriptorArray> new_descriptors = DescriptorArray::CopyUpTo(
       descriptors, old_size, slack);
 
+  Handle<LayoutDescriptor> new_layout_descriptor =
+      LayoutDescriptor::New(new_descriptors);
+
+  DisallowHeapAllocation no_allocation;
+
   if (old_size == 0) {
-    map->set_instance_descriptors(*new_descriptors);
+    map->InitializeDescriptors(*new_descriptors, *new_layout_descriptor);
     return;
   }
 
   // If the source descriptors had an enum cache we copy it. This ensures
   // that the maps to which we push the new descriptor array back can rely
   // on a cache always being available once it is set. If the map has more
   // enumerated descriptors than available in the original cache, the cache
   // will be lazily replaced by the extended cache when needed.
   if (descriptors->HasEnumCache()) {
     new_descriptors->CopyEnumCacheFrom(*descriptors);
   }
 
   // Replace descriptors by new_descriptors in all maps that share it.
   map->GetHeap()->incremental_marking()->RecordWrites(*descriptors);
 
   Map* walk_map;
   for (Object* current = map->GetBackPointer();
        !current->IsUndefined();
        current = walk_map->GetBackPointer()) {
     walk_map = Map::cast(current);
     if (walk_map->instance_descriptors() != *descriptors) break;
-    walk_map->set_instance_descriptors(*new_descriptors);
+    walk_map->InitializeDescriptors(*new_descriptors, *new_layout_descriptor);
   }
 
-  map->set_instance_descriptors(*new_descriptors);
+  map->InitializeDescriptors(*new_descriptors, *new_layout_descriptor);
 }
 
 
 template<class T>
 static int AppendUniqueCallbacks(NeanderArray* callbacks,
                                  Handle<typename T::Array> array,
                                  int valid_descriptors) {
   int nof_callbacks = callbacks->length();
 
   Isolate* isolate = array->GetIsolate();
@@ skipping 294 matching lines @@
 
   if (HasFastProperties()) {
     map()->LookupDescriptor(this, *name, result);
     // A property or a map transition was found. We return all of these result
     // types because LookupOwnRealNamedProperty is used when setting
     // properties where map transitions are handled.
     ASSERT(!result->IsFound() ||
            (result->holder() == this && result->IsFastPropertyType()));
     // Disallow caching for uninitialized constants. These can only
     // occur as fields.
-    if (result->IsField() &&
-        result->IsReadOnly() &&
-        RawFastPropertyAt(result->GetFieldIndex())->IsTheHole()) {
-      result->DisallowCaching();
+    if (result->IsField() && result->IsReadOnly()) {
+      FieldIndex index = result->GetFieldIndex();
+      if (!map()->IsUnboxedDoubleField(index) &&

[Toon Verwaest, 2014/07/29 15:02:09]

Unnecessary by now

[Igor Sheludko, 2014/10/30 14:23:44]

Done.

+          RawFastPropertyAt(index)->IsTheHole()) {
+        result->DisallowCaching();
+      }
     }
     return;
   }
 
   int entry = property_dictionary()->FindEntry(name);
   if (entry != NameDictionary::kNotFound) {
     Object* value = property_dictionary()->ValueAt(entry);
     if (IsGlobalObject()) {
       PropertyDetails d = property_dictionary()->DetailsAt(entry);
       if (d.IsDeleted()) {
@@ skipping 494 matching lines @@
 
   DescriptorArray* desc = map()->instance_descriptors();
   PropertyDetails details = desc->GetDetails(descriptor);
 
   ASSERT(details.type() == FIELD);
 
   FieldIndex index = FieldIndex::ForDescriptor(map(), descriptor);
   if (details.representation().IsDouble()) {
     // Nothing more to be done.
     if (value->IsUninitialized()) return;
-    HeapNumber* box = HeapNumber::cast(RawFastPropertyAt(index));
-    ASSERT(box->IsMutableHeapNumber());
-    box->set_value(value->Number());
+    if (map()->IsUnboxedDoubleField(index)) {
+      FastDoublePropertyAtPut(index, value->Number());
+    } else {
+      HeapNumber* box = HeapNumber::cast(RawFastPropertyAt(index));
+      ASSERT(box->IsMutableHeapNumber());
+      box->set_value(value->Number());
+    }
   } else {
     FastPropertyAtPut(index, value);
   }
 }
 
 
 void JSObject::SetPropertyToField(LookupResult* lookup, Handle<Object> value) {
   if (lookup->type() == CONSTANT || !lookup->CanHoldValue(value)) {
     Representation field_representation = value->OptimalRepresentation();
     Handle<HeapType> field_type = value->OptimalType(
@@ skipping 645 matching lines @@
         Handle<Name> key(descs->GetKey(i));
         Handle<Object> value(descs->GetConstant(i), isolate);
         PropertyDetails d = PropertyDetails(
             details.attributes(), NORMAL, i + 1);
         dictionary = NameDictionary::Add(dictionary, key, value, d);
         break;
       }
       case FIELD: {
         Handle<Name> key(descs->GetKey(i));
         FieldIndex index = FieldIndex::ForDescriptor(*map, i);
-        Handle<Object> value(
-            object->RawFastPropertyAt(index), isolate);
+        Handle<Object> value(JSObject::RawFastBoxedPropertyAt(object, index));
         if (details.representation().IsDouble()) {
           ASSERT(value->IsMutableHeapNumber());
           Handle<HeapNumber> old = Handle<HeapNumber>::cast(value);
           value = isolate->factory()->NewHeapNumber(old->value());
         }
         PropertyDetails d =
             PropertyDetails(details.attributes(), NORMAL, i + 1);
         dictionary = NameDictionary::Add(dictionary, key, value, d);
         break;
       }
@@ skipping 145 matching lines @@
         descriptors->Set(enumeration_index - 1, &d);
       } else if (type == NORMAL) {
         if (current_offset < inobject_props) {
           object->InObjectPropertyAtPut(current_offset,
                                         value,
                                         UPDATE_WRITE_BARRIER);
         } else {
           int offset = current_offset - inobject_props;
           fields->set(offset, value);
         }
-        FieldDescriptor d(key,
-                          current_offset++,
-                          details.attributes(),
+        FieldDescriptor d(key, current_offset, details.attributes(),
                           // TODO(verwaest): value->OptimalRepresentation();
                           Representation::Tagged());
+        current_offset += d.GetDetails().field_width_in_words();
         descriptors->Set(enumeration_index - 1, &d);
       } else if (type == CALLBACKS) {
         CallbacksDescriptor d(key,
                               handle(value, isolate),
                               details.attributes());
         descriptors->Set(enumeration_index - 1, &d);
       } else {
         UNREACHABLE();
       }
     }
   }
   ASSERT(current_offset == number_of_fields);
 
   descriptors->Sort();
 
+  Handle<LayoutDescriptor> layout_descriptor =
+      LayoutDescriptor::New(descriptors);
+
   DisallowHeapAllocation no_gc;
-  new_map->InitializeDescriptors(*descriptors);
+  new_map->InitializeOwnDescriptors(*descriptors, *layout_descriptor);
   new_map->set_unused_property_fields(unused_property_fields);
 
   // Transform the object.
   object->synchronized_set_map(*new_map);
 
   object->set_properties(*fields);
   ASSERT(object->IsJSObject());
 
   // Check that it really works.
   ASSERT(object->HasFastProperties());
@@ skipping 962 matching lines @@
     new_map->set_is_observed();
   }
   JSObject::MigrateToMap(object, new_map);
 }
 
 
 Handle<Object> JSObject::FastPropertyAt(Handle<JSObject> object,
                                         Representation representation,
                                         FieldIndex index) {
   Isolate* isolate = object->GetIsolate();
-  Handle<Object> raw_value(object->RawFastPropertyAt(index), isolate);
+  // TODO(ishell): unboxed double fields will be wrapped twice here.
+  Handle<Object> raw_value(JSObject::RawFastBoxedPropertyAt(object, index));
   return Object::WrapForRead(isolate, raw_value, representation);
 }
 
 
 template<class ContextObject>
 class JSObjectWalkVisitor {
  public:
   JSObjectWalkVisitor(ContextObject* site_context, bool copying,
                       JSObject::DeepCopyHints hints)
     : site_context_(site_context),
@@ skipping 69 matching lines @@
     HandleScope scope(isolate);
 
     // Deep copy own properties.
     if (copy->HasFastProperties()) {
       Handle<DescriptorArray> descriptors(copy->map()->instance_descriptors());
       int limit = copy->map()->NumberOfOwnDescriptors();
       for (int i = 0; i < limit; i++) {
         PropertyDetails details = descriptors->GetDetails(i);
         if (details.type() != FIELD) continue;
         FieldIndex index = FieldIndex::ForDescriptor(copy->map(), i);
-        Handle<Object> value(object->RawFastPropertyAt(index), isolate);
+        // TODO(ishell): avoid boxing if copying to unboxed double.
+        Handle<Object> value = JSObject::RawFastBoxedPropertyAt(object, index);
         if (value->IsJSObject()) {
           ASSIGN_RETURN_ON_EXCEPTION(
               isolate, value,
               VisitElementOrProperty(copy, Handle<JSObject>::cast(value)),
               JSObject);
         } else {
           Representation representation = details.representation();
           value = Object::NewStorageFor(isolate, value, representation);
         }
         if (copying) {
@@ skipping 222 matching lines @@
     if ((descs->GetDetails(i).attributes() & filter) == 0 &&
         !FilterKey(descs->GetKey(i), filter)) {
       result++;
     }
   }
   return result;
 }
 
 
 int Map::NextFreePropertyIndex() {
-  int max_index = -1;
+  int free_index = 0;
   int number_of_own_descriptors = NumberOfOwnDescriptors();
   DescriptorArray* descs = instance_descriptors();
   for (int i = 0; i < number_of_own_descriptors; i++) {
-    if (descs->GetType(i) == FIELD) {
-      int current_index = descs->GetFieldIndex(i);
-      if (current_index > max_index) max_index = current_index;
+    PropertyDetails details = descs->GetDetails(i);
+    if (details.type() == FIELD) {
+      int candidate = details.field_index() + details.field_width_in_words();
+      if (candidate > free_index) free_index = candidate;
     }
   }
-  return max_index + 1;
+  return free_index;
 }
 
 
 void JSReceiver::LookupOwn(
     Handle<Name> name, LookupResult* result, bool search_hidden_prototypes) {
   DisallowHeapAllocation no_gc;
   ASSERT(name->IsName());
 
   if (IsJSGlobalProxy()) {
     Object* proto = GetPrototype();
@@ skipping 818 matching lines @@
     }
   }
   return isolate->factory()->undefined_value();
 }
 
 
 Object* JSObject::SlowReverseLookup(Object* value) {
   if (HasFastProperties()) {
     int number_of_own_descriptors = map()->NumberOfOwnDescriptors();
     DescriptorArray* descs = map()->instance_descriptors();
+    bool value_is_number = value->IsNumber();
     for (int i = 0; i < number_of_own_descriptors; i++) {
       if (descs->GetType(i) == FIELD) {
-        Object* property =
-            RawFastPropertyAt(FieldIndex::ForDescriptor(map(), i));
-        if (descs->GetDetails(i).representation().IsDouble()) {
-          ASSERT(property->IsMutableHeapNumber());
-          if (value->IsNumber() && property->Number() == value->Number()) {
+        FieldIndex field_index = FieldIndex::ForDescriptor(map(), i);
+        if (map()->IsUnboxedDoubleField(field_index)) {
+          if (value_is_number) {
+            double property = RawFastDoublePropertyAt(field_index);
+            if (property == value->Number()) {
+              return descs->GetKey(i);
+            }
+          }
+        } else {
+          Object* property = RawFastPropertyAt(field_index);
+          if (field_index.is_double()) {
+            ASSERT(property->IsMutableHeapNumber());
+            if (value_is_number && property->Number() == value->Number()) {
+              return descs->GetKey(i);
+            }
+          } else if (property == value) {
             return descs->GetKey(i);
           }
-        } else if (property == value) {
-          return descs->GetKey(i);
         }
       } else if (descs->GetType(i) == CONSTANT) {
         if (descs->GetConstant(i) == value) {
           return descs->GetKey(i);
         }
       }
     }
     return GetHeap()->undefined_value();
   } else {
     return property_dictionary()->SlowReverseLookup(value);
@@ skipping 130 matching lines @@
   if (descriptors->NumberOfSlackDescriptors() == 0) {
     int old_size = descriptors->number_of_descriptors();
     if (old_size == 0) {
       descriptors = DescriptorArray::Allocate(map->GetIsolate(), 0, 1);
     } else {
       EnsureDescriptorSlack(map, old_size < 4 ? 1 : old_size / 2);
       descriptors = handle(map->instance_descriptors());
     }
   }
 
+  descriptors->Append(descriptor);
+  Handle<LayoutDescriptor> layout_descriptor =
+      LayoutDescriptor::New(descriptors);
+
   // Commit the state atomically.
   DisallowHeapAllocation no_gc;
 
-  descriptors->Append(descriptor);
   result->SetBackPointer(*map);
-  result->InitializeDescriptors(*descriptors);
+  result->InitializeOwnDescriptors(*descriptors, *layout_descriptor);
 
   ASSERT(result->NumberOfOwnDescriptors() == map->NumberOfOwnDescriptors() + 1);
 
   map->set_transitions(*transitions);
   map->set_owns_descriptors(false);
 
   return result;
 }
 
 
 Handle<Map> Map::CopyReplaceDescriptors(Handle<Map> map,
                                         Handle<DescriptorArray> descriptors,
                                         TransitionFlag flag,
                                         MaybeHandle<Name> maybe_name,
                                         SimpleTransitionFlag simple_flag) {
   ASSERT(descriptors->IsSortedNoDuplicates());
 
   Handle<Map> result = CopyDropDescriptors(map);
-  result->InitializeDescriptors(*descriptors);
 
   if (flag == INSERT_TRANSITION && map->CanHaveMoreTransitions()) {
+    Handle<LayoutDescriptor> layout_descriptor =
+        LayoutDescriptor::New(descriptors);
+    result->InitializeOwnDescriptors(*descriptors, *layout_descriptor);
+
     Handle<Name> name;
     CHECK(maybe_name.ToHandle(&name));
     Handle<TransitionArray> transitions = TransitionArray::CopyInsert(
         map, name, result, simple_flag);
     map->set_transitions(*transitions);
     result->SetBackPointer(*map);
   } else {
     int length = descriptors->number_of_descriptors();
     for (int i = 0; i < length; i++) {
       descriptors->SetRepresentation(i, Representation::Tagged());
       if (descriptors->GetDetails(i).type() == FIELD) {
         descriptors->SetValue(i, HeapType::Any());
       }
     }
+    result->InitializeOwnDescriptors(*descriptors,
+                                     LayoutDescriptor::FastPointerLayout());
   }
 
   return result;
 }
 
 
 // Since this method is used to rewrite an existing transition tree, it can
 // always insert transitions without checking.
 Handle<Map> Map::CopyInstallDescriptors(Handle<Map> map,
                                         int new_descriptor,
                                         Handle<DescriptorArray> descriptors) {
   ASSERT(descriptors->IsSortedNoDuplicates());
 
   Handle<Map> result = CopyDropDescriptors(map);
 
-  result->InitializeDescriptors(*descriptors);
+  result->set_instance_descriptors(*descriptors);
   result->SetNumberOfOwnDescriptors(new_descriptor + 1);
+  if (FLAG_unbox_double_fields) {
+    Handle<LayoutDescriptor> layout_descriptor =
+        LayoutDescriptor::New(descriptors);
+    result->set_layout_descriptor(layout_descriptor->OptimizeFor(*result));
+    result->set_visitor_id(StaticVisitorBase::GetVisitorId(*result));
+  }
 
   int unused_property_fields = map->unused_property_fields();
   if (descriptors->GetDetails(new_descriptor).type() == FIELD) {
     unused_property_fields = map->unused_property_fields() - 1;
     if (unused_property_fields < 0) {
       unused_property_fields += JSObject::kFieldsAdded;
     }
   }
 
   result->set_unused_property_fields(unused_property_fields);
@@ skipping 26 matching lines @@
   }
 
   bool insert_transition =
       flag == INSERT_TRANSITION && !map->HasElementsTransition();
 
   if (insert_transition && map->owns_descriptors()) {
     // In case the map owned its own descriptors, share the descriptors and
     // transfer ownership to the new map.
     Handle<Map> new_map = CopyDropDescriptors(map);
 
+    Handle<DescriptorArray> descriptors(map->instance_descriptors());
+    Handle<LayoutDescriptor> layout_descriptor =
+        LayoutDescriptor::New(descriptors);
+
     SetElementsTransitionMap(map, new_map);
 
     new_map->set_elements_kind(kind);
-    new_map->InitializeDescriptors(map->instance_descriptors());
+    new_map->InitializeOwnDescriptors(*descriptors, *layout_descriptor);
     new_map->SetBackPointer(*map);
     map->set_owns_descriptors(false);
     return new_map;
   }
 
   // In case the map did not own its own descriptors, a split is forced by
   // copying the map; creating a new descriptor array cell.
   // Create a new free-floating map only if we are not allowed to store it.
   Handle<Map> new_map = Copy(map);
 
@@ skipping 23 matching lines @@
   }
 
   Handle<TransitionArray> transitions = TransitionArray::CopyInsert(
       map, isolate->factory()->observed_symbol(), new_map, FULL_TRANSITION);
 
   map->set_transitions(*transitions);
 
   new_map->set_is_observed();
 
   if (map->owns_descriptors()) {
-    new_map->InitializeDescriptors(map->instance_descriptors());

[Toon Verwaest, 2014/07/29 15:02:09]

This is overkill, set_instance_descriptors should be good enough. The length
didn't change.

Use UpdateDescriptors(DescriptorArray*, LayoutDescriptor*) instead.

[Igor Sheludko, 2014/10/30 14:23:44]

Done.

+    Handle<DescriptorArray> descriptors(map->instance_descriptors());
+    Handle<LayoutDescriptor> layout_descriptor =
+        LayoutDescriptor::New(descriptors);
+    new_map->InitializeOwnDescriptors(*descriptors, *layout_descriptor);
     map->set_owns_descriptors(false);
   }
 
   new_map->SetBackPointer(*map);
   return new_map;
 }
 
 
 Handle<Map> Map::Copy(Handle<Map> map) {
   Handle<DescriptorArray> descriptors(map->instance_descriptors());
@@ skipping 932 matching lines @@
                                                   int slack) {
   ASSERT(0 <= number_of_descriptors);
   Factory* factory = isolate->factory();
   // Do not use DescriptorArray::cast on incomplete object.
   int size = number_of_descriptors + slack;
   if (size == 0) return factory->empty_descriptor_array();
   // Allocate the array of keys.
   Handle<FixedArray> result = factory->NewFixedArray(LengthFor(size));
 
   result->set(kDescriptorLengthIndex, Smi::FromInt(number_of_descriptors));
+  if (FLAG_unbox_double_fields) {
+    result->set(kLayoutDescriptorCacheIndex, *factory->undefined_value());
+  }
   result->set(kEnumCacheIndex, Smi::FromInt(0));
   return Handle<DescriptorArray>::cast(result);
 }
 
 
 void DescriptorArray::ClearEnumCache() {
   set(kEnumCacheIndex, Smi::FromInt(0));
 }
 
 
@@ skipping 11 matching lines @@
   ASSERT(!IsEmpty());
   ASSERT(!HasEnumCache() || new_cache->length() > GetEnumCache()->length());
   FixedArray::cast(bridge_storage)->
     set(kEnumCacheBridgeCacheIndex, new_cache);
   FixedArray::cast(bridge_storage)->
     set(kEnumCacheBridgeIndicesCacheIndex, new_index_cache);
   set(kEnumCacheIndex, bridge_storage);
 }
 
 
-void DescriptorArray::CopyFrom(int index,
-                               DescriptorArray* src,
+void DescriptorArray::CopyFrom(int index, DescriptorArray* src,
                                const WhitenessWitness& witness) {
   Object* value = src->GetValue(index);
   PropertyDetails details = src->GetDetails(index);
   Descriptor desc(handle(src->GetKey(index)),
                   handle(value, src->GetIsolate()),
                   details);
   Set(index, &desc, witness);
 }
 
 
@@ skipping 49 matching lines @@
       }
       if (child_hash <= parent_hash) break;
       SwapSortedKeys(parent_index, child_index);
       parent_index = child_index;
     }
   }
   ASSERT(IsSortedNoDuplicates());
 }
 
 
+Handle<LayoutDescriptor> LayoutDescriptor::New(
+    Handle<DescriptorArray> descriptors) {
+  Isolate* isolate = descriptors->GetIsolate();
+  if (!FLAG_unbox_double_fields) return handle(FastPointerLayout(), isolate);
+
+  // Check cached layout descriptor in descriptors array.
+  Object* cached = descriptors->cached_layout_descriptor();
+  if (cached != isolate->heap()->undefined_value()) {
+    LayoutDescriptor* layout_descriptor = LayoutDescriptor::cast(cached);
+    return handle(layout_descriptor, isolate);
+  }
+
+  int num_descriptors = descriptors->number_of_descriptors();
+
+  int layout_descriptor_length;
+
+  const int kMaxWordsPerField = kDoubleSize / kPointerSize;
+
+  if (num_descriptors <= kSmiValueSize / kMaxWordsPerField) {
+    // Even in the "worst" case (all fields are doubles) it would fit into
+    // a Smi, so no need to calculate length.
+    layout_descriptor_length = kSmiValueSize;
+
+  } else {
+    layout_descriptor_length = 0;
+
+    for (int i = 0; i < num_descriptors; i++) {
+      PropertyDetails details = descriptors->GetDetails(i);
+      if (details.type() == FIELD) {
+        if (layout_descriptor_length <= details.field_index()) {
+          layout_descriptor_length =
+              details.field_index() + details.field_width_in_words();
+        }
+      }
+    }
+  }
+
+  Handle<LayoutDescriptor> layout_descriptor_handle =
+      LayoutDescriptor::New(isolate, layout_descriptor_length);
+
+  DisallowHeapAllocation no_allocation;
+  LayoutDescriptor* layout_descriptor = *layout_descriptor_handle;
+
+  for (int i = 0; i < num_descriptors; i++) {
+    PropertyDetails details = descriptors->GetDetails(i);
+    if (details.type() == FIELD) {
+      int field_index = details.field_index();
+      bool tagged = !details.representation().IsDouble();
+      layout_descriptor = layout_descriptor->SetTagged(field_index, tagged);
+      if (details.field_width_in_words() > 1) {
+        layout_descriptor =
+            layout_descriptor->SetTagged(field_index + 1, tagged);
+      }
+    }
+  }
+  descriptors->set_cached_layout_descriptor(layout_descriptor);
+  return handle(layout_descriptor, isolate);
+}
+
+
 Handle<AccessorPair> AccessorPair::Copy(Handle<AccessorPair> pair) {
   Handle<AccessorPair> copy = pair->GetIsolate()->factory()->NewAccessorPair();
   copy->set_getter(pair->getter());
   copy->set_setter(pair->setter());
   return copy;
 }
 
 
 Object* AccessorPair::GetComponent(AccessorComponent component) {
   Object* accessor = get(component);
@@ skipping 8602 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal