Allocate as many object-literal properties as possible inobject....

src/factory.cc

 // Copyright 2006-2008 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 177 matching lines @@
 Handle<JSObject> Factory::NewFunctionPrototype(Handle<JSFunction> function) {
   CALL_HEAP_FUNCTION(Heap::AllocateFunctionPrototype(*function), JSObject);
 }
 
 
 Handle<Map> Factory::CopyMap(Handle<Map> src) {
   CALL_HEAP_FUNCTION(src->Copy(), Map);
 }
 
 
+Handle<Map> Factory::CopyMap(Handle<Map> src,
+                             int extra_inobject_properties) {
+  Handle<Map> copy = CopyMap(src);
+  // Check that we do not overflow the instance size when adding the
+  // extra inobject properties.
+  int instance_size_delta = extra_inobject_properties * kPointerSize;
+  int max_instance_size_delta =
+      JSObject::kMaxInstanceSize - copy->instance_size();
+  if (instance_size_delta > max_instance_size_delta) {
+    // If the instance size overflows, we allocate as many properties
+    // as we can as inobject properties.
+    instance_size_delta = max_instance_size_delta;
+    extra_inobject_properties = max_instance_size_delta >> kPointerSizeLog2;
+  }
+  // Adjust the map with the extra inobject properties.
+  int inobject_properties =
+      copy->inobject_properties() + extra_inobject_properties;
+  copy->set_inobject_properties(inobject_properties);
+  copy->set_unused_property_fields(inobject_properties);
+  copy->set_instance_size(copy->instance_size() + instance_size_delta);
+  return copy;
+}
+
 Handle<Map> Factory::CopyMapDropTransitions(Handle<Map> src) {
   CALL_HEAP_FUNCTION(src->CopyDropTransitions(), Map);
 }
 
 
 Handle<FixedArray> Factory::CopyFixedArray(Handle<FixedArray> array) {
   CALL_HEAP_FUNCTION(array->Copy(), FixedArray);
 }
 
 
@@ skipping 362 matching lines @@
   CALL_HEAP_FUNCTION(Heap::AllocateJSObject(*constructor, pretenure), JSObject);
 }
 
 
 Handle<JSObject> Factory::NewJSObjectFromMap(Handle<Map> map) {
   CALL_HEAP_FUNCTION(Heap::AllocateJSObjectFromMap(*map, NOT_TENURED),
                      JSObject);
 }
 
 
-Handle<JSObject> Factory::NewObjectLiteral(int expected_number_of_properties) {
-  Handle<Map> map = Handle<Map>(Top::object_function()->initial_map());
-  map = Factory::CopyMap(map);
-  map->set_instance_descriptors(Heap::empty_descriptor_array());
-  map->set_unused_property_fields(expected_number_of_properties);
-  CALL_HEAP_FUNCTION(Heap::AllocateJSObjectFromMap(*map, TENURED),
-                     JSObject);
-}
-
-
 Handle<JSArray> Factory::NewArrayLiteral(int length) {
   return NewJSArrayWithElements(NewFixedArray(length), TENURED);
 }
 
 
 Handle<JSArray> Factory::NewJSArray(int length,
                                     PretenureFlag pretenure) {
   Handle<JSObject> obj = NewJSObject(Top::array_function(), pretenure);
   CALL_HEAP_FUNCTION(Handle<JSArray>::cast(obj)->Initialize(length), JSArray);
 }
@@ skipping 209 matching lines @@
     Handle<MapCache> new_cache = NewMapCache(24);
     context->set_map_cache(*new_cache);
   }
   // Check to see whether there is a maching element in the cache.
   Handle<MapCache> cache =
       Handle<MapCache>(MapCache::cast(context->map_cache()));
   Handle<Object> result = Handle<Object>(cache->Lookup(*keys));
   if (result->IsMap()) return Handle<Map>::cast(result);
   // Create a new map and add it to the cache.
   Handle<Map> map =
-      CopyMap(Handle<Map>(context->object_function()->initial_map()));
+      CopyMap(Handle<Map>(context->object_function()->initial_map()),
+              keys->length());
   AddToMapCache(context, keys, map);
   return Handle<Map>(map);
 }
 
 
 void Factory::SetRegExpData(Handle<JSRegExp> regexp,
                             JSRegExp::Type type,
                             Handle<String> source,
                             JSRegExp::Flags flags,
                             Handle<Object> data) {
@@ skipping 16 matching lines @@
     Execution::ConfigureInstance(instance,
                                  instance_template,
                                  pending_exception);
   } else {
     *pending_exception = false;
   }
 }
 
 
 } }  // namespace v8::internal