Function allocators handlified.

src/factory.cc

 // Copyright 2014 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 "factory.h"
 
 #include "isolate-inl.h"
 
 namespace v8 {
 namespace internal {
 
+
+template<typename T>
+Handle<T> Factory::New(Handle<Map> map, AllocationSpace space) {
+  CALL_HEAP_FUNCTION(
+      isolate(),
+      isolate()->heap()->Allocate(*map, space),
+      T);
+}
+
+
+template<typename T>
+Handle<T> Factory::New(Handle<Map> map,
+                       AllocationSpace space,
+                       Handle<AllocationSite> allocation_site) {
+  CALL_HEAP_FUNCTION(
+      isolate(),
+      isolate()->heap()->Allocate(*map, space, *allocation_site),
+      T);
+}
+
+
 Handle<Box> Factory::NewBox(Handle<Object> value) {
   Handle<Box> result = Handle<Box>::cast(NewStruct(BOX_TYPE));
   result->set_value(*value);
   return result;
 }
 
 
 Handle<FixedArray> Factory::NewFixedArray(int size, PretenureFlag pretenure) {
   ASSERT(0 <= size);
   CALL_HEAP_FUNCTION(
@@ skipping 318 matching lines @@
   SinkChar* sink = result->GetChars();
   String::WriteToFlat(*first, sink, 0, first->length());
   String::WriteToFlat(*second, sink + first->length(), 0, second->length());
   return result;
 }
 
 
 Handle<ConsString> Factory::NewRawConsString(String::Encoding encoding) {
   Handle<Map> map = (encoding == String::ONE_BYTE_ENCODING)
       ? cons_ascii_string_map() : cons_string_map();
-  CALL_HEAP_FUNCTION(isolate(),
-                     isolate()->heap()->Allocate(*map, NEW_SPACE),
-                     ConsString);
+  return New<ConsString>(map, NEW_SPACE);
 }
 
 
 MaybeHandle<String> Factory::NewConsString(Handle<String> left,
                                            Handle<String> right) {
   int left_length = left->length();
   if (left_length == 0) return right;
   int right_length = right->length();
   if (right_length == 0) return left;
 
@@ skipping 85 matching lines @@
   } else {
     return ConcatStringContent<uc16>(
         NewRawTwoByteString(total_length).ToHandleChecked(), first, second);
   }
 }
 
 
 Handle<SlicedString> Factory::NewRawSlicedString(String::Encoding encoding) {
   Handle<Map> map = (encoding == String::ONE_BYTE_ENCODING)
       ? sliced_ascii_string_map() : sliced_string_map();
-  CALL_HEAP_FUNCTION(isolate(),
-                     isolate()->heap()->Allocate(*map, NEW_SPACE),
-                     SlicedString);
+  return New<SlicedString>(map, NEW_SPACE);
 }
 
 
 Handle<String> Factory::NewProperSubString(Handle<String> str,
                                            int begin,
                                            int end) {
 #if VERIFY_HEAP
   if (FLAG_verify_heap) str->StringVerify();
 #endif
   ASSERT(begin > 0 || end < str->length());
@@ skipping 418 matching lines @@
   CALL_HEAP_FUNCTION(isolate(), array->Copy(), FixedDoubleArray);
 }
 
 
 Handle<ConstantPoolArray> Factory::CopyConstantPoolArray(
     Handle<ConstantPoolArray> array) {
   CALL_HEAP_FUNCTION(isolate(), array->Copy(), ConstantPoolArray);
 }
 
 
-Handle<JSFunction> Factory::BaseNewFunctionFromSharedFunctionInfo(
-    Handle<SharedFunctionInfo> function_info,
-    Handle<Map> function_map,
-    PretenureFlag pretenure) {
-  CALL_HEAP_FUNCTION(
-      isolate(),
-      isolate()->heap()->AllocateFunction(*function_map,
-                                          *function_info,
-                                          isolate()->heap()->the_hole_value(),
-                                          pretenure),
-                     JSFunction);
-}
-
-
 static Handle<Map> MapForNewFunction(Isolate *isolate,
                                      Handle<SharedFunctionInfo> function_info) {
   Context *context = isolate->context()->native_context();
   int map_index = Context::FunctionMapIndex(function_info->strict_mode(),
                                             function_info->is_generator());
   return Handle<Map>(Map::cast(context->get(map_index)));
 }
 
 
 Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
     Handle<SharedFunctionInfo> function_info,
     Handle<Context> context,
     PretenureFlag pretenure) {
-  Handle<JSFunction> result = BaseNewFunctionFromSharedFunctionInfo(
+  Handle<JSFunction> result = NewFunctionHelper(
+      MapForNewFunction(isolate(), function_info),
       function_info,
-      MapForNewFunction(isolate(), function_info),
+      the_hole_value(),
       pretenure);
 
   if (function_info->ic_age() != isolate()->heap()->global_ic_age()) {
     function_info->ResetForNewContext(isolate()->heap()->global_ic_age());
   }
 
   result->set_context(*context);
 
   int index = function_info->SearchOptimizedCodeMap(context->native_context(),
                                                     BailoutId::None());
@@ skipping 397 matching lines @@
 static Handle<NameDictionary> NameDictionaryAdd(Handle<NameDictionary> dict,
                                                 Handle<Name> name,
                                                 Handle<Object> value,
                                                 PropertyDetails details) {
   CALL_HEAP_FUNCTION(dict->GetIsolate(),
                      dict->Add(*name, *value, details),
                      NameDictionary);
 }
 
 
-static Handle<GlobalObject> NewGlobalObjectFromMap(Isolate* isolate,
-                                                   Handle<Map> map) {
-  CALL_HEAP_FUNCTION(isolate,
-                     isolate->heap()->Allocate(*map, OLD_POINTER_SPACE),
-                     GlobalObject);
-}
-
-
 Handle<GlobalObject> Factory::NewGlobalObject(Handle<JSFunction> constructor) {
   ASSERT(constructor->has_initial_map());
   Handle<Map> map(constructor->initial_map());
   ASSERT(map->is_dictionary_map());
 
   // Make sure no field properties are described in the initial map.
   // This guarantees us that normalizing the properties does not
   // require us to change property values to PropertyCells.
   ASSERT(map->NextFreePropertyIndex() == 0);
 
@@ skipping 18 matching lines @@
     PropertyDetails details = descs->GetDetails(i);
     ASSERT(details.type() == CALLBACKS);  // Only accessors are expected.
     PropertyDetails d = PropertyDetails(details.attributes(), CALLBACKS, i + 1);
     Handle<Name> name(descs->GetKey(i));
     Handle<Object> value(descs->GetCallbacksObject(i), isolate());
     Handle<PropertyCell> cell = NewPropertyCell(value);
     NameDictionaryAdd(dictionary, name, cell, d);
   }
 
   // Allocate the global object and initialize it with the backing store.
-  Handle<GlobalObject> global = NewGlobalObjectFromMap(isolate(), map);
+  Handle<GlobalObject> global = New<GlobalObject>(map, OLD_POINTER_SPACE);
   isolate()->heap()->InitializeJSObjectFromMap(*global, *dictionary, *map);
 
   // Create a new map for the global object.
   Handle<Map> new_map = Map::CopyDropDescriptors(map);
   new_map->set_dictionary_map(true);
 
   // Set up the global object as a normalized object.
   global->set_map(*new_map);
   global->set_properties(*dictionary);
 
@@ skipping 155 matching lines @@
 
 Handle<JSProxy> Factory::NewJSProxy(Handle<Object> handler,
                                     Handle<Object> prototype) {
   CALL_HEAP_FUNCTION(
       isolate(),
       isolate()->heap()->AllocateJSProxy(*handler, *prototype),
       JSProxy);
 }
 
 
+void Factory::ReinitializeJSReceiver(Handle<JSReceiver> object,
+                                     InstanceType type,
+                                     int size) {
+  ASSERT(type >= FIRST_JS_OBJECT_TYPE);
+
+  // Allocate fresh map.
+  // TODO(rossberg): Once we optimize proxies, cache these maps.
+  Handle<Map> map = NewMap(type, size);
+
+  // Check that the receiver has at least the size of the fresh object.
+  int size_difference = object->map()->instance_size() - map->instance_size();
+  ASSERT(size_difference >= 0);
+
+  map->set_prototype(object->map()->prototype());
+
+  // Allocate the backing storage for the properties.
+  int prop_size = map->unused_property_fields() - map->inobject_properties();
+  Handle<FixedArray> properties = NewFixedArray(prop_size, TENURED);
+
+  // Reset the map for the object.
+  object->set_map(*map);
+  Handle<JSObject> jsobj = Handle<JSObject>::cast(object);
+
+  Heap* heap = isolate()->heap();

[Michael Starzinger, 2014/04/15 09:54:59]

nit: There should be Factory::heap() IIRC, I think there is no need to pull out
the Heap into a local variable if we use that one.

[Igor Sheludko, 2014/04/15 11:03:42]

There's no heap() method. Lets address this in a separate CL.

+  // Reinitialize the object from the constructor map.
+  heap->InitializeJSObjectFromMap(*jsobj, FixedArray::cast(*properties), *map);

[Michael Starzinger, 2014/04/15 09:54:59]

nit: No need to cast the FixedArray anymore, it is also typed correctly.

[Igor Sheludko, 2014/04/15 11:03:42]

Done.

+
+  // Functions require some minimal initialization.
+  if (type == JS_FUNCTION_TYPE) {
+    OneByteStringKey key(STATIC_ASCII_VECTOR("<freezing call trap>"),
+                         heap->HashSeed());
+    Handle<String> name = InternalizeStringWithKey(&key);
+    Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(name);
+
+    map->set_function_with_prototype(true);
+    Handle<JSFunction> js_function = Handle<JSFunction>::cast(object);
+    InitializeFunction(js_function, shared, the_hole_value());

[Michael Starzinger, 2014/04/15 09:54:59]

Same comment as below goes for the call to InitializeFunction. This whole method
needs to be re-ordered to maintain a consistent heap at allocation points.

[Igor Sheludko, 2014/04/15 11:03:42]

Done.

+    js_function->set_context(isolate()->context()->native_context());
+  }
+
+  // Put in filler if the new object is smaller than the old.
+  if (size_difference > 0) {
+    heap->CreateFillerObjectAt(

[Michael Starzinger, 2014/04/15 09:54:59]

Creating the filler object needs to happen right after we change the map of the
object, otherwise the heap is no longer iterable. Hence the allocations in the
block above could cause GCs that see an inconsistent heap. Please move this up
to after the call to InitializeJSObjectFromMap above.

[Igor Sheludko, 2014/04/15 11:03:42]

I fixed this in a little bit different way than you suggested.

+        object->address() + map->instance_size(), size_difference);
+  }
+}
+
+
+void Factory::ReinitializeJSGlobalProxy(Handle<JSFunction> constructor,
+                                        Handle<JSGlobalProxy> object) {
+  ASSERT(constructor->has_initial_map());
+  Handle<Map> map(constructor->initial_map(), isolate());
+
+  // Check that the already allocated object has the same size and type as
+  // objects allocated using the constructor.
+  ASSERT(map->instance_size() == object->map()->instance_size());
+  ASSERT(map->instance_type() == object->map()->instance_type());
+
+  // Allocate the backing storage for the properties.
+  int prop_size = map->unused_property_fields() - map->inobject_properties();
+  Handle<FixedArray> properties =
+      isolate()->factory()->NewFixedArray(prop_size, TENURED);

[Michael Starzinger, 2014/04/15 09:54:59]

nit: We are already inside the Factory, just call NewFixedArray directly here.

[Igor Sheludko, 2014/04/15 11:03:42]

Fixed here and in all other places in the file.

+
+  // Reset the map for the object.
+  object->set_map(constructor->initial_map());
+
+  Heap* heap = isolate()->heap();

[Michael Starzinger, 2014/04/15 09:54:59]

nit: There should be Factory::heap() IIRC, I think there is no need to pull out
the Heap into a local variable if we use that one.

[Igor Sheludko, 2014/04/15 11:03:42]

Done.

+  // Reinitialize the object from the constructor map.
+  heap->InitializeJSObjectFromMap(*object, FixedArray::cast(*properties), *map);

[Michael Starzinger, 2014/04/15 09:54:59]

nit: No need to cast the FixedArray anymore, it is also typed correctly.

[Igor Sheludko, 2014/04/15 11:03:42]

Done.

+}
+
+
 void Factory::BecomeJSObject(Handle<JSReceiver> object) {
-  CALL_HEAP_FUNCTION_VOID(
-      isolate(),
-      isolate()->heap()->ReinitializeJSReceiver(
-          *object, JS_OBJECT_TYPE, JSObject::kHeaderSize));
+  ReinitializeJSReceiver(object, JS_OBJECT_TYPE, JSObject::kHeaderSize);
 }
 
 
 void Factory::BecomeJSFunction(Handle<JSReceiver> object) {
-  CALL_HEAP_FUNCTION_VOID(
-      isolate(),
-      isolate()->heap()->ReinitializeJSReceiver(
-          *object, JS_FUNCTION_TYPE, JSFunction::kSize));
+  ReinitializeJSReceiver(object, JS_FUNCTION_TYPE, JSFunction::kSize);
 }
 
 
 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
     Handle<String> name,
     int number_of_literals,
     bool is_generator,
     Handle<Code> code,
     Handle<ScopeInfo> scope_info) {
   Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(name);
@@ skipping 65 matching lines @@
 Handle<UnseededNumberDictionary> Factory::DictionaryAtNumberPut(
     Handle<UnseededNumberDictionary> dictionary,
     uint32_t key,
     Handle<Object> value) {
   CALL_HEAP_FUNCTION(isolate(),
                      dictionary->AtNumberPut(key, *value),
                      UnseededNumberDictionary);
 }
 
 
-Handle<JSFunction> Factory::NewFunctionHelper(Handle<String> name,

[Igor Sheludko, 2014/04/15 08:33:32]

one usage, inlined

-                                              Handle<Object> prototype) {
-  Handle<SharedFunctionInfo> function_share = NewSharedFunctionInfo(name);
-  CALL_HEAP_FUNCTION(
-      isolate(),
-      isolate()->heap()->AllocateFunction(*isolate()->sloppy_function_map(),
-                                          *function_share,
-                                          *prototype),
-      JSFunction);
+void Factory::InitializeFunction(Handle<JSFunction> function,
+                                 Handle<SharedFunctionInfo> shared,
+                                 Handle<Object> prototype) {
+  ASSERT(!prototype->IsMap());
+  function->initialize_properties();
+  function->initialize_elements();
+  function->set_shared(*shared);
+  function->set_code(shared->code());
+  function->set_prototype_or_initial_map(*prototype);
+  function->set_context(*undefined_value());
+  function->set_literals_or_bindings(*empty_fixed_array());
+  function->set_next_function_link(*undefined_value());
+}
+
+
+Handle<JSFunction> Factory::NewFunctionHelper(Handle<Map> function_map,

[Igor Sheludko, 2014/04/15 08:33:32]

Handlified Heap::AllocateFunction()

+                                              Handle<SharedFunctionInfo> shared,
+                                              Handle<Object> prototype,
+                                              PretenureFlag pretenure) {
+  AllocationSpace space =
+      (pretenure == TENURED) ? OLD_POINTER_SPACE : NEW_SPACE;
+  Handle<JSFunction> fun = New<JSFunction>(function_map, space);
+  InitializeFunction(fun, shared, prototype);
+  return fun;
 }
 
 
 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
                                         Handle<Object> prototype) {
-  Handle<JSFunction> fun = NewFunctionHelper(name, prototype);
+  Handle<SharedFunctionInfo> function_share = NewSharedFunctionInfo(name);
+  Handle<JSFunction> fun = NewFunctionHelper(
+      isolate()->sloppy_function_map(), function_share, prototype);
   fun->set_context(isolate()->context()->native_context());
   return fun;
 }
 
 
-Handle<JSFunction> Factory::NewFunctionWithoutPrototypeHelper(

[Igor Sheludko, 2014/04/15 08:33:32]

one usage, inlined

+Handle<JSFunction> Factory::NewFunctionWithoutPrototype(
     Handle<String> name,
     StrictMode strict_mode) {
   Handle<SharedFunctionInfo> function_share = NewSharedFunctionInfo(name);
   Handle<Map> map = strict_mode == SLOPPY
       ? isolate()->sloppy_function_without_prototype_map()
       : isolate()->strict_function_without_prototype_map();
-  CALL_HEAP_FUNCTION(isolate(),
-                     isolate()->heap()->AllocateFunction(
-                         *map,
-                         *function_share,
-                         *the_hole_value()),
-                     JSFunction);
-}
-
-
-Handle<JSFunction> Factory::NewFunctionWithoutPrototype(
-    Handle<String> name,
-    StrictMode strict_mode) {
-  Handle<JSFunction> fun = NewFunctionWithoutPrototypeHelper(name, strict_mode);
+  Handle<JSFunction> fun =
+      NewFunctionHelper(map, function_share, the_hole_value());
   fun->set_context(isolate()->context()->native_context());
   return fun;
 }
 
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 Handle<DebugInfo> Factory::NewDebugInfo(Handle<SharedFunctionInfo> shared) {
   // Get the original code of the function.
   Handle<Code> code(shared->code());
 
@@ skipping 301 matching lines @@
   if (String::Equals(name, infinity_string())) return infinity_value();
   return Handle<Object>::null();
 }
 
 
 Handle<Object> Factory::ToBoolean(bool value) {
   return value ? true_value() : false_value();
 }
 
 } }  // namespace v8::internal