Initial steps for moving code onto Map

src/objects.cc

 // Copyright 2013 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 1807 matching lines @@
 static Handle<Object> NewStorageFor(Isolate* isolate,
                                     Handle<Object> object,
                                     Representation representation) {
   Heap* heap = isolate->heap();
   CALL_HEAP_FUNCTION(isolate,
                      object->AllocateNewStorageFor(heap, representation),
                      Object);
 }
 
 
-static Handle<Map> CopyAddFieldDescriptor(Handle<Map> map,
-                                          Handle<Name> name,
-                                          int index,
-                                          PropertyAttributes attributes,
-                                          Representation representation,
-                                          TransitionFlag flag) {
-  FieldDescriptor new_field_desc(name, index, attributes, representation);
-  Handle<Map> new_map = Map::CopyAddDescriptor(map, &new_field_desc, flag);
-  int unused_property_fields = map->unused_property_fields() - 1;
-  if (unused_property_fields < 0) {
-    unused_property_fields += JSObject::kFieldsAdded;
-  }
-  new_map->set_unused_property_fields(unused_property_fields);
-  return new_map;
-}
-
-
 void JSObject::AddFastProperty(Handle<JSObject> object,
                                Handle<Name> name,
                                Handle<Object> value,
                                PropertyAttributes attributes,
                                StoreFromKeyed store_mode,
                                ValueType value_type,
                                TransitionFlag flag) {
   ASSERT(!object->IsJSGlobalProxy());
   ASSERT(DescriptorArray::kNotFound ==
          object->map()->instance_descriptors()->Search(
              *name, object->map()->NumberOfOwnDescriptors()));
 
   // Normalize the object if the name is an actual name (not the
   // hidden strings) and is not a real identifier.
   // Normalize the object if it will have too many fast properties.
   Isolate* isolate = object->GetIsolate();
   if (!name->IsCacheable(isolate) ||
       object->TooManyFastProperties(store_mode)) {
     NormalizeProperties(object, CLEAR_INOBJECT_PROPERTIES, 0);
     AddSlowProperty(object, name, value, attributes);
     return;
   }
 
+  // Allocate new instance descriptors with (name, index) added
+  if (object->IsJSContextExtensionObject()) value_type = FORCE_TAGGED;
+  Representation representation = value->OptimalRepresentation(value_type);
+
   // Compute the new index for new field.
   int index = object->map()->NextFreePropertyIndex();
 
-  // Allocate new instance descriptors with (name, index) added
-  if (object->IsJSContextExtensionObject()) value_type = FORCE_TAGGED;
-  Representation representation = value->OptimalRepresentation(value_type);
-  Handle<Map> new_map = CopyAddFieldDescriptor(
-      handle(object->map()), name, index, attributes, representation, flag);
+  FieldDescriptor new_field_desc(name, index, attributes, representation);
+  Handle<Map> new_map = Map::CopyAddDescriptor(
+      handle(object->map()), &new_field_desc, flag);
+  int unused_property_fields = new_map->unused_property_fields() - 1;
+  if (unused_property_fields < 0) {
+    unused_property_fields += JSObject::kFieldsAdded;
+  }
+  new_map->set_unused_property_fields(unused_property_fields);
 
   JSObject::MigrateToMap(object, new_map);
 
   if (representation.IsDouble()) {
     // Nothing more to be done.
     if (value->IsUninitialized()) return;
     HeapNumber* box = HeapNumber::cast(object->RawFastPropertyAt(index));
     box->set_value(value->Number());
   } else {
     object->FastPropertyAtPut(index, *value);
   }
 }
 
 
-static Handle<Map> CopyAddConstantDescriptor(Handle<Map> map,
-                                             Handle<Name> name,
-                                             Handle<Object> value,
-                                             PropertyAttributes attributes,
-                                             TransitionFlag flag) {
-  ConstantDescriptor new_constant_desc(name, value, attributes);
-  return Map::CopyAddDescriptor(map, &new_constant_desc, flag);
-}
-
-
 void JSObject::AddConstantProperty(Handle<JSObject> object,
                                    Handle<Name> name,
                                    Handle<Object> constant,
                                    PropertyAttributes attributes,
                                    TransitionFlag initial_flag) {
-  TransitionFlag flag =
-      // Do not add transitions to global objects.
-      (object->IsGlobalObject() ||
-      // Don't add transitions to special properties with non-trivial
-      // attributes.
-       attributes != NONE)
-      ? OMIT_TRANSITION
-      : initial_flag;
+  ASSERT(!object->IsGlobalObject());
+  // Don't add transitions to special properties with non-trivial attributes.
+  TransitionFlag flag = attributes != NONE ? OMIT_TRANSITION : initial_flag;
 
   // Allocate new instance descriptors with (name, constant) added.
-  Handle<Map> new_map = CopyAddConstantDescriptor(
-      handle(object->map()), name, constant, attributes, flag);
+  ConstantDescriptor new_constant_desc(name, constant, attributes);
+  Handle<Map> new_map = Map::CopyAddDescriptor(
+      handle(object->map()), &new_constant_desc, flag);
 
   JSObject::MigrateToMap(object, new_map);
 }
 
 
 void JSObject::AddSlowProperty(Handle<JSObject> object,
                                Handle<Name> name,
                                Handle<Object> value,
                                PropertyAttributes attributes) {
   ASSERT(!object->HasFastProperties());
@@ skipping 2476 matching lines @@
     return JSProxy::GetElementAttributeWithHandler(
         Handle<JSProxy>::cast(proto), receiver, index);
   }
   if (proto->IsNull()) return ABSENT;
   return GetElementAttributeWithReceiver(
       Handle<JSObject>::cast(proto), receiver, index, true);
 }
 
 
 Handle<Map> NormalizedMapCache::Get(Handle<NormalizedMapCache> cache,
-                                    Handle<JSObject> obj,
+                                    Handle<Map> fast_map,
                                     PropertyNormalizationMode mode) {
-  int index = obj->map()->Hash() % kEntries;
+  int index = fast_map->Hash() % kEntries;
   Handle<Object> result = handle(cache->get(index), cache->GetIsolate());
   if (result->IsMap() &&
-      Handle<Map>::cast(result)->EquivalentToForNormalization(obj->map(),
-                                                              mode)) {
+      Handle<Map>::cast(result)->EquivalentToForNormalization(
+          *fast_map, mode)) {
 #ifdef VERIFY_HEAP
     if (FLAG_verify_heap) {
       Handle<Map>::cast(result)->SharedMapVerify();
     }
 #endif
 #ifdef ENABLE_SLOW_ASSERTS
     if (FLAG_enable_slow_asserts) {
       // The cached map should match newly created normalized map bit-by-bit,
       // except for the code cache, which can contain some ics which can be
       // applied to the shared map.
-      Handle<Map> fresh = Map::CopyNormalized(handle(obj->map()), mode,
-                                              SHARED_NORMALIZED_MAP);
+      Handle<Map> fresh = Map::CopyNormalized(
+          fast_map, mode, SHARED_NORMALIZED_MAP);
 
       ASSERT(memcmp(fresh->address(),
                     Handle<Map>::cast(result)->address(),
                     Map::kCodeCacheOffset) == 0);
       STATIC_ASSERT(Map::kDependentCodeOffset ==
                     Map::kCodeCacheOffset + kPointerSize);
       int offset = Map::kDependentCodeOffset + kPointerSize;
       ASSERT(memcmp(fresh->address() + offset,
                     Handle<Map>::cast(result)->address() + offset,
                     Map::kSize - offset) == 0);
     }
 #endif
     return Handle<Map>::cast(result);
   }
 
   Isolate* isolate = cache->GetIsolate();

[Igor Sheludko, 2014/04/14 16:17:53]

While we are here: lets get isolate only once in this method.

-  Handle<Map> map = Map::CopyNormalized(handle(obj->map()), mode,
-                                        SHARED_NORMALIZED_MAP);
+  Handle<Map> map = Map::CopyNormalized(fast_map, mode, SHARED_NORMALIZED_MAP);
   ASSERT(map->is_dictionary_map());
   cache->set(index, *map);
   isolate->counters()->normalized_maps()->Increment();
 
   return map;
 }
 
 
 void NormalizedMapCache::Clear() {
   int entries = length();
@@ skipping 16 matching lines @@
                                    int expected_additional_properties) {
   if (!object->HasFastProperties()) return;
 
   // The global object is always normalized.
   ASSERT(!object->IsGlobalObject());
   // JSGlobalProxy must never be normalized
   ASSERT(!object->IsJSGlobalProxy());
 
   Isolate* isolate = object->GetIsolate();
   HandleScope scope(isolate);
   Handle<Map> map(object->map());

[Igor Sheludko, 2014/04/14 16:17:53]

While we are here: map(..., isolate)

 
   // Allocate new content.
   int real_size = map->NumberOfOwnDescriptors();
   int property_count = real_size;
   if (expected_additional_properties > 0) {
     property_count += expected_additional_properties;
   } else {
     property_count += 2;  // Make space for two more properties.
   }
   Handle<NameDictionary> dictionary =
       isolate->factory()->NewNameDictionary(property_count);
 
   Handle<DescriptorArray> descs(map->instance_descriptors());

[Igor Sheludko, 2014/04/14 16:17:53]

, isolate)

[Igor Sheludko, 2014/04/14 16:17:53]

, isolate)

   for (int i = 0; i < real_size; i++) {
     PropertyDetails details = descs->GetDetails(i);
     switch (details.type()) {
       case CONSTANT: {
         Handle<Name> key(descs->GetKey(i));

[Igor Sheludko, 2014/04/14 16:17:53]

, isolate)

         Handle<Object> value(descs->GetConstant(i), isolate);
         PropertyDetails d = PropertyDetails(
             details.attributes(), NORMAL, i + 1);
         dictionary = NameDictionaryAdd(dictionary, key, value, d);
         break;
       }
       case FIELD: {
         Handle<Name> key(descs->GetKey(i));

[Igor Sheludko, 2014/04/14 16:17:53]

, isolate)

         Handle<Object> value(
             object->RawFastPropertyAt(descs->GetFieldIndex(i)), isolate);
         PropertyDetails d =
             PropertyDetails(details.attributes(), NORMAL, i + 1);
         dictionary = NameDictionaryAdd(dictionary, key, value, d);
         break;
       }
       case CALLBACKS: {
         Handle<Name> key(descs->GetKey(i));

[Igor Sheludko, 2014/04/14 16:17:53]

, isolate)

         Handle<Object> value(descs->GetCallbacksObject(i), isolate);
         PropertyDetails d = PropertyDetails(
             details.attributes(), CALLBACKS, i + 1);
         dictionary = NameDictionaryAdd(dictionary, key, value, d);
         break;
       }
       case INTERCEPTOR:
         break;
       case HANDLER:
       case NORMAL:
       case NONEXISTENT:
         UNREACHABLE();
         break;
     }
   }
 
   // Copy the next enumeration index from instance descriptor.
   dictionary->SetNextEnumerationIndex(real_size + 1);
 
   Handle<NormalizedMapCache> cache(
       isolate->context()->native_context()->normalized_map_cache());

[Igor Sheludko, 2014/04/14 16:17:53]

, isolate)

-  Handle<Map> new_map = NormalizedMapCache::Get(cache, object, mode);
+  Handle<Map> new_map = NormalizedMapCache::Get(
+      cache, handle(object->map()), mode);

[Igor Sheludko, 2014/04/14 16:17:53]

handle(..., isolate)

   ASSERT(new_map->is_dictionary_map());
 
   // From here on we cannot fail and we shouldn't GC anymore.
   DisallowHeapAllocation no_allocation;
 
   // Resize the object in the heap if necessary.
   int new_instance_size = new_map->instance_size();
   int instance_size_delta = map->instance_size() - new_instance_size;
   ASSERT(instance_size_delta >= 0);
   Heap* heap = isolate->heap();
@@ skipping 11936 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