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

Isolates: Cleanup usage of FACTORY in code stubs and bootstrapper.

Browse Source 
Review URL: http://codereview.chromium.org/6720014

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@7611 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
karlklose@chromium.org 2011-04-14 08:01:19 +00:00
parent 26e2d5a89f
commit f7840f65f0
8 changed files with 193 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/api.cc
View File

@ -3707,6 +3707,7 @@ Persistent<Context> v8::Context::New(
// Create the environment.
env = isolate->bootstrapper()->CreateEnvironment(
isolate,
Utils::OpenHandle(*global_object),
proxy_template,
extensions);

12
src/arm/code-stubs-arm.cc
View File

@ -3678,7 +3678,7 @@ void InstanceofStub::Generate(MacroAssembler* masm) {
__ b(ne, &slow);
// Null is not instance of anything.
__ cmp(scratch, Operand(FACTORY->null_value()));
__ cmp(scratch, Operand(masm->isolate()->factory()->null_value()));
__ b(ne, &object_not_null);
__ mov(r0, Operand(Smi::FromInt(1)));
__ Ret(HasArgsInRegisters() ? 0 : 2);
@ -4176,7 +4176,7 @@ void RegExpExecStub::Generate(MacroAssembler* masm) {
__ bind(&failure);
// For failure and exception return null.
__ mov(r0, Operand(FACTORY->null_value()));
__ mov(r0, Operand(masm->isolate()->factory()->null_value()));
__ add(sp, sp, Operand(4 * kPointerSize));
__ Ret();
@ -4247,6 +4247,8 @@ void RegExpConstructResultStub::Generate(MacroAssembler* masm) {
const int kMaxInlineLength = 100;
Label slowcase;
Label done;
Factory* factory = masm->isolate()->factory();
__ ldr(r1, MemOperand(sp, kPointerSize * 2));
STATIC_ASSERT(kSmiTag == 0);
STATIC_ASSERT(kSmiTagSize == 1);
@ -4281,7 +4283,7 @@ void RegExpConstructResultStub::Generate(MacroAssembler* masm) {
// Interleave operations for better latency.
__ ldr(r2, ContextOperand(cp, Context::GLOBAL_INDEX));
__ add(r3, r0, Operand(JSRegExpResult::kSize));
__ mov(r4, Operand(FACTORY->empty_fixed_array()));
__ mov(r4, Operand(factory->empty_fixed_array()));
__ ldr(r2, FieldMemOperand(r2, GlobalObject::kGlobalContextOffset));
__ str(r3, FieldMemOperand(r0, JSObject::kElementsOffset));
__ ldr(r2, ContextOperand(r2, Context::REGEXP_RESULT_MAP_INDEX));
@ -4302,13 +4304,13 @@ void RegExpConstructResultStub::Generate(MacroAssembler* masm) {
// r5: Number of elements in array, untagged.
// Set map.
__ mov(r2, Operand(FACTORY->fixed_array_map()));
__ mov(r2, Operand(factory->fixed_array_map()));
__ str(r2, FieldMemOperand(r3, HeapObject::kMapOffset));
// Set FixedArray length.
__ mov(r6, Operand(r5, LSL, kSmiTagSize));
__ str(r6, FieldMemOperand(r3, FixedArray::kLengthOffset));
// Fill contents of fixed-array with the-hole.
__ mov(r2, Operand(FACTORY->the_hole_value()));
__ mov(r2, Operand(factory->the_hole_value()));
__ add(r3, r3, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
// Fill fixed array elements with hole.
// r0: JSArray, tagged.

320
src/bootstrapper.cc
View File

@ -1,4 +1,4 @@
// Copyright 2006-2008 the V8 project authors. All rights reserved.
// Copyright 2011 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:
@ -141,7 +141,8 @@ void Bootstrapper::TearDown() {
class Genesis BASE_EMBEDDED {
public:
Genesis(Handle<Object> global_object,
Genesis(Isolate* isolate,
Handle<Object> global_object,
v8::Handle<v8::ObjectTemplate> global_template,
v8::ExtensionConfiguration* extensions);
~Genesis() { }
@ -150,8 +151,13 @@ class Genesis BASE_EMBEDDED {
Genesis* previous() { return previous_; }
Isolate* isolate() const { return isolate_; }
Factory* factory() const { return isolate_->factory(); }
Heap* heap() const { return isolate_->heap(); }
private:
Handle<Context> global_context_;
Isolate* isolate_;
// There may be more than one active genesis object: When GC is
// triggered during environment creation there may be weak handle
@ -163,7 +169,7 @@ class Genesis BASE_EMBEDDED {
// Creates some basic objects. Used for creating a context from scratch.
void CreateRoots();
// Creates the empty function. Used for creating a context from scratch.
Handle<JSFunction> CreateEmptyFunction();
Handle<JSFunction> CreateEmptyFunction(Isolate* isolate);
// Creates the ThrowTypeError function. ECMA 5th Ed. 13.2.3
Handle<JSFunction> CreateThrowTypeErrorFunction(Builtins::Name builtin);
@ -239,7 +245,7 @@ class Genesis BASE_EMBEDDED {
Handle<FixedArray> arguments,
Handle<FixedArray> caller);
static bool CompileBuiltin(int index);
static bool CompileBuiltin(Isolate* isolate, int index);
static bool CompileNative(Vector<const char> name, Handle<String> source);
static bool CompileScriptCached(Vector<const char> name,
Handle<String> source,
@ -269,12 +275,13 @@ void Bootstrapper::Iterate(ObjectVisitor* v) {
Handle<Context> Bootstrapper::CreateEnvironment(
Isolate* isolate,
Handle<Object> global_object,
v8::Handle<v8::ObjectTemplate> global_template,
v8::ExtensionConfiguration* extensions) {
HandleScope scope;
Handle<Context> env;
Genesis genesis(global_object, global_template, extensions);
Genesis genesis(isolate, global_object, global_template, extensions);
env = genesis.result();
if (!env.is_null()) {
if (InstallExtensions(env, extensions)) {
@ -287,15 +294,16 @@ Handle<Context> Bootstrapper::CreateEnvironment(
static void SetObjectPrototype(Handle<JSObject> object, Handle<Object> proto) {
// object.__proto__ = proto;
Factory* factory = object->GetIsolate()->factory();
Handle<Map> old_to_map = Handle<Map>(object->map());
Handle<Map> new_to_map = FACTORY->CopyMapDropTransitions(old_to_map);
Handle<Map> new_to_map = factory->CopyMapDropTransitions(old_to_map);
new_to_map->set_prototype(*proto);
object->set_map(*new_to_map);
}
void Bootstrapper::DetachGlobal(Handle<Context> env) {
Factory* factory = Isolate::Current()->factory();
Factory* factory = env->GetIsolate()->factory();
JSGlobalProxy::cast(env->global_proxy())->set_context(*factory->null_value());
SetObjectPrototype(Handle<JSObject>(env->global_proxy()),
factory->null_value());
@ -322,7 +330,7 @@ static Handle<JSFunction> InstallFunction(Handle<JSObject> target,
Handle<JSObject> prototype,
Builtins::Name call,
bool is_ecma_native) {
Isolate* isolate = Isolate::Current();
Isolate* isolate = target->GetIsolate();
Factory* factory = isolate->factory();
Handle<String> symbol = factory->LookupAsciiSymbol(name);
Handle<Code> call_code = Handle<Code>(isolate->builtins()->builtin(call));
@ -344,30 +352,29 @@ static Handle<JSFunction> InstallFunction(Handle<JSObject> target,
Handle<DescriptorArray> Genesis::ComputeFunctionInstanceDescriptor(
PrototypePropertyMode prototypeMode) {
Factory* factory = Isolate::Current()->factory();
Handle<DescriptorArray> descriptors =
factory->NewDescriptorArray(prototypeMode == DONT_ADD_PROTOTYPE ? 4 : 5);
factory()->NewDescriptorArray(prototypeMode == DONT_ADD_PROTOTYPE ? 4 : 5);
PropertyAttributes attributes =
static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
{ // Add length.
Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionLength);
CallbacksDescriptor d(*factory->length_symbol(), *proxy, attributes);
Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionLength);
CallbacksDescriptor d(*factory()->length_symbol(), *proxy, attributes);
descriptors->Set(0, &d);
}
{ // Add name.
Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionName);
CallbacksDescriptor d(*factory->name_symbol(), *proxy, attributes);
Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionName);
CallbacksDescriptor d(*factory()->name_symbol(), *proxy, attributes);
descriptors->Set(1, &d);
}
{ // Add arguments.
Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionArguments);
CallbacksDescriptor d(*factory->arguments_symbol(), *proxy, attributes);
Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionArguments);
CallbacksDescriptor d(*factory()->arguments_symbol(), *proxy, attributes);
descriptors->Set(2, &d);
}
{ // Add caller.
Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionCaller);
CallbacksDescriptor d(*factory->caller_symbol(), *proxy, attributes);
Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionCaller);
CallbacksDescriptor d(*factory()->caller_symbol(), *proxy, attributes);
descriptors->Set(3, &d);
}
if (prototypeMode != DONT_ADD_PROTOTYPE) {
@ -375,8 +382,8 @@ Handle<DescriptorArray> Genesis::ComputeFunctionInstanceDescriptor(
if (prototypeMode == ADD_WRITEABLE_PROTOTYPE) {
attributes = static_cast<PropertyAttributes>(attributes & ~READ_ONLY);
}
Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionPrototype);
CallbacksDescriptor d(*factory->prototype_symbol(), *proxy, attributes);
Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionPrototype);
CallbacksDescriptor d(*factory()->prototype_symbol(), *proxy, attributes);
descriptors->Set(4, &d);
}
descriptors->Sort();
@ -385,7 +392,7 @@ Handle<DescriptorArray> Genesis::ComputeFunctionInstanceDescriptor(
Handle<Map> Genesis::CreateFunctionMap(PrototypePropertyMode prototype_mode) {
Handle<Map> map = FACTORY->NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
Handle<Map> map = factory()->NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
Handle<DescriptorArray> descriptors =
ComputeFunctionInstanceDescriptor(prototype_mode);
map->set_instance_descriptors(*descriptors);
@ -394,7 +401,7 @@ Handle<Map> Genesis::CreateFunctionMap(PrototypePropertyMode prototype_mode) {
}
Handle<JSFunction> Genesis::CreateEmptyFunction() {
Handle<JSFunction> Genesis::CreateEmptyFunction(Isolate* isolate) {
// Allocate the map for function instances. Maps are allocated first and their
// prototypes patched later, once empty function is created.
@ -422,7 +429,6 @@ Handle<JSFunction> Genesis::CreateEmptyFunction() {
function_instance_map_writable_prototype_ =
CreateFunctionMap(ADD_WRITEABLE_PROTOTYPE);
Isolate* isolate = Isolate::Current();
Factory* factory = isolate->factory();
Heap* heap = isolate->heap();
@ -491,28 +497,29 @@ Handle<DescriptorArray> Genesis::ComputeStrictFunctionInstanceDescriptor(
PrototypePropertyMode prototypeMode,
Handle<FixedArray> arguments,
Handle<FixedArray> caller) {
Factory* factory = Isolate::Current()->factory();
Handle<DescriptorArray> descriptors =
factory->NewDescriptorArray(prototypeMode == DONT_ADD_PROTOTYPE ? 4 : 5);
factory()->NewDescriptorArray(prototypeMode == DONT_ADD_PROTOTYPE ? 4 : 5);
PropertyAttributes attributes = static_cast<PropertyAttributes>(
DONT_ENUM | DONT_DELETE | READ_ONLY);
{ // length
Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionLength);
CallbacksDescriptor d(*factory->length_symbol(), *proxy, attributes);
Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionLength);
CallbacksDescriptor d(*factory()->length_symbol(), *proxy, attributes);
descriptors->Set(0, &d);
}
{ // name
Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionName);
CallbacksDescriptor d(*factory->name_symbol(), *proxy, attributes);
Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionName);
CallbacksDescriptor d(*factory()->name_symbol(), *proxy, attributes);
descriptors->Set(1, &d);
}
{ // arguments
CallbacksDescriptor d(*factory->arguments_symbol(), *arguments, attributes);
CallbacksDescriptor d(*factory()->arguments_symbol(),
*arguments,
attributes);
descriptors->Set(2, &d);
}
{ // caller
CallbacksDescriptor d(*factory->caller_symbol(), *caller, attributes);
CallbacksDescriptor d(*factory()->caller_symbol(), *caller, attributes);
descriptors->Set(3, &d);
}
@ -521,8 +528,8 @@ Handle<DescriptorArray> Genesis::ComputeStrictFunctionInstanceDescriptor(
if (prototypeMode == ADD_WRITEABLE_PROTOTYPE) {
attributes = static_cast<PropertyAttributes>(attributes & ~READ_ONLY);
}
Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionPrototype);
CallbacksDescriptor d(*factory->prototype_symbol(), *proxy, attributes);
Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionPrototype);
CallbacksDescriptor d(*factory()->prototype_symbol(), *proxy, attributes);
descriptors->Set(4, &d);
}
@ -534,14 +541,11 @@ Handle<DescriptorArray> Genesis::ComputeStrictFunctionInstanceDescriptor(
// ECMAScript 5th Edition, 13.2.3
Handle<JSFunction> Genesis::CreateThrowTypeErrorFunction(
Builtins::Name builtin) {
Isolate* isolate = Isolate::Current();
Factory* factory = isolate->factory();
Handle<String> name = factory->LookupAsciiSymbol("ThrowTypeError");
Handle<String> name = factory()->LookupAsciiSymbol("ThrowTypeError");
Handle<JSFunction> throw_type_error =
factory->NewFunctionWithoutPrototype(name, kStrictMode);
factory()->NewFunctionWithoutPrototype(name, kStrictMode);
Handle<Code> code = Handle<Code>(
isolate->builtins()->builtin(builtin));
isolate()->builtins()->builtin(builtin));
throw_type_error->set_map(global_context()->strict_mode_function_map());
throw_type_error->set_code(*code);
@ -559,7 +563,7 @@ Handle<Map> Genesis::CreateStrictModeFunctionMap(
Handle<JSFunction> empty_function,
Handle<FixedArray> arguments_callbacks,
Handle<FixedArray> caller_callbacks) {
Handle<Map> map = FACTORY->NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
Handle<Map> map = factory()->NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
Handle<DescriptorArray> descriptors =
ComputeStrictFunctionInstanceDescriptor(prototype_mode,
arguments_callbacks,
@ -574,7 +578,7 @@ Handle<Map> Genesis::CreateStrictModeFunctionMap(
void Genesis::CreateStrictModeFunctionMaps(Handle<JSFunction> empty) {
// Create the callbacks arrays for ThrowTypeError functions.
// The get/set callacks are filled in after the maps are created below.
Factory* factory = Isolate::Current()->factory();
Factory* factory = empty->GetIsolate()->factory();
Handle<FixedArray> arguments = factory->NewFixedArray(2, TENURED);
Handle<FixedArray> caller = factory->NewFixedArray(2, TENURED);
@ -623,7 +627,7 @@ void Genesis::CreateStrictModeFunctionMaps(Handle<JSFunction> empty) {
static void AddToWeakGlobalContextList(Context* context) {
ASSERT(context->IsGlobalContext());
Heap* heap = Isolate::Current()->heap();
Heap* heap = context->GetIsolate()->heap();
#ifdef DEBUG
{ // NOLINT
ASSERT(context->get(Context::NEXT_CONTEXT_LINK)->IsUndefined());
@ -641,15 +645,14 @@ static void AddToWeakGlobalContextList(Context* context) {
void Genesis::CreateRoots() {
Isolate* isolate = Isolate::Current();
// Allocate the global context FixedArray first and then patch the
// closure and extension object later (we need the empty function
// and the global object, but in order to create those, we need the
// global context).
global_context_ = Handle<Context>::cast(isolate->global_handles()->Create(
*isolate->factory()->NewGlobalContext()));
global_context_ = Handle<Context>::cast(isolate()->global_handles()->Create(
*factory()->NewGlobalContext()));
AddToWeakGlobalContextList(*global_context_);
isolate->set_context(*global_context());
isolate()->set_context(*global_context());
// Allocate the message listeners object.
{
@ -692,16 +695,12 @@ Handle<JSGlobalProxy> Genesis::CreateNewGlobals(
}
}
Isolate* isolate = Isolate::Current();
Factory* factory = isolate->factory();
Heap* heap = isolate->heap();
if (js_global_template.is_null()) {
Handle<String> name = Handle<String>(heap->empty_symbol());
Handle<Code> code = Handle<Code>(isolate->builtins()->builtin(
Handle<String> name = Handle<String>(heap()->empty_symbol());
Handle<Code> code = Handle<Code>(isolate()->builtins()->builtin(
Builtins::kIllegal));
js_global_function =
factory->NewFunction(name, JS_GLOBAL_OBJECT_TYPE,
factory()->NewFunction(name, JS_GLOBAL_OBJECT_TYPE,
JSGlobalObject::kSize, code, true);
// Change the constructor property of the prototype of the
// hidden global function to refer to the Object function.
@ -710,20 +709,20 @@ Handle<JSGlobalProxy> Genesis::CreateNewGlobals(
JSObject::cast(js_global_function->instance_prototype()));
SetLocalPropertyNoThrow(
prototype,
factory->constructor_symbol(),
isolate->object_function(),
factory()->constructor_symbol(),
isolate()->object_function(),
NONE);
} else {
Handle<FunctionTemplateInfo> js_global_constructor(
FunctionTemplateInfo::cast(js_global_template->constructor()));
js_global_function =
factory->CreateApiFunction(js_global_constructor,
factory->InnerGlobalObject);
factory()->CreateApiFunction(js_global_constructor,
factory()->InnerGlobalObject);
}
js_global_function->initial_map()->set_is_hidden_prototype();
Handle<GlobalObject> inner_global =
factory->NewGlobalObject(js_global_function);
factory()->NewGlobalObject(js_global_function);
if (inner_global_out != NULL) {
*inner_global_out = inner_global;
}
@ -731,11 +730,11 @@ Handle<JSGlobalProxy> Genesis::CreateNewGlobals(
// Step 2: create or re-initialize the global proxy object.
Handle<JSFunction> global_proxy_function;
if (global_template.IsEmpty()) {
Handle<String> name = Handle<String>(heap->empty_symbol());
Handle<Code> code = Handle<Code>(isolate->builtins()->builtin(
Handle<String> name = Handle<String>(heap()->empty_symbol());
Handle<Code> code = Handle<Code>(isolate()->builtins()->builtin(
Builtins::kIllegal));
global_proxy_function =
factory->NewFunction(name, JS_GLOBAL_PROXY_TYPE,
factory()->NewFunction(name, JS_GLOBAL_PROXY_TYPE,
JSGlobalProxy::kSize, code, true);
} else {
Handle<ObjectTemplateInfo> data =
@ -743,11 +742,11 @@ Handle<JSGlobalProxy> Genesis::CreateNewGlobals(
Handle<FunctionTemplateInfo> global_constructor(
FunctionTemplateInfo::cast(data->constructor()));
global_proxy_function =
factory->CreateApiFunction(global_constructor,
factory->OuterGlobalObject);
factory()->CreateApiFunction(global_constructor,
factory()->OuterGlobalObject);
}
Handle<String> global_name = factory->LookupAsciiSymbol("global");
Handle<String> global_name = factory()->LookupAsciiSymbol("global");
global_proxy_function->shared()->set_instance_class_name(*global_name);
global_proxy_function->initial_map()->set_is_access_check_needed(true);
@ -761,7 +760,7 @@ Handle<JSGlobalProxy> Genesis::CreateNewGlobals(
Handle<JSGlobalProxy>::cast(global_object));
} else {
return Handle<JSGlobalProxy>::cast(
factory->NewJSObject(global_proxy_function, TENURED));
factory()->NewJSObject(global_proxy_function, TENURED));
}
}
@ -786,7 +785,7 @@ void Genesis::HookUpInnerGlobal(Handle<GlobalObject> inner_global) {
static const PropertyAttributes attributes =
static_cast<PropertyAttributes>(READ_ONLY | DONT_DELETE);
ForceSetProperty(builtins_global,
FACTORY->LookupAsciiSymbol("global"),
factory()->LookupAsciiSymbol("global"),
inner_global,
attributes);
// Setup the reference from the global object to the builtins object.
@ -814,7 +813,7 @@ void Genesis::InitializeGlobal(Handle<GlobalObject> inner_global,
// object reinitialization.
global_context()->set_security_token(*inner_global);
Isolate* isolate = Isolate::Current();
Isolate* isolate = inner_global->GetIsolate();
Factory* factory = isolate->factory();
Heap* heap = isolate->heap();
@ -1164,17 +1163,17 @@ void Genesis::InitializeGlobal(Handle<GlobalObject> inner_global,
}
bool Genesis::CompileBuiltin(int index) {
bool Genesis::CompileBuiltin(Isolate* isolate, int index) {
Vector<const char> name = Natives::GetScriptName(index);
Handle<String> source_code =
Isolate::Current()->bootstrapper()->NativesSourceLookup(index);
isolate->bootstrapper()->NativesSourceLookup(index);
return CompileNative(name, source_code);
}
bool Genesis::CompileNative(Vector<const char> name, Handle<String> source) {
HandleScope scope;
Isolate* isolate = Isolate::Current();
Isolate* isolate = source->GetIsolate();
#ifdef ENABLE_DEBUGGER_SUPPORT
isolate->debugger()->set_compiling_natives(true);
#endif
@ -1199,7 +1198,7 @@ bool Genesis::CompileScriptCached(Vector<const char> name,
v8::Extension* extension,
Handle<Context> top_context,
bool use_runtime_context) {
Factory* factory = Isolate::Current()->factory();
Factory* factory = source->GetIsolate()->factory();
HandleScope scope;
Handle<SharedFunctionInfo> function_info;
@ -1247,14 +1246,13 @@ bool Genesis::CompileScriptCached(Vector<const char> name,
#define INSTALL_NATIVE(Type, name, var) \
Handle<String> var##_name = factory->LookupAsciiSymbol(name); \
Handle<String> var##_name = factory()->LookupAsciiSymbol(name); \
Object* var##_native = \
global_context()->builtins()->GetPropertyNoExceptionThrown(*var##_name); \
global_context()->set_##var(Type::cast(var##_native));
void Genesis::InstallNativeFunctions() {
Factory* factory = Isolate::Current()->factory();
HandleScope scope;
INSTALL_NATIVE(JSFunction, "CreateDate", create_date_fun);
INSTALL_NATIVE(JSFunction, "ToNumber", to_number_fun);
@ -1277,25 +1275,23 @@ void Genesis::InstallNativeFunctions() {
bool Genesis::InstallNatives() {
HandleScope scope;
Isolate* isolate = Isolate::Current();
Factory* factory = isolate->factory();
Heap* heap = isolate->heap();
// Create a function for the builtins object. Allocate space for the
// JavaScript builtins, a reference to the builtins object
// (itself) and a reference to the global_context directly in the object.
Handle<Code> code = Handle<Code>(
isolate->builtins()->builtin(Builtins::kIllegal));
isolate()->builtins()->builtin(Builtins::kIllegal));
Handle<JSFunction> builtins_fun =
factory->NewFunction(factory->empty_symbol(), JS_BUILTINS_OBJECT_TYPE,
factory()->NewFunction(factory()->empty_symbol(),
JS_BUILTINS_OBJECT_TYPE,
JSBuiltinsObject::kSize, code, true);
Handle<String> name = factory->LookupAsciiSymbol("builtins");
Handle<String> name = factory()->LookupAsciiSymbol("builtins");
builtins_fun->shared()->set_instance_class_name(*name);
// Allocate the builtins object.
Handle<JSBuiltinsObject> builtins =
Handle<JSBuiltinsObject>::cast(factory->NewGlobalObject(builtins_fun));
Handle<JSBuiltinsObject>::cast(factory()->NewGlobalObject(builtins_fun));
builtins->set_builtins(*builtins);
builtins->set_global_context(*global_context());
builtins->set_global_receiver(*builtins);
@ -1306,7 +1302,7 @@ bool Genesis::InstallNatives() {
// global object.
static const PropertyAttributes attributes =
static_cast<PropertyAttributes>(READ_ONLY | DONT_DELETE);
Handle<String> global_symbol = factory->LookupAsciiSymbol("global");
Handle<String> global_symbol = factory()->LookupAsciiSymbol("global");
Handle<Object> global_obj(global_context()->global());
SetLocalPropertyNoThrow(builtins, global_symbol, global_obj, attributes);
@ -1315,12 +1311,13 @@ bool Genesis::InstallNatives() {
// Create a bridge function that has context in the global context.
Handle<JSFunction> bridge =
factory->NewFunction(factory->empty_symbol(), factory->undefined_value());
ASSERT(bridge->context() == *isolate->global_context());
factory()->NewFunction(factory()->empty_symbol(),
factory()->undefined_value());
ASSERT(bridge->context() == *isolate()->global_context());
// Allocate the builtins context.
Handle<Context> context =
factory->NewFunctionContext(Context::MIN_CONTEXT_SLOTS, bridge);
factory()->NewFunctionContext(Context::MIN_CONTEXT_SLOTS, bridge);
context->set_global(*builtins); // override builtins global object
global_context()->set_runtime_context(*context);
@ -1329,113 +1326,113 @@ bool Genesis::InstallNatives() {
// Builtin functions for Script.
Handle<JSFunction> script_fun =
InstallFunction(builtins, "Script", JS_VALUE_TYPE, JSValue::kSize,
isolate->initial_object_prototype(),
isolate()->initial_object_prototype(),
Builtins::kIllegal, false);
Handle<JSObject> prototype =
factory->NewJSObject(isolate->object_function(), TENURED);
factory()->NewJSObject(isolate()->object_function(), TENURED);
SetPrototype(script_fun, prototype);
global_context()->set_script_function(*script_fun);
// Add 'source' and 'data' property to scripts.
PropertyAttributes common_attributes =
static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
Handle<Proxy> proxy_source = factory->NewProxy(&Accessors::ScriptSource);
Handle<Proxy> proxy_source = factory()->NewProxy(&Accessors::ScriptSource);
Handle<DescriptorArray> script_descriptors =
factory->CopyAppendProxyDescriptor(
factory->empty_descriptor_array(),
factory->LookupAsciiSymbol("source"),
factory()->CopyAppendProxyDescriptor(
factory()->empty_descriptor_array(),
factory()->LookupAsciiSymbol("source"),
proxy_source,
common_attributes);
Handle<Proxy> proxy_name = factory->NewProxy(&Accessors::ScriptName);
Handle<Proxy> proxy_name = factory()->NewProxy(&Accessors::ScriptName);
script_descriptors =
factory->CopyAppendProxyDescriptor(
factory()->CopyAppendProxyDescriptor(
script_descriptors,
factory->LookupAsciiSymbol("name"),
factory()->LookupAsciiSymbol("name"),
proxy_name,
common_attributes);
Handle<Proxy> proxy_id = factory->NewProxy(&Accessors::ScriptId);
Handle<Proxy> proxy_id = factory()->NewProxy(&Accessors::ScriptId);
script_descriptors =
factory->CopyAppendProxyDescriptor(
factory()->CopyAppendProxyDescriptor(
script_descriptors,
factory->LookupAsciiSymbol("id"),
factory()->LookupAsciiSymbol("id"),
proxy_id,
common_attributes);
Handle<Proxy> proxy_line_offset =
factory->NewProxy(&Accessors::ScriptLineOffset);
factory()->NewProxy(&Accessors::ScriptLineOffset);
script_descriptors =
factory->CopyAppendProxyDescriptor(
factory()->CopyAppendProxyDescriptor(
script_descriptors,
factory->LookupAsciiSymbol("line_offset"),
factory()->LookupAsciiSymbol("line_offset"),
proxy_line_offset,
common_attributes);
Handle<Proxy> proxy_column_offset =
factory->NewProxy(&Accessors::ScriptColumnOffset);
factory()->NewProxy(&Accessors::ScriptColumnOffset);
script_descriptors =
factory->CopyAppendProxyDescriptor(
factory()->CopyAppendProxyDescriptor(
script_descriptors,
factory->LookupAsciiSymbol("column_offset"),
factory()->LookupAsciiSymbol("column_offset"),
proxy_column_offset,
common_attributes);
Handle<Proxy> proxy_data = factory->NewProxy(&Accessors::ScriptData);
Handle<Proxy> proxy_data = factory()->NewProxy(&Accessors::ScriptData);
script_descriptors =
factory->CopyAppendProxyDescriptor(
factory()->CopyAppendProxyDescriptor(
script_descriptors,
factory->LookupAsciiSymbol("data"),
factory()->LookupAsciiSymbol("data"),
proxy_data,
common_attributes);
Handle<Proxy> proxy_type = factory->NewProxy(&Accessors::ScriptType);
Handle<Proxy> proxy_type = factory()->NewProxy(&Accessors::ScriptType);
script_descriptors =
factory->CopyAppendProxyDescriptor(
factory()->CopyAppendProxyDescriptor(
script_descriptors,
factory->LookupAsciiSymbol("type"),
factory()->LookupAsciiSymbol("type"),
proxy_type,
common_attributes);
Handle<Proxy> proxy_compilation_type =
factory->NewProxy(&Accessors::ScriptCompilationType);
factory()->NewProxy(&Accessors::ScriptCompilationType);
script_descriptors =
factory->CopyAppendProxyDescriptor(
factory()->CopyAppendProxyDescriptor(
script_descriptors,
factory->LookupAsciiSymbol("compilation_type"),
factory()->LookupAsciiSymbol("compilation_type"),
proxy_compilation_type,
common_attributes);
Handle<Proxy> proxy_line_ends =
factory->NewProxy(&Accessors::ScriptLineEnds);
factory()->NewProxy(&Accessors::ScriptLineEnds);
script_descriptors =
factory->CopyAppendProxyDescriptor(
factory()->CopyAppendProxyDescriptor(
script_descriptors,
factory->LookupAsciiSymbol("line_ends"),
factory()->LookupAsciiSymbol("line_ends"),
proxy_line_ends,
common_attributes);
Handle<Proxy> proxy_context_data =
factory->NewProxy(&Accessors::ScriptContextData);
factory()->NewProxy(&Accessors::ScriptContextData);
script_descriptors =
factory->CopyAppendProxyDescriptor(
factory()->CopyAppendProxyDescriptor(
script_descriptors,
factory->LookupAsciiSymbol("context_data"),
factory()->LookupAsciiSymbol("context_data"),
proxy_context_data,
common_attributes);
Handle<Proxy> proxy_eval_from_script =
factory->NewProxy(&Accessors::ScriptEvalFromScript);
factory()->NewProxy(&Accessors::ScriptEvalFromScript);
script_descriptors =
factory->CopyAppendProxyDescriptor(
factory()->CopyAppendProxyDescriptor(
script_descriptors,
factory->LookupAsciiSymbol("eval_from_script"),
factory()->LookupAsciiSymbol("eval_from_script"),
proxy_eval_from_script,
common_attributes);
Handle<Proxy> proxy_eval_from_script_position =
factory->NewProxy(&Accessors::ScriptEvalFromScriptPosition);
factory()->NewProxy(&Accessors::ScriptEvalFromScriptPosition);
script_descriptors =
factory->CopyAppendProxyDescriptor(
factory()->CopyAppendProxyDescriptor(
script_descriptors,
factory->LookupAsciiSymbol("eval_from_script_position"),
factory()->LookupAsciiSymbol("eval_from_script_position"),
proxy_eval_from_script_position,
common_attributes);
Handle<Proxy> proxy_eval_from_function_name =
factory->NewProxy(&Accessors::ScriptEvalFromFunctionName);
factory()->NewProxy(&Accessors::ScriptEvalFromFunctionName);
script_descriptors =
factory->CopyAppendProxyDescriptor(
factory()->CopyAppendProxyDescriptor(
script_descriptors,
factory->LookupAsciiSymbol("eval_from_function_name"),
factory()->LookupAsciiSymbol("eval_from_function_name"),
proxy_eval_from_function_name,
common_attributes);
@ -1443,9 +1440,9 @@ bool Genesis::InstallNatives() {
script_map->set_instance_descriptors(*script_descriptors);
// Allocate the empty script.
Handle<Script> script = factory->NewScript(factory->empty_string());
Handle<Script> script = factory()->NewScript(factory()->empty_string());
script->set_type(Smi::FromInt(Script::TYPE_NATIVE));
heap->public_set_empty_script(*script);
heap()->public_set_empty_script(*script);
}
{
// Builtin function for OpaqueReference -- a JSValue-based object,
@ -1454,10 +1451,10 @@ bool Genesis::InstallNatives() {
Handle<JSFunction> opaque_reference_fun =
InstallFunction(builtins, "OpaqueReference", JS_VALUE_TYPE,
JSValue::kSize,
isolate->initial_object_prototype(),
isolate()->initial_object_prototype(),
Builtins::kIllegal, false);
Handle<JSObject> prototype =
factory->NewJSObject(isolate->object_function(), TENURED);
factory()->NewJSObject(isolate()->object_function(), TENURED);
SetPrototype(opaque_reference_fun, prototype);
global_context()->set_opaque_reference_function(*opaque_reference_fun);
}
@ -1476,23 +1473,23 @@ bool Genesis::InstallNatives() {
"InternalArray",
JS_ARRAY_TYPE,
JSArray::kSize,
isolate->initial_object_prototype(),
isolate()->initial_object_prototype(),
Builtins::kArrayCode,
true);
Handle<JSObject> prototype =
factory->NewJSObject(isolate->object_function(), TENURED);
factory()->NewJSObject(isolate()->object_function(), TENURED);
SetPrototype(array_function, prototype);
array_function->shared()->set_construct_stub(
isolate->builtins()->builtin(Builtins::kArrayConstructCode));
isolate()->builtins()->builtin(Builtins::kArrayConstructCode));
array_function->shared()->DontAdaptArguments();
// Make "length" magic on instances.
Handle<DescriptorArray> array_descriptors =
factory->CopyAppendProxyDescriptor(
factory->empty_descriptor_array(),
factory->length_symbol(),
factory->NewProxy(&Accessors::ArrayLength),
factory()->CopyAppendProxyDescriptor(
factory()->empty_descriptor_array(),
factory()->length_symbol(),
factory()->NewProxy(&Accessors::ArrayLength),
static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE));
array_function->initial_map()->set_instance_descriptors(
@ -1509,7 +1506,7 @@ bool Genesis::InstallNatives() {
i < Natives::GetBuiltinsCount();
i++) {
Vector<const char> name = Natives::GetScriptName(i);
if (!CompileBuiltin(i)) return false;
if (!CompileBuiltin(isolate(), i)) return false;
// TODO(ager): We really only need to install the JS builtin
// functions on the builtins object after compiling and running
// runtime.js.
@ -1529,9 +1526,9 @@ bool Genesis::InstallNatives() {
InstallBuiltinFunctionIds();
// Install Function.prototype.call and apply.
{ Handle<String> key = factory->function_class_symbol();
{ Handle<String> key = factory()->function_class_symbol();
Handle<JSFunction> function =
Handle<JSFunction>::cast(GetProperty(isolate->global(), key));
Handle<JSFunction>::cast(GetProperty(isolate()->global(), key));
Handle<JSObject> proto =
Handle<JSObject>(JSObject::cast(function->instance_prototype()));
@ -1573,7 +1570,7 @@ bool Genesis::InstallNatives() {
// Add initial map.
Handle<Map> initial_map =
factory->NewMap(JS_ARRAY_TYPE, JSRegExpResult::kSize);
factory()->NewMap(JS_ARRAY_TYPE, JSRegExpResult::kSize);
initial_map->set_constructor(*array_constructor);
// Set prototype on map.
@ -1587,13 +1584,13 @@ bool Genesis::InstallNatives() {
ASSERT_EQ(1, array_descriptors->number_of_descriptors());
Handle<DescriptorArray> reresult_descriptors =
factory->NewDescriptorArray(3);
factory()->NewDescriptorArray(3);
reresult_descriptors->CopyFrom(0, *array_descriptors, 0);
int enum_index = 0;
{
FieldDescriptor index_field(heap->index_symbol(),
FieldDescriptor index_field(heap()->index_symbol(),
JSRegExpResult::kIndexIndex,
NONE,
enum_index++);
@ -1601,7 +1598,7 @@ bool Genesis::InstallNatives() {
}
{
FieldDescriptor input_field(heap->input_symbol(),
FieldDescriptor input_field(heap()->input_symbol(),
JSRegExpResult::kInputIndex,
NONE,
enum_index++);
@ -1629,7 +1626,7 @@ bool Genesis::InstallNatives() {
static Handle<JSObject> ResolveBuiltinIdHolder(
Handle<Context> global_context,
const char* holder_expr) {
Factory* factory = Isolate::Current()->factory();
Factory* factory = global_context->GetIsolate()->factory();
Handle<GlobalObject> global(global_context->global());
const char* period_pos = strchr(holder_expr, '.');
if (period_pos == NULL) {
@ -1648,7 +1645,8 @@ static Handle<JSObject> ResolveBuiltinIdHolder(
static void InstallBuiltinFunctionId(Handle<JSObject> holder,
const char* function_name,
BuiltinFunctionId id) {
Handle<String> name = FACTORY->LookupAsciiSymbol(function_name);
Factory* factory = holder->GetIsolate()->factory();
Handle<String> name = factory->LookupAsciiSymbol(function_name);
Object* function_object = holder->GetProperty(*name)->ToObjectUnchecked();
Handle<JSFunction> function(JSFunction::cast(function_object));
function->shared()->set_function_data(Smi::FromInt(id));
@ -1675,13 +1673,14 @@ void Genesis::InstallBuiltinFunctionIds() {
F(16, global_context()->regexp_function())
static FixedArray* CreateCache(int size, JSFunction* factory) {
static FixedArray* CreateCache(int size, JSFunction* factory_function) {
Factory* factory = factory_function->GetIsolate()->factory();
// Caches are supposed to live for a long time, allocate in old space.
int array_size = JSFunctionResultCache::kEntriesIndex + 2 * size;
// Cannot use cast as object is not fully initialized yet.
JSFunctionResultCache* cache = reinterpret_cast<JSFunctionResultCache*>(
*FACTORY->NewFixedArrayWithHoles(array_size, TENURED));
cache->set(JSFunctionResultCache::kFactoryIndex, factory);
*factory->NewFixedArrayWithHoles(array_size, TENURED));
cache->set(JSFunctionResultCache::kFactoryIndex, factory_function);
cache->MakeZeroSize();
return cache;
}
@ -1720,7 +1719,7 @@ void Genesis::InitializeNormalizedMapCaches() {
bool Bootstrapper::InstallExtensions(Handle<Context> global_context,
v8::ExtensionConfiguration* extensions) {
Isolate* isolate = Isolate::Current();
Isolate* isolate = global_context->GetIsolate();
BootstrapperActive active;
SaveContext saved_context(isolate);
isolate->set_context(*global_context);
@ -1731,7 +1730,7 @@ bool Bootstrapper::InstallExtensions(Handle<Context> global_context,
void Genesis::InstallSpecialObjects(Handle<Context> global_context) {
Factory* factory = Isolate::Current()->factory();
Factory* factory = global_context->GetIsolate()->factory();
HandleScope scope;
Handle<JSGlobalObject> js_global(
JSGlobalObject::cast(global_context->global()));
@ -1867,9 +1866,10 @@ bool Genesis::InstallExtension(v8::RegisteredExtension* current) {
bool Genesis::InstallJSBuiltins(Handle<JSBuiltinsObject> builtins) {
HandleScope scope;
Factory* factory = builtins->GetIsolate()->factory();
for (int i = 0; i < Builtins::NumberOfJavaScriptBuiltins(); i++) {
Builtins::JavaScript id = static_cast<Builtins::JavaScript>(i);
Handle<String> name = FACTORY->LookupAsciiSymbol(Builtins::GetName(id));
Handle<String> name = factory->LookupAsciiSymbol(Builtins::GetName(id));
Object* function_object = builtins->GetPropertyNoExceptionThrown(*name);
Handle<JSFunction> function
= Handle<JSFunction>(JSFunction::cast(function_object));
@ -1918,13 +1918,12 @@ bool Genesis::ConfigureApiObject(Handle<JSObject> object,
ASSERT(object->IsInstanceOf(
FunctionTemplateInfo::cast(object_template->constructor())));
Isolate* isolate = Isolate::Current();
bool pending_exception = false;
Handle<JSObject> obj =
Execution::InstantiateObject(object_template, &pending_exception);
if (pending_exception) {
ASSERT(isolate->has_pending_exception());
isolate->clear_pending_exception();
ASSERT(isolate()->has_pending_exception());
isolate()->clear_pending_exception();
return false;
}
TransferObject(obj, object);
@ -2023,6 +2022,7 @@ void Genesis::TransferIndexedProperties(Handle<JSObject> from,
void Genesis::TransferObject(Handle<JSObject> from, Handle<JSObject> to) {
HandleScope outer;
Factory* factory = from->GetIsolate()->factory();
ASSERT(!from->IsJSArray());
ASSERT(!to->IsJSArray());
@ -2032,7 +2032,7 @@ void Genesis::TransferObject(Handle<JSObject> from, Handle<JSObject> to) {
// Transfer the prototype (new map is needed).
Handle<Map> old_to_map = Handle<Map>(to->map());
Handle<Map> new_to_map = FACTORY->CopyMapDropTransitions(old_to_map);
Handle<Map> new_to_map = factory->CopyMapDropTransitions(old_to_map);
new_to_map->set_prototype(from->map()->prototype());
to->set_map(*new_to_map);
}
@ -2053,10 +2053,10 @@ void Genesis::MakeFunctionInstancePrototypeWritable() {
}
Genesis::Genesis(Handle<Object> global_object,
Genesis::Genesis(Isolate* isolate,
Handle<Object> global_object,
v8::Handle<v8::ObjectTemplate> global_template,
v8::ExtensionConfiguration* extensions) {
Isolate* isolate = Isolate::Current();
v8::ExtensionConfiguration* extensions) : isolate_(isolate) {
result_ = Handle<Context>::null();
// If V8 isn't running and cannot be initialized, just return.
if (!V8::IsRunning() && !V8::Initialize(NULL)) return;
@ -2086,7 +2086,7 @@ Genesis::Genesis(Handle<Object> global_object,
} else {
// We get here if there was no context snapshot.
CreateRoots();
Handle<JSFunction> empty_function = CreateEmptyFunction();
Handle<JSFunction> empty_function = CreateEmptyFunction(isolate);
CreateStrictModeFunctionMaps(empty_function);
Handle<GlobalObject> inner_global;
Handle<JSGlobalProxy> global_proxy =

1
src/bootstrapper.h
View File

@ -93,6 +93,7 @@ class Bootstrapper {
// Creates a JavaScript Global Context with initial object graph.
// The returned value is a global handle casted to V8Environment*.
Handle<Context> CreateEnvironment(
Isolate* isolate,
Handle<Object> global_object,
v8::Handle<v8::ObjectTemplate> global_template,
v8::ExtensionConfiguration* extensions);

1
src/debug.cc
View File

@ -843,6 +843,7 @@ bool Debug::Load() {
HandleScope scope(isolate_);
Handle<Context> context =
isolate_->bootstrapper()->CreateEnvironment(
isolate_,
Handle<Object>::null(),
v8::Handle<ObjectTemplate>(),
NULL);

10
src/ia32/code-stubs-ia32.cc
View File

@ -1120,23 +1120,25 @@ void TypeRecordingBinaryOpStub::GenerateOddballStub(MacroAssembler* masm) {
GenerateAddStrings(masm);
}
Factory* factory = masm->isolate()->factory();
// Convert odd ball arguments to numbers.
NearLabel check, done;
__ cmp(edx, FACTORY->undefined_value());
__ cmp(edx, factory->undefined_value());
__ j(not_equal, &check);
if (Token::IsBitOp(op_)) {
__ xor_(edx, Operand(edx));
} else {
__ mov(edx, Immediate(FACTORY->nan_value()));
__ mov(edx, Immediate(factory->nan_value()));
}
__ jmp(&done);
__ bind(&check);
__ cmp(eax, FACTORY->undefined_value());
__ cmp(eax, factory->undefined_value());
__ j(not_equal, &done);
if (Token::IsBitOp(op_)) {
__ xor_(eax, Operand(eax));
} else {
__ mov(eax, Immediate(FACTORY->nan_value()));
__ mov(eax, Immediate(factory->nan_value()));
}
__ bind(&done);

12
src/x64/code-stubs-x64.cc
View File

@ -2330,9 +2330,10 @@ void NumberToStringStub::GenerateLookupNumberStringCache(MacroAssembler* masm,
// Heap::GetNumberStringCache.
Label is_smi;
Label load_result_from_cache;
Factory* factory = masm->isolate()->factory();
if (!object_is_smi) {
__ JumpIfSmi(object, &is_smi);
__ CheckMap(object, FACTORY->heap_number_map(), not_found, true);
__ CheckMap(object, factory->heap_number_map(), not_found, true);
STATIC_ASSERT(8 == kDoubleSize);
__ movl(scratch, FieldOperand(object, HeapNumber::kValueOffset + 4));
@ -2419,6 +2420,7 @@ void CompareStub::Generate(MacroAssembler* masm) {
ASSERT(lhs_.is(no_reg) && rhs_.is(no_reg));
Label check_unequal_objects, done;
Factory* factory = masm->isolate()->factory();
// Compare two smis if required.
if (include_smi_compare_) {
@ -2466,7 +2468,6 @@ void CompareStub::Generate(MacroAssembler* masm) {
// Note: if cc_ != equal, never_nan_nan_ is not used.
// We cannot set rax to EQUAL until just before return because
// rax must be unchanged on jump to not_identical.
if (never_nan_nan_ && (cc_ == equal)) {
__ Set(rax, EQUAL);
__ ret(0);
@ -2474,7 +2475,7 @@ void CompareStub::Generate(MacroAssembler* masm) {
NearLabel heap_number;
// If it's not a heap number, then return equal for (in)equality operator.
__ Cmp(FieldOperand(rdx, HeapObject::kMapOffset),
FACTORY->heap_number_map());
factory->heap_number_map());
__ j(equal, &heap_number);
if (cc_ != equal) {
// Call runtime on identical JSObjects. Otherwise return equal.
@ -2519,7 +2520,7 @@ void CompareStub::Generate(MacroAssembler* masm) {
// Check if the non-smi operand is a heap number.
__ Cmp(FieldOperand(rbx, HeapObject::kMapOffset),
FACTORY->heap_number_map());
factory->heap_number_map());
// If heap number, handle it in the slow case.
__ j(equal, &slow);
// Return non-equal. ebx (the lower half of rbx) is not zero.
@ -3450,10 +3451,11 @@ void StringCharCodeAtGenerator::GenerateSlow(
MacroAssembler* masm, const RuntimeCallHelper& call_helper) {
__ Abort("Unexpected fallthrough to CharCodeAt slow case");
Factory* factory = masm->isolate()->factory();
// Index is not a smi.
__ bind(&index_not_smi_);
// If index is a heap number, try converting it to an integer.
__ CheckMap(index_, FACTORY->heap_number_map(), index_not_number_, true);
__ CheckMap(index_, factory->heap_number_map(), index_not_number_, true);
call_helper.BeforeCall(masm);
__ push(object_);
__ push(index_);

13
src/x64/macro-assembler-x64.cc
View File

@ -650,6 +650,7 @@ MaybeObject* MacroAssembler::TryCallApiFunctionAndReturn(
Label leave_exit_frame;
Label write_back;
Factory* factory = isolate()->factory();
ExternalReference next_address =
ExternalReference::handle_scope_next_address();
const int kNextOffset = 0;
@ -697,7 +698,7 @@ MaybeObject* MacroAssembler::TryCallApiFunctionAndReturn(
// Check if the function scheduled an exception.
movq(rsi, scheduled_exception_address);
Cmp(Operand(rsi, 0), FACTORY->the_hole_value());
Cmp(Operand(rsi, 0), factory->the_hole_value());
j(not_equal, &promote_scheduled_exception);
LeaveApiExitFrame();
@ -712,7 +713,7 @@ MaybeObject* MacroAssembler::TryCallApiFunctionAndReturn(
bind(&empty_result);
// It was zero; the result is undefined.
Move(rax, FACTORY->undefined_value());
Move(rax, factory->undefined_value());
jmp(&prologue);
// HandleScope limit has changed. Delete allocated extensions.
@ -1895,7 +1896,7 @@ void MacroAssembler::AbortIfNotNumber(Register object) {
Condition is_smi = CheckSmi(object);
j(is_smi, &ok);
Cmp(FieldOperand(object, HeapObject::kMapOffset),
FACTORY->heap_number_map());
isolate()->factory()->heap_number_map());
Assert(equal, "Operand not a number");
bind(&ok);
}
@ -2152,7 +2153,7 @@ void MacroAssembler::EnterFrame(StackFrame::Type type) {
push(kScratchRegister);
if (emit_debug_code()) {
movq(kScratchRegister,
FACTORY->undefined_value(),
isolate()->factory()->undefined_value(),
RelocInfo::EMBEDDED_OBJECT);
cmpq(Operand(rsp, 0), kScratchRegister);
Check(not_equal, "code object not properly patched");
@ -2320,7 +2321,7 @@ void MacroAssembler::CheckAccessGlobalProxy(Register holder_reg,
// Check the context is a global context.
if (emit_debug_code()) {
Cmp(FieldOperand(scratch, HeapObject::kMapOffset),
FACTORY->global_context_map());
isolate()->factory()->global_context_map());
Check(equal, "JSGlobalObject::global_context should be a global context.");
}
@ -2822,7 +2823,7 @@ void MacroAssembler::LoadGlobalFunctionInitialMap(Register function,
movq(map, FieldOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
if (emit_debug_code()) {
Label ok, fail;
CheckMap(map, FACTORY->meta_map(), &fail, false);
CheckMap(map, isolate()->factory()->meta_map(), &fail, false);
jmp(&ok);
bind(&fail);
Abort("Global functions must have initial map");