Skip to content

V
V8
Commit 80e3843d authored by ulan@chromium.org's avatar ulan@chromium.org
Browse files
Options

Handlify upper layers of StoreIC based on 8337008. 

BUG=
TEST=

Review URL: http://codereview.chromium.org/8341008

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@9692 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
parent 8b181d4d
Hide whitespace changes
Inline Side-by-side
Showing with 177 additions and 166 deletions
src/ic.cc
View file @ 80e3843d
...@@ -1371,17 +1371,17 @@ static bool StoreICableLookup(LookupResult* lookup) { ...@@ -1371,17 +1371,17 @@ static bool StoreICableLookup(LookupResult* lookup) {
} }
static bool LookupForWrite(JSObject* receiver, static bool LookupForWrite(Handle<JSObject> receiver,
String* name, Handle<String> name,
LookupResult* lookup) { LookupResult* lookup) {
receiver->LocalLookup(name, lookup); receiver->LocalLookup(*name, lookup);
if (!StoreICableLookup(lookup)) { if (!StoreICableLookup(lookup)) {
return false; return false;
} }
if (lookup->type() == INTERCEPTOR && if (lookup->type() == INTERCEPTOR &&
receiver->GetNamedInterceptor()->setter()->IsUndefined()) { receiver->GetNamedInterceptor()->setter()->IsUndefined()) {
receiver->LocalLookupRealNamedProperty(name, lookup); receiver->LocalLookupRealNamedProperty(*name, lookup);
return StoreICableLookup(lookup); return StoreICableLookup(lookup);
} }
...@@ -1422,30 +1422,30 @@ MaybeObject* StoreIC::Store(State state, ...@@ -1422,30 +1422,30 @@ MaybeObject* StoreIC::Store(State state,
// Check if the given name is an array index. // Check if the given name is an array index.
uint32_t index; uint32_t index;
if (name->AsArrayIndex(&index)) { if (name->AsArrayIndex(&index)) {
HandleScope scope(isolate());
Handle<Object> result = SetElement(receiver, index, value, strict_mode); Handle<Object> result = SetElement(receiver, index, value, strict_mode);
if (result.is_null()) return Failure::Exception(); RETURN_IF_EMPTY_HANDLE(isolate(), result);
return *value; return *value;
} }
// Use specialized code for setting the length of arrays. // Use specialized code for setting the length of arrays.
if (receiver->IsJSArray() if (receiver->IsJSArray()
&& name->Equals(isolate()->heap()->length_symbol()) && name->Equals(isolate()->heap()->length_symbol())
&& JSArray::cast(*receiver)->AllowsSetElementsLength()) { && Handle<JSArray>::cast(receiver)->AllowsSetElementsLength()) {
#ifdef DEBUG #ifdef DEBUG
if (FLAG_trace_ic) PrintF("[StoreIC : +#length /array]\n"); if (FLAG_trace_ic) PrintF("[StoreIC : +#length /array]\n");
#endif #endif
Builtins::Name target = (strict_mode == kStrictMode) Handle<Code> stub = (strict_mode == kStrictMode)
? Builtins::kStoreIC_ArrayLength_Strict ? isolate()->builtins()->StoreIC_ArrayLength_Strict()
: Builtins::kStoreIC_ArrayLength; : isolate()->builtins()->StoreIC_ArrayLength();
set_target(isolate()->builtins()->builtin(target)); set_target(*stub);
return receiver->SetProperty(*name, *value, NONE, strict_mode); return receiver->SetProperty(*name, *value, NONE, strict_mode);
} }
// Lookup the property locally in the receiver. // Lookup the property locally in the receiver.
if (FLAG_use_ic && !receiver->IsJSGlobalProxy()) { if (FLAG_use_ic && !receiver->IsJSGlobalProxy()) {
LookupResult lookup(isolate()); LookupResult lookup(isolate());
if (LookupForWrite(*receiver, *name, &lookup)) {
if (LookupForWrite(receiver, name, &lookup)) {
// Generate a stub for this store. // Generate a stub for this store.
UpdateCaches(&lookup, state, strict_mode, receiver, name, value); UpdateCaches(&lookup, state, strict_mode, receiver, name, value);
} else { } else {
...@@ -1462,13 +1462,14 @@ MaybeObject* StoreIC::Store(State state, ...@@ -1462,13 +1462,14 @@ MaybeObject* StoreIC::Store(State state,
} }
if (receiver->IsJSGlobalProxy()) { if (receiver->IsJSGlobalProxy()) {
// TODO(ulan): find out why we patch this site even with --no-use-ic
// Generate a generic stub that goes to the runtime when we see a global // Generate a generic stub that goes to the runtime when we see a global
// proxy as receiver. // proxy as receiver.
Code* stub = (strict_mode == kStrictMode) Handle<Code> stub = (strict_mode == kStrictMode)
? global_proxy_stub_strict() ? global_proxy_stub_strict()
: global_proxy_stub(); : global_proxy_stub();
if (target() != stub) { if (target() != *stub) {
set_target(stub); set_target(*stub);
#ifdef DEBUG #ifdef DEBUG
TraceIC("StoreIC", name, state, target()); TraceIC("StoreIC", name, state, target());
#endif #endif
...@@ -1499,77 +1500,70 @@ void StoreIC::UpdateCaches(LookupResult* lookup, ...@@ -1499,77 +1500,70 @@ void StoreIC::UpdateCaches(LookupResult* lookup,
// Compute the code stub for this store; used for rewriting to // Compute the code stub for this store; used for rewriting to
// monomorphic state and making sure that the code stub is in the // monomorphic state and making sure that the code stub is in the
// stub cache. // stub cache.
MaybeObject* maybe_code = NULL; Handle<Code> code;
Object* code = NULL;
switch (type) { switch (type) {
case FIELD: { case FIELD:
maybe_code = isolate()->stub_cache()->ComputeStoreField( code = isolate()->stub_cache()->ComputeStoreField(name,
*name, *receiver, lookup->GetFieldIndex(), NULL, strict_mode); receiver,
lookup->GetFieldIndex(),
Handle<Map>::null(),
strict_mode);
break; break;
}
case MAP_TRANSITION: { case MAP_TRANSITION: {
if (lookup->GetAttributes() != NONE) return; if (lookup->GetAttributes() != NONE) return;
HandleScope scope(isolate());
ASSERT(type == MAP_TRANSITION); ASSERT(type == MAP_TRANSITION);
Handle<Map> transition(lookup->GetTransitionMap()); Handle<Map> transition(lookup->GetTransitionMap());
int index = transition->PropertyIndexFor(*name); int index = transition->PropertyIndexFor(*name);
maybe_code = isolate()->stub_cache()->ComputeStoreField( code = isolate()->stub_cache()->ComputeStoreField(
*name, *receiver, index, *transition, strict_mode); name, receiver, index, transition, strict_mode);
break; break;
} }
case NORMAL: { case NORMAL:
if (receiver->IsGlobalObject()) { if (receiver->IsGlobalObject()) {
// The stub generated for the global object picks the value directly // The stub generated for the global object picks the value directly
// from the property cell. So the property must be directly on the // from the property cell. So the property must be directly on the
// global object. // global object.
Handle<GlobalObject> global = Handle<GlobalObject>::cast(receiver); Handle<GlobalObject> global = Handle<GlobalObject>::cast(receiver);
JSGlobalPropertyCell* cell = Handle<JSGlobalPropertyCell> cell(global->GetPropertyCell(lookup));
JSGlobalPropertyCell::cast(global->GetPropertyCell(lookup)); code = isolate()->stub_cache()->ComputeStoreGlobal(
maybe_code = isolate()->stub_cache()->ComputeStoreGlobal( name, global, cell, strict_mode);
*name, *global, cell, strict_mode);
} else { } else {
if (lookup->holder() != *receiver) return; if (lookup->holder() != *receiver) return;
maybe_code = isolate()->stub_cache()->ComputeStoreNormal(strict_mode); code = isolate()->stub_cache()->ComputeStoreNormal(strict_mode);
} }
break; break;
}
case CALLBACKS: { case CALLBACKS: {
if (!lookup->GetCallbackObject()->IsAccessorInfo()) return; Handle<Object> callback_object(lookup->GetCallbackObject());
AccessorInfo* callback = AccessorInfo::cast(lookup->GetCallbackObject()); if (!callback_object->IsAccessorInfo()) return;
Handle<AccessorInfo> callback =
Handle<AccessorInfo>::cast(callback_object);
if (v8::ToCData<Address>(callback->setter()) == 0) return; if (v8::ToCData<Address>(callback->setter()) == 0) return;
maybe_code = isolate()->stub_cache()->ComputeStoreCallback( code = isolate()->stub_cache()->ComputeStoreCallback(
*name, *receiver, callback, strict_mode); name, receiver, callback, strict_mode);
break; break;
} }
case INTERCEPTOR: { case INTERCEPTOR:
ASSERT(!receiver->GetNamedInterceptor()->setter()->IsUndefined()); ASSERT(!receiver->GetNamedInterceptor()->setter()->IsUndefined());
maybe_code = isolate()->stub_cache()->ComputeStoreInterceptor( code = isolate()->stub_cache()->ComputeStoreInterceptor(
*name, *receiver, strict_mode); name, receiver, strict_mode);
break; break;
}
default: default:
return; return;
} }
// If we're unable to compute the stub (not enough memory left), we
// simply avoid updating the caches.
if (maybe_code == NULL || !maybe_code->ToObject(&code)) return;
// Patch the call site depending on the state of the cache. // Patch the call site depending on the state of the cache.
if (state == UNINITIALIZED || state == MONOMORPHIC_PROTOTYPE_FAILURE) { if (state == UNINITIALIZED || state == MONOMORPHIC_PROTOTYPE_FAILURE) {
set_target(Code::cast(code)); set_target(*code);
} else if (state == MONOMORPHIC) { } else if (state == MONOMORPHIC) {
// Only move to megamorphic if the target changes. // Only move to megamorphic if the target changes.
if (target() != Code::cast(code)) { if (target() != *code) {
set_target((strict_mode == kStrictMode) set_target((strict_mode == kStrictMode)
? megamorphic_stub_strict() ? megamorphic_stub_strict()
: megamorphic_stub()); : megamorphic_stub());
} }
} else if (state == MEGAMORPHIC) { } else if (state == MEGAMORPHIC) {
// Update the stub cache. // Update the stub cache.
isolate()->stub_cache()->Set(*name, isolate()->stub_cache()->Set(*name, receiver->map(), *code);
receiver->map(),
Code::cast(code));
} }
#ifdef DEBUG #ifdef DEBUG
...@@ -2090,7 +2084,7 @@ RUNTIME_FUNCTION(MaybeObject*, KeyedLoadIC_MissForceGeneric) { ...@@ -2090,7 +2084,7 @@ RUNTIME_FUNCTION(MaybeObject*, KeyedLoadIC_MissForceGeneric) {
// Used from ic-<arch>.cc. // Used from ic-<arch>.cc.
RUNTIME_FUNCTION(MaybeObject*, StoreIC_Miss) { RUNTIME_FUNCTION(MaybeObject*, StoreIC_Miss) {
NoHandleAllocation na; HandleScope scope;
ASSERT(args.length() == 3); ASSERT(args.length() == 3);
StoreIC ic(isolate); StoreIC ic(isolate);
IC::State state = IC::StateFrom(ic.target(), args[0], args[1]); IC::State state = IC::StateFrom(ic.target(), args[0], args[1]);
......
src/ic.h
View file @ 80e3843d
...@@ -532,13 +532,11 @@ class StoreIC: public IC { ...@@ -532,13 +532,11 @@ class StoreIC: public IC {
return Isolate::Current()->builtins()->builtin( return Isolate::Current()->builtins()->builtin(
Builtins::kStoreIC_Initialize_Strict); Builtins::kStoreIC_Initialize_Strict);
} }
Code* global_proxy_stub() { Handle<Code> global_proxy_stub() {
return isolate()->builtins()->builtin( return isolate()->builtins()->StoreIC_GlobalProxy();
Builtins::kStoreIC_GlobalProxy);
} }
Code* global_proxy_stub_strict() { Handle<Code> global_proxy_stub_strict() {
return isolate()->builtins()->builtin( return isolate()->builtins()->StoreIC_GlobalProxy_Strict();
Builtins::kStoreIC_GlobalProxy_Strict);
} }
static void Clear(Address address, Code* target); static void Clear(Address address, Code* target);
......
src/stub-cache.cc
View file @ 80e3843d
...@@ -491,31 +491,38 @@ MaybeObject* StubCache::ComputeKeyedLoadFunctionPrototype( ...@@ -491,31 +491,38 @@ MaybeObject* StubCache::ComputeKeyedLoadFunctionPrototype(
} }
MaybeObject* StubCache::ComputeStoreField(String* name, Handle<Code> StoreStubCompiler::CompileStoreField(Handle<JSObject> object,
JSObject* receiver, int index,
Handle<Map> transition,
Handle<String> name) {
CALL_HEAP_FUNCTION(isolate(),
CompileStoreField(*object,
index,
(transition.is_null()
? NULL
: *transition),
*name),
Code);
}
Handle<Code> StubCache::ComputeStoreField(Handle<String> name,
Handle<JSObject> receiver,
int field_index, int field_index,
Map* transition, Handle<Map> transition,
StrictModeFlag strict_mode) { StrictModeFlag strict_mode) {
PropertyType type = (transition == NULL) ? FIELD : MAP_TRANSITION; PropertyType type = (transition.is_null()) ? FIELD : MAP_TRANSITION;
Code::Flags flags = Code::ComputeMonomorphicFlags( Code::Flags flags = Code::ComputeMonomorphicFlags(
Code::STORE_IC, type, strict_mode); Code::STORE_IC, type, strict_mode);
Object* code = receiver->map()->FindInCodeCache(name, flags); Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
if (code->IsUndefined()) { if (probe->IsCode()) return Handle<Code>::cast(probe);
HandleScope scope(isolate_);
StoreStubCompiler compiler(isolate_, strict_mode); StoreStubCompiler compiler(isolate_, strict_mode);
{ MaybeObject* maybe_code = Handle<Code> code =
compiler.CompileStoreField(receiver, field_index, transition, name); compiler.CompileStoreField(receiver, field_index, transition, name);
if (!maybe_code->ToObject(&code)) return maybe_code; PROFILE(isolate_, CodeCreateEvent(Logger::STORE_IC_TAG, *code, *name));
} GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
PROFILE(isolate_, JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name));
GDBJIT(AddCode(GDBJITInterface::STORE_IC, name, Code::cast(code)));
Object* result;
{ MaybeObject* maybe_result =
receiver->UpdateMapCodeCache(name, Code::cast(code));
if (!maybe_result->ToObject(&result)) return maybe_result;
}
}
return code; return code;
} }
...@@ -586,92 +593,91 @@ MaybeObject* StubCache::ComputeKeyedLoadOrStoreElement( ...@@ -586,92 +593,91 @@ MaybeObject* StubCache::ComputeKeyedLoadOrStoreElement(
} }
MaybeObject* StubCache::ComputeStoreNormal(StrictModeFlag strict_mode) { Handle<Code> StubCache::ComputeStoreNormal(StrictModeFlag strict_mode) {
return isolate_->builtins()->builtin((strict_mode == kStrictMode) return (strict_mode == kStrictMode)
? Builtins::kStoreIC_Normal_Strict ? isolate_->builtins()->Builtins::StoreIC_Normal_Strict()
: Builtins::kStoreIC_Normal); : isolate_->builtins()->Builtins::StoreIC_Normal();
}
Handle<Code> StoreStubCompiler::CompileStoreGlobal(
Handle<GlobalObject> object,
Handle<JSGlobalPropertyCell> holder,
Handle<String> name) {
CALL_HEAP_FUNCTION(isolate(),
CompileStoreGlobal(*object, *holder, *name),
Code);
} }
MaybeObject* StubCache::ComputeStoreGlobal(String* name, Handle<Code> StubCache::ComputeStoreGlobal(Handle<String> name,
GlobalObject* receiver, Handle<GlobalObject> receiver,
JSGlobalPropertyCell* cell, Handle<JSGlobalPropertyCell> cell,
StrictModeFlag strict_mode) { StrictModeFlag strict_mode) {
Code::Flags flags = Code::ComputeMonomorphicFlags( Code::Flags flags = Code::ComputeMonomorphicFlags(
Code::STORE_IC, NORMAL, strict_mode); Code::STORE_IC, NORMAL, strict_mode);
Object* code = receiver->map()->FindInCodeCache(name, flags); Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
if (code->IsUndefined()) { if (probe->IsCode()) return Handle<Code>::cast(probe);
HandleScope scope(isolate_);
StoreStubCompiler compiler(isolate_, strict_mode); StoreStubCompiler compiler(isolate_, strict_mode);
{ MaybeObject* maybe_code = Handle<Code> code = compiler.CompileStoreGlobal(receiver, cell, name);
compiler.CompileStoreGlobal(receiver, cell, name); PROFILE(isolate_, CodeCreateEvent(Logger::STORE_IC_TAG, *code, *name));
if (!maybe_code->ToObject(&code)) return maybe_code; GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
} JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
PROFILE(isolate_,
CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name));
GDBJIT(AddCode(GDBJITInterface::STORE_IC, name, Code::cast(code)));
Object* result;
{ MaybeObject* maybe_result =
receiver->UpdateMapCodeCache(name, Code::cast(code));
if (!maybe_result->ToObject(&result)) return maybe_result;
}
}
return code; return code;
} }
MaybeObject* StubCache::ComputeStoreCallback( Handle<Code> StoreStubCompiler::CompileStoreCallback(
String* name, Handle<JSObject> object,
JSObject* receiver, Handle<AccessorInfo> callback,
AccessorInfo* callback, Handle<String> name) {
StrictModeFlag strict_mode) { CALL_HEAP_FUNCTION(isolate(),
CompileStoreCallback(*object, *callback, *name),
Code);
}
Handle<Code> StubCache::ComputeStoreCallback(Handle<String> name,
Handle<JSObject> receiver,
Handle<AccessorInfo> callback,
StrictModeFlag strict_mode) {
ASSERT(v8::ToCData<Address>(callback->setter()) != 0); ASSERT(v8::ToCData<Address>(callback->setter()) != 0);
Code::Flags flags = Code::ComputeMonomorphicFlags( Code::Flags flags = Code::ComputeMonomorphicFlags(
Code::STORE_IC, CALLBACKS, strict_mode); Code::STORE_IC, CALLBACKS, strict_mode);
Object* code = receiver->map()->FindInCodeCache(name, flags); Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
if (code->IsUndefined()) { if (probe->IsCode()) return Handle<Code>::cast(probe);
HandleScope scope(isolate_);
StoreStubCompiler compiler(isolate_, strict_mode); StoreStubCompiler compiler(isolate_, strict_mode);
{ MaybeObject* maybe_code = Handle<Code> code = compiler.CompileStoreCallback(receiver, callback, name);
compiler.CompileStoreCallback(receiver, callback, name); PROFILE(isolate_, CodeCreateEvent(Logger::STORE_IC_TAG, *code, *name));
if (!maybe_code->ToObject(&code)) return maybe_code; GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
} JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
PROFILE(isolate_,
CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name));
GDBJIT(AddCode(GDBJITInterface::STORE_IC, name, Code::cast(code)));
Object* result;
{ MaybeObject* maybe_result =
receiver->UpdateMapCodeCache(name, Code::cast(code));
if (!maybe_result->ToObject(&result)) return maybe_result;
}
}
return code; return code;
} }
MaybeObject* StubCache::ComputeStoreInterceptor( Handle<Code> StoreStubCompiler::CompileStoreInterceptor(Handle<JSObject> object,
String* name, Handle<String> name) {
JSObject* receiver, CALL_HEAP_FUNCTION(isolate(),
StrictModeFlag strict_mode) { CompileStoreInterceptor(*object, *name),
Code);
}
Handle<Code> StubCache::ComputeStoreInterceptor(Handle<String> name,
Handle<JSObject> receiver,
StrictModeFlag strict_mode) {
Code::Flags flags = Code::ComputeMonomorphicFlags( Code::Flags flags = Code::ComputeMonomorphicFlags(
Code::STORE_IC, INTERCEPTOR, strict_mode); Code::STORE_IC, INTERCEPTOR, strict_mode);
Object* code = receiver->map()->FindInCodeCache(name, flags); Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
if (code->IsUndefined()) { if (probe->IsCode()) return Handle<Code>::cast(probe);
HandleScope scope(isolate_);
StoreStubCompiler compiler(isolate_, strict_mode); StoreStubCompiler compiler(isolate_, strict_mode);
{ MaybeObject* maybe_code = Handle<Code> code = compiler.CompileStoreInterceptor(receiver, name);
compiler.CompileStoreInterceptor(receiver, name); PROFILE(isolate_, CodeCreateEvent(Logger::STORE_IC_TAG, *code, *name));
if (!maybe_code->ToObject(&code)) return maybe_code; GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
} JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
PROFILE(isolate_,
CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name));
GDBJIT(AddCode(GDBJITInterface::STORE_IC, name, Code::cast(code)));
Object* result;
{ MaybeObject* maybe_result =
receiver->UpdateMapCodeCache(name, Code::cast(code));
if (!maybe_result->ToObject(&result)) return maybe_result;
}
}
return code; return code;
} }
......
src/stub-cache.h
View file @ 80e3843d
...@@ -144,32 +144,27 @@ class StubCache { ...@@ -144,32 +144,27 @@ class StubCache {
// --- // ---
MUST_USE_RESULT MaybeObject* ComputeStoreField( Handle<Code> ComputeStoreField(Handle<String> name,
String* name, Handle<JSObject> receiver,
JSObject* receiver, int field_index,
int field_index, Handle<Map> transition,
Map* transition, StrictModeFlag strict_mode);
StrictModeFlag strict_mode);
MUST_USE_RESULT MaybeObject* ComputeStoreNormal( Handle<Code> ComputeStoreNormal(StrictModeFlag strict_mode);
StrictModeFlag strict_mode);
MUST_USE_RESULT MaybeObject* ComputeStoreGlobal( Handle<Code> ComputeStoreGlobal(Handle<String> name,
String* name, Handle<GlobalObject> receiver,
GlobalObject* receiver, Handle<JSGlobalPropertyCell> cell,
JSGlobalPropertyCell* cell, StrictModeFlag strict_mode);
StrictModeFlag strict_mode);
MUST_USE_RESULT MaybeObject* ComputeStoreCallback( Handle<Code> ComputeStoreCallback(Handle<String> name,
String* name, Handle<JSObject> receiver,
JSObject* receiver, Handle<AccessorInfo> callback,
AccessorInfo* callback, StrictModeFlag strict_mode);
StrictModeFlag strict_mode);
MUST_USE_RESULT MaybeObject* ComputeStoreInterceptor( Handle<Code> ComputeStoreInterceptor(Handle<String> name,
String* name, Handle<JSObject> receiver,
JSObject* receiver, StrictModeFlag strict_mode);
StrictModeFlag strict_mode);
// --- // ---
...@@ -693,16 +688,34 @@ class StoreStubCompiler: public StubCompiler { ...@@ -693,16 +688,34 @@ class StoreStubCompiler: public StubCompiler {
StoreStubCompiler(Isolate* isolate, StrictModeFlag strict_mode) StoreStubCompiler(Isolate* isolate, StrictModeFlag strict_mode)
: StubCompiler(isolate), strict_mode_(strict_mode) { } : StubCompiler(isolate), strict_mode_(strict_mode) { }
Handle<Code> CompileStoreField(Handle<JSObject> object,
int index,
Handle<Map> transition,
Handle<String> name);
MUST_USE_RESULT MaybeObject* CompileStoreField(JSObject* object, MUST_USE_RESULT MaybeObject* CompileStoreField(JSObject* object,
int index, int index,
Map* transition, Map* transition,
String* name); String* name);
Handle<Code> CompileStoreCallback(Handle<JSObject> object,
Handle<AccessorInfo> callback,
Handle<String> name);
MUST_USE_RESULT MaybeObject* CompileStoreCallback(JSObject* object, MUST_USE_RESULT MaybeObject* CompileStoreCallback(JSObject* object,
AccessorInfo* callbacks, AccessorInfo* callback,
String* name); String* name);
Handle<Code> CompileStoreInterceptor(Handle<JSObject> object,
Handle<String> name);
MUST_USE_RESULT MaybeObject* CompileStoreInterceptor(JSObject* object, MUST_USE_RESULT MaybeObject* CompileStoreInterceptor(JSObject* object,
String* name); String* name);
Handle<Code> CompileStoreGlobal(Handle<GlobalObject> object,
Handle<JSGlobalPropertyCell> holder,
Handle<String> name);
MUST_USE_RESULT MaybeObject* CompileStoreGlobal(GlobalObject* object, MUST_USE_RESULT MaybeObject* CompileStoreGlobal(GlobalObject* object,
JSGlobalPropertyCell* holder, JSGlobalPropertyCell* holder,
String* name); String* name);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment