AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Handlify Heap::AllocateInitialMap method.

Browse Source 
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
This commit is contained in:
mstarzinger@chromium.org 2013-11-05 12:32:03 +00:00
parent e78081ca1c
commit ea89d6bd29
5 changed files with 36 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/factory.cc
View File

@ -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);

2
src/factory.h
View File

@ -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

42
src/heap.cc
View File

@ -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) {

3
src/heap.h
View File

@ -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();

39
src/objects.cc
View File

@ -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);
}