Handlify Heap::AllocateInitialMap method.

R=rossberg@chromium.org
BUG=v8:2877

Review URL: https://codereview.chromium.org/32003006

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@17482 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

diff --git a/src/factory.cc b/src/factory.cc
index 7886627b9fff49a16e774ba98fe34d17bf683c47..400132e14b520f1bf5ff7992d4c59e090d9dde88 100644 (file)
--- a/src/factory.cc
+++ b/src/factory.cc
@@ -583,12 +583,6 @@ Handle<JSObject> Factory::NewFunctionPrototype(Handle<JSFunction> function) {
 }
 
 
-Handle<Map> Factory::NewInitialMap(Handle<JSFunction> function) {
-  CALL_HEAP_FUNCTION(
-      isolate(), isolate()->heap()->AllocateInitialMap(*function), Map);
-}
-
-
 Handle<Map> Factory::CopyWithPreallocatedFieldDescriptors(Handle<Map> src) {
   CALL_HEAP_FUNCTION(
       isolate(), src->CopyWithPreallocatedFieldDescriptors(), Map);

diff --git a/src/factory.h b/src/factory.h
index 2e02ed19be94856c19697793d48d898c7b4f7fc7..d7761b992715c17cf66479f69f2c5169e848f237 100644 (file)
--- a/src/factory.h
+++ b/src/factory.h
@@ -263,8 +263,6 @@ class Factory {
 
   Handle<JSObject> NewFunctionPrototype(Handle<JSFunction> function);
 
-  Handle<Map> NewInitialMap(Handle<JSFunction> function);
-
   Handle<Map> CopyWithPreallocatedFieldDescriptors(Handle<Map> map);
 
   // Copy the map adding more inobject properties if possible without

diff --git a/src/heap.cc b/src/heap.cc
index 7f5d323393183ba78d792e2307c0de09e581be82..ecd959da6716ee680e1c8307dc7594dfce8c2d46 100644 (file)
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -4492,48 +4492,6 @@ MaybeObject* Heap::AllocateArgumentsObject(Object* callee, int length) {
 }
 
 
-MaybeObject* Heap::AllocateInitialMap(JSFunction* fun) {
-  ASSERT(!fun->has_initial_map());
-
-  // First create a new map with the size and number of in-object properties
-  // suggested by the function.
-  InstanceType instance_type;
-  int instance_size;
-  int in_object_properties;
-  if (fun->shared()->is_generator()) {
-    instance_type = JS_GENERATOR_OBJECT_TYPE;
-    instance_size = JSGeneratorObject::kSize;
-    in_object_properties = 0;
-  } else {
-    instance_type = JS_OBJECT_TYPE;
-    instance_size = fun->shared()->CalculateInstanceSize();
-    in_object_properties = fun->shared()->CalculateInObjectProperties();
-  }
-  Map* map;
-  MaybeObject* maybe_map = AllocateMap(instance_type, instance_size);
-  if (!maybe_map->To(&map)) return maybe_map;
-
-  // Fetch or allocate prototype.
-  Object* prototype;
-  if (fun->has_instance_prototype()) {
-    prototype = fun->instance_prototype();
-  } else {
-    MaybeObject* maybe_prototype = AllocateFunctionPrototype(fun);
-    if (!maybe_prototype->To(&prototype)) return maybe_prototype;
-  }
-  map->set_inobject_properties(in_object_properties);
-  map->set_unused_property_fields(in_object_properties);
-  map->set_prototype(prototype);
-  ASSERT(map->has_fast_object_elements());
-
-  if (!fun->shared()->is_generator()) {
-    fun->shared()->StartInobjectSlackTracking(map);
-  }
-
-  return map;
-}
-
-
 void Heap::InitializeJSObjectFromMap(JSObject* obj,
                                      FixedArray* properties,
                                      Map* map) {

diff --git a/src/heap.h b/src/heap.h
index a18525caeaaca3507434ee00461901b7977a1341..fc0a2152fda70eca671605c49d9d555a53410985 100644 (file)
--- a/src/heap.h
+++ b/src/heap.h
@@ -744,9 +744,6 @@ class Heap {
   MUST_USE_RESULT MaybeObject* AllocatePartialMap(InstanceType instance_type,
                                                   int instance_size);
 
-  // Allocate a map for the specified function
-  MUST_USE_RESULT MaybeObject* AllocateInitialMap(JSFunction* fun);
-
   // Allocates an empty code cache.
   MUST_USE_RESULT MaybeObject* AllocateCodeCache();
 

diff --git a/src/objects.cc b/src/objects.cc
index cc73995ae7e16ea5191ac1d8991485d3be55c0bc..8bb603a985db87e6a8c0d78be94d081b74777f67 100644 (file)
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -9899,9 +9899,42 @@ void JSFunction::RemovePrototype() {
 void JSFunction::EnsureHasInitialMap(Handle<JSFunction> function) {
   if (function->has_initial_map()) return;
   Isolate* isolate = function->GetIsolate();
-  Handle<Map> initial_map = isolate->factory()->NewInitialMap(function);
-  function->set_initial_map(*initial_map);
-  initial_map->set_constructor(*function);
+
+  // First create a new map with the size and number of in-object properties
+  // suggested by the function.
+  InstanceType instance_type;
+  int instance_size;
+  int in_object_properties;
+  if (function->shared()->is_generator()) {
+    instance_type = JS_GENERATOR_OBJECT_TYPE;
+    instance_size = JSGeneratorObject::kSize;
+    in_object_properties = 0;
+  } else {
+    instance_type = JS_OBJECT_TYPE;
+    instance_size = function->shared()->CalculateInstanceSize();
+    in_object_properties = function->shared()->CalculateInObjectProperties();
+  }
+  Handle<Map> map = isolate->factory()->NewMap(instance_type, instance_size);
+
+  // Fetch or allocate prototype.
+  Handle<Object> prototype;
+  if (function->has_instance_prototype()) {
+    prototype = handle(function->instance_prototype(), isolate);
+  } else {
+    prototype = isolate->factory()->NewFunctionPrototype(function);
+  }
+  map->set_inobject_properties(in_object_properties);
+  map->set_unused_property_fields(in_object_properties);
+  map->set_prototype(*prototype);
+  ASSERT(map->has_fast_object_elements());
+
+  if (!function->shared()->is_generator()) {
+    function->shared()->StartInobjectSlackTracking(*map);
+  }
+
+  // Finally link initial map and constructor function.
+  function->set_initial_map(*map);
+  map->set_constructor(*function);
 }