src/stub-cache.cc - Issue 110573004: Merge bleeding_edge 17696:18016.

Unified Diff: src/stub-cache.cc

Issue 110573004: Merge bleeding_edge 17696:18016. (Closed) Base URL: https://v8.googlecode.com/svn/branches/experimental/parser

Patch Set: Created 7 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: src/stub-cache.cc

diff --git a/src/stub-cache.cc b/src/stub-cache.cc

index 1bc4b1314e79cbff3a4616181ed3f236c5095557..6fdd6d989fa11ff95e99cddf66d343224e5fcc0e 100644

--- a/src/stub-cache.cc

+++ b/src/stub-cache.cc

@@ -102,8 +102,10 @@ Code* StubCache::Set(Name* name, Map* map, Code* code) {

Handle<Code> StubCache::FindIC(Handle<Name> name,

Handle<Map> stub_holder_map,

Code::Kind kind,

- Code::ExtraICState extra_state) {

- Code::Flags flags = Code::ComputeMonomorphicFlags(kind, extra_state);

+ Code::ExtraICState extra_state,

+ InlineCacheHolderFlag cache_holder) {

+ Code::Flags flags = Code::ComputeMonomorphicFlags(

+ kind, extra_state, cache_holder);

Handle<Object> probe(stub_holder_map->FindInCodeCache(*name, flags),

isolate_);

if (probe->IsCode()) return Handle<Code>::cast(probe);

@@ -111,17 +113,10 @@ Handle<Code> StubCache::FindIC(Handle<Name> name,

}

-Handle<Code> StubCache::FindIC(Handle<Name> name,

- Handle<JSObject> stub_holder,

- Code::Kind kind,

- Code::ExtraICState extra_ic_state) {

- return FindIC(name, Handle<Map>(stub_holder->map()), kind, extra_ic_state);

Handle<Code> StubCache::FindHandler(Handle<Name> name,

- Handle<JSObject> receiver,

+ Handle<HeapObject> stub_holder,

Code::Kind kind,

+ InlineCacheHolderFlag cache_holder,

StrictModeFlag strict_mode) {

Code::ExtraICState extra_ic_state = Code::kNoExtraICState;

if (kind == Code::STORE_IC || kind == Code::KEYED_STORE_IC) {

@@ -129,45 +124,59 @@ Handle<Code> StubCache::FindHandler(Handle<Name> name,

STANDARD_STORE, strict_mode);

}

Code::Flags flags = Code::ComputeMonomorphicFlags(

- Code::HANDLER, extra_ic_state, Code::NORMAL, kind);

- Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags),

+ Code::HANDLER, extra_ic_state, cache_holder, Code::NORMAL, kind);

+ Handle<Object> probe(stub_holder->map()->FindInCodeCache(*name, flags),

isolate_);

if (probe->IsCode()) return Handle<Code>::cast(probe);

return Handle<Code>::null();

}

-Handle<Code> StubCache::ComputeMonomorphicIC(Handle<HeapObject> receiver,

+Handle<Code> StubCache::ComputeMonomorphicIC(Handle<Name> name,

+ Handle<Type> type,

Handle<Code> handler,

- Handle<Name> name,

StrictModeFlag strict_mode) {

Code::Kind kind = handler->handler_kind();

- Handle<Map> map(receiver->map());

- Handle<Code> ic = FindIC(name, map, kind, strict_mode);

- if (!ic.is_null()) return ic;

+ InlineCacheHolderFlag flag = IC::GetCodeCacheFlag(*type);

+ Handle<Map> stub_holder;

+ Handle<Code> ic;

+ // There are multiple string maps that all use the same prototype. That

+ // prototype cannot hold multiple handlers, one for each of the string maps,

+ // for a single name. Hence, turn off caching of the IC.

+ bool can_be_cached = !type->Is(Type::String());

+ if (can_be_cached) {

+ stub_holder = IC::GetCodeCacheHolder(flag, *type, isolate());

+ ic = FindIC(name, stub_holder, kind, strict_mode, flag);

+ if (!ic.is_null()) return ic;

+ }

if (kind == Code::LOAD_IC) {

- LoadStubCompiler ic_compiler(isolate());

- ic = ic_compiler.CompileMonomorphicIC(map, handler, name);

+ LoadStubCompiler ic_compiler(isolate(), flag);

+ ic = ic_compiler.CompileMonomorphicIC(type, handler, name);

} else if (kind == Code::KEYED_LOAD_IC) {

- KeyedLoadStubCompiler ic_compiler(isolate());

- ic = ic_compiler.CompileMonomorphicIC(map, handler, name);

+ KeyedLoadStubCompiler ic_compiler(isolate(), flag);

+ ic = ic_compiler.CompileMonomorphicIC(type, handler, name);

} else if (kind == Code::STORE_IC) {

StoreStubCompiler ic_compiler(isolate(), strict_mode);

- ic = ic_compiler.CompileMonomorphicIC(map, handler, name);

+ ic = ic_compiler.CompileMonomorphicIC(type, handler, name);

} else {

ASSERT(kind == Code::KEYED_STORE_IC);

KeyedStoreStubCompiler ic_compiler(isolate(), strict_mode, STANDARD_STORE);

- ic = ic_compiler.CompileMonomorphicIC(map, handler, name);

+ ic = ic_compiler.CompileMonomorphicIC(type, handler, name);

}

- HeapObject::UpdateMapCodeCache(receiver, name, ic);

+ if (can_be_cached) Map::UpdateCodeCache(stub_holder, name, ic);

return ic;

}

Handle<Code> StubCache::ComputeLoadNonexistent(Handle<Name> name,

- Handle<JSObject> receiver) {

+ Handle<Object> object) {

+ InlineCacheHolderFlag cache_holder = IC::GetCodeCacheForObject(*object);

+ Handle<HeapObject> stub_holder(IC::GetCodeCacheHolder(

+ isolate(), *object, cache_holder));

// If no global objects are present in the prototype chain, the load

// nonexistent IC stub can be shared for all names for a given map

// and we use the empty string for the map cache in that case. If

@@ -176,7 +185,7 @@ Handle<Code> StubCache::ComputeLoadNonexistent(Handle<Name> name,

// specific to the name.

Handle<Name> cache_name = factory()->empty_string();

Handle<JSObject> current;

- Handle<Object> next = receiver;

+ Handle<Object> next = stub_holder;

Handle<JSGlobalObject> global;

do {

current = Handle<JSObject>::cast(next);

@@ -191,13 +200,14 @@ Handle<Code> StubCache::ComputeLoadNonexistent(Handle<Name> name,

// Compile the stub that is either shared for all names or

// name specific if there are global objects involved.

- Handle<Code> handler = FindHandler(cache_name, receiver, Code::LOAD_IC);

+ Handle<Code> handler = FindHandler(

+ cache_name, stub_holder, Code::LOAD_IC, cache_holder);

if (!handler.is_null()) return handler;

- LoadStubCompiler compiler(isolate_);

+ LoadStubCompiler compiler(isolate_, cache_holder);

handler =

- compiler.CompileLoadNonexistent(receiver, current, cache_name, global);

- HeapObject::UpdateMapCodeCache(receiver, cache_name, handler);

+ compiler.CompileLoadNonexistent(object, current, cache_name, global);

+ HeapObject::UpdateMapCodeCache(stub_holder, cache_name, handler);

return handler;

}

@@ -257,9 +267,8 @@ Handle<Code> StubCache::ComputeCallConstant(int argc,

Handle<JSObject> holder,

Handle<JSFunction> function) {

// Compute the check type and the map.

- InlineCacheHolderFlag cache_holder =

- IC::GetCodeCacheForObject(*object, *holder);

- Handle<JSObject> stub_holder(IC::GetCodeCacheHolder(

+ InlineCacheHolderFlag cache_holder = IC::GetCodeCacheForObject(*object);

+ Handle<HeapObject> stub_holder(IC::GetCodeCacheHolder(

isolate_, *object, cache_holder));

// Compute check type based on receiver/holder.

@@ -283,7 +292,7 @@ Handle<Code> StubCache::ComputeCallConstant(int argc,

}

Code::Flags flags = Code::ComputeMonomorphicFlags(

- kind, extra_state, Code::CONSTANT, argc, cache_holder);

+ kind, extra_state, cache_holder, Code::FAST, argc);

Handle<Object> probe(stub_holder->map()->FindInCodeCache(*name, flags),

isolate_);

if (probe->IsCode()) return Handle<Code>::cast(probe);

@@ -312,9 +321,8 @@ Handle<Code> StubCache::ComputeCallField(int argc,

Handle<JSObject> holder,

PropertyIndex index) {

// Compute the check type and the map.

- InlineCacheHolderFlag cache_holder =

- IC::GetCodeCacheForObject(*object, *holder);

- Handle<JSObject> stub_holder(IC::GetCodeCacheHolder(

+ InlineCacheHolderFlag cache_holder = IC::GetCodeCacheForObject(*object);

+ Handle<HeapObject> stub_holder(IC::GetCodeCacheHolder(

isolate_, *object, cache_holder));

// TODO(1233596): We cannot do receiver map check for non-JS objects

@@ -326,7 +334,7 @@ Handle<Code> StubCache::ComputeCallField(int argc,

}

Code::Flags flags = Code::ComputeMonomorphicFlags(

- kind, extra_state, Code::FIELD, argc, cache_holder);

+ kind, extra_state, cache_holder, Code::FAST, argc);

Handle<Object> probe(stub_holder->map()->FindInCodeCache(*name, flags),

isolate_);

if (probe->IsCode()) return Handle<Code>::cast(probe);

@@ -351,9 +359,8 @@ Handle<Code> StubCache::ComputeCallInterceptor(int argc,

Handle<Object> object,

Handle<JSObject> holder) {

// Compute the check type and the map.

- InlineCacheHolderFlag cache_holder =

- IC::GetCodeCacheForObject(*object, *holder);

- Handle<JSObject> stub_holder(IC::GetCodeCacheHolder(

+ InlineCacheHolderFlag cache_holder = IC::GetCodeCacheForObject(*object);

+ Handle<HeapObject> stub_holder(IC::GetCodeCacheHolder(

isolate_, *object, cache_holder));

// TODO(1233596): We cannot do receiver map check for non-JS objects

@@ -365,7 +372,7 @@ Handle<Code> StubCache::ComputeCallInterceptor(int argc,

}

Code::Flags flags = Code::ComputeMonomorphicFlags(

- kind, extra_state, Code::INTERCEPTOR, argc, cache_holder);

+ kind, extra_state, cache_holder, Code::FAST, argc);

Handle<Object> probe(stub_holder->map()->FindInCodeCache(*name, flags),

isolate_);

if (probe->IsCode()) return Handle<Code>::cast(probe);

@@ -392,7 +399,7 @@ Handle<Code> StubCache::ComputeCallGlobal(int argc,

Handle<PropertyCell> cell,

Handle<JSFunction> function) {

Code::Flags flags = Code::ComputeMonomorphicFlags(

- kind, extra_state, Code::NORMAL, argc);

+ kind, extra_state, OWN_MAP, Code::NORMAL, argc);

Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags),

isolate_);

if (probe->IsCode()) return Handle<Code>::cast(probe);

@@ -580,6 +587,7 @@ Handle<Code> StubCache::ComputeCompareNil(Handle<Map> receiver_map,

}

+// TODO(verwaest): Change this method so it takes in a TypeHandleList.

Handle<Code> StubCache::ComputeLoadElementPolymorphic(

MapHandleList* receiver_maps) {

Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC, POLYMORPHIC);

@@ -588,12 +596,15 @@ Handle<Code> StubCache::ComputeLoadElementPolymorphic(

Handle<Object> probe = cache->Lookup(receiver_maps, flags);

if (probe->IsCode()) return Handle<Code>::cast(probe);

+ TypeHandleList types(receiver_maps->length());

+ for (int i = 0; i < receiver_maps->length(); i++) {

+ types.Add(handle(Type::Class(receiver_maps->at(i)), isolate()));

+ }

CodeHandleList handlers(receiver_maps->length());

KeyedLoadStubCompiler compiler(isolate_);

compiler.CompileElementHandlers(receiver_maps, &handlers);

Handle<Code> code = compiler.CompilePolymorphicIC(

- receiver_maps, &handlers, factory()->empty_string(),

- Code::NORMAL, ELEMENT);

+ &types, &handlers, factory()->empty_string(), Code::NORMAL, ELEMENT);

isolate()->counters()->keyed_load_polymorphic_stubs()->Increment();

@@ -602,24 +613,24 @@ Handle<Code> StubCache::ComputeLoadElementPolymorphic(

}

-Handle<Code> StubCache::ComputePolymorphicIC(MapHandleList* receiver_maps,

+Handle<Code> StubCache::ComputePolymorphicIC(TypeHandleList* types,

CodeHandleList* handlers,

- int number_of_valid_maps,

+ int number_of_valid_types,

Handle<Name> name,

StrictModeFlag strict_mode) {

Handle<Code> handler = handlers->at(0);

Code::Kind kind = handler->handler_kind();

- Code::StubType type = number_of_valid_maps == 1 ? handler->type()

- : Code::NORMAL;

+ Code::StubType type = number_of_valid_types == 1 ? handler->type()

+ : Code::NORMAL;

if (kind == Code::LOAD_IC) {

LoadStubCompiler ic_compiler(isolate_);

return ic_compiler.CompilePolymorphicIC(

- receiver_maps, handlers, name, type, PROPERTY);

+ types, handlers, name, type, PROPERTY);

} else {

ASSERT(kind == Code::STORE_IC);

StoreStubCompiler ic_compiler(isolate_, strict_mode);

return ic_compiler.CompilePolymorphicIC(

- receiver_maps, handlers, name, type, PROPERTY);

+ types, handlers, name, type, PROPERTY);

}

@@ -826,7 +837,7 @@ static MaybeObject* ThrowReferenceError(Isolate* isolate, Name* name) {

// can't use either LoadIC or KeyedLoadIC constructors.

HandleScope scope(isolate);

IC ic(IC::NO_EXTRA_FRAME, isolate);

- ASSERT(ic.target()->is_load_stub() || ic.target()->is_keyed_load_stub());

+ ASSERT(ic.IsLoadStub());

if (!ic.SlowIsUndeclaredGlobal()) return isolate->heap()->undefined_value();

// Throw a reference error.

@@ -1096,10 +1107,7 @@ Handle<Code> StubCompiler::GetCodeWithFlags(Code::Flags flags,

masm_.GetCode(&desc);

Handle<Code> code = factory()->NewCode(desc, flags, masm_.CodeObject());

#ifdef ENABLE_DISASSEMBLER

- if (FLAG_print_code_stubs) {

- CodeTracer::Scope trace_scope(isolate()->GetCodeTracer());

- code->Disassemble(name, trace_scope.file());

- }

+ if (FLAG_print_code_stubs) code->Disassemble(name);

#endif

return code;

}

@@ -1127,55 +1135,90 @@ void StubCompiler::LookupPostInterceptor(Handle<JSObject> holder,

- Handle<JSObject> object,

+ Handle<Object> object,

Handle<JSObject> holder,

Handle<Name> name,

Label* miss) {

- return CheckPrototypes(object, object_reg, holder,

+ Handle<JSObject> receiver;

+ PrototypeCheckType check_type = CHECK_ALL_MAPS;

+ int function_index = -1;

+ if (object->IsJSObject()) {

+ receiver = Handle<JSObject>::cast(object);

+ check_type = SKIP_RECEIVER;

+ } else {

+ if (object->IsString()) {

+ function_index = Context::STRING_FUNCTION_INDEX;

+ } else if (object->IsSymbol()) {

+ function_index = Context::SYMBOL_FUNCTION_INDEX;

+ } else if (object->IsNumber()) {

+ function_index = Context::NUMBER_FUNCTION_INDEX;

+ } else {

+ ASSERT(object->IsBoolean());

+ // Booleans use the generic oddball map, so an additional check is

+ // needed to ensure the receiver is really a boolean.

+ GenerateBooleanCheck(object_reg, miss);

+ function_index = Context::BOOLEAN_FUNCTION_INDEX;

+ }

+ GenerateDirectLoadGlobalFunctionPrototype(

+ masm(), function_index, scratch1(), miss);

+ receiver = handle(JSObject::cast(object->GetPrototype(isolate())));

+ object_reg = scratch1();

+ }

+ // Check that the maps starting from the prototype haven't changed.

+ return CheckPrototypes(receiver, object_reg, holder,

scratch1(), scratch2(), scratch3(),

- name, miss, SKIP_RECEIVER);

+ name, miss, check_type);

}

// HandlerFrontend for store uses the name register. It has to be restored

// before a miss.

- Handle<JSObject> object,

+ Handle<Object> object,

Handle<JSObject> holder,

Handle<Name> name,

Label* miss) {

- return CheckPrototypes(object, object_reg, holder,

+ return CheckPrototypes(Handle<JSObject>::cast(object), object_reg, holder,

this->name(), scratch1(), scratch2(),

name, miss, SKIP_RECEIVER);

}

-Register BaseLoadStoreStubCompiler::HandlerFrontend(Handle<JSObject> object,

+bool BaseLoadStoreStubCompiler::IncludesNumberType(TypeHandleList* types) {

+ for (int i = 0; i < types->length(); ++i) {

+ if (types->at(i)->Is(Type::Number())) return true;

+ }

+ return false;

+Register BaseLoadStoreStubCompiler::HandlerFrontend(Handle<Object> object,

Handle<JSObject> holder,

- Handle<Name> name,

- Label* success) {

+ Handle<Name> name) {

Label miss;

- HandlerFrontendFooter(name, success, &miss);

+ HandlerFrontendFooter(name, &miss);

return reg;

}

void LoadStubCompiler::NonexistentHandlerFrontend(

- Handle<JSObject> object,

+ Handle<Object> object,

Handle<JSObject> last,

Handle<Name> name,

- Label* success,

Handle<JSGlobalObject> global) {

Label miss;

- Register holder =

- HandlerFrontendHeader(object, receiver(), last, name, &miss);

+ Register holder = HandlerFrontendHeader(

+ object, receiver(), last, name, &miss);

if (!last->HasFastProperties() &&

!last->IsJSGlobalObject() &&

@@ -1196,12 +1239,12 @@ void LoadStubCompiler::NonexistentHandlerFrontend(

GenerateCheckPropertyCell(masm(), global, name, scratch2(), &miss);

}

- HandlerFrontendFooter(name, success, &miss);

+ HandlerFrontendFooter(name, &miss);

}

Handle<Code> LoadStubCompiler::CompileLoadField(

- Handle<JSObject> object,

+ Handle<Object> object,

Handle<JSObject> holder,

Handle<Name> name,

PropertyIndex field,

@@ -1216,78 +1259,66 @@ Handle<Code> LoadStubCompiler::CompileLoadField(

TailCallBuiltin(masm(), MissBuiltin(kind()));

// Return the generated code.

- return GetCode(kind(), Code::FIELD, name);

+ return GetCode(kind(), Code::FAST, name);

}

Handle<Code> LoadStubCompiler::CompileLoadConstant(

- Handle<JSObject> object,

+ Handle<Object> object,

Handle<JSObject> holder,

Handle<Name> name,

Handle<Object> value) {

- Label success;

- HandlerFrontend(object, receiver(), holder, name, &success);

- __ bind(&success);

+ HandlerFrontend(object, receiver(), holder, name);

GenerateLoadConstant(value);

// Return the generated code.

- return GetCode(kind(), Code::CONSTANT, name);

+ return GetCode(kind(), Code::FAST, name);

}

Handle<Code> LoadStubCompiler::CompileLoadCallback(

- Handle<JSObject> object,

+ Handle<Object> object,

Handle<JSObject> holder,

Handle<Name> name,

Handle<ExecutableAccessorInfo> callback) {

- Label success;

- object, receiver(), holder, name, &success, callback);

- __ bind(&success);

+ object, receiver(), holder, name, callback);

GenerateLoadCallback(reg, callback);

// Return the generated code.

- return GetCode(kind(), Code::CALLBACKS, name);

+ return GetCode(kind(), Code::FAST, name);

}

Handle<Code> LoadStubCompiler::CompileLoadCallback(

- Handle<JSObject> object,

+ Handle<Object> object,

Handle<JSObject> holder,

Handle<Name> name,

const CallOptimization& call_optimization) {

ASSERT(call_optimization.is_simple_api_call());

- Label success;

Handle<JSFunction> callback = call_optimization.constant_function();

- CallbackHandlerFrontend(

- object, receiver(), holder, name, &success, callback);

- __ bind(&success);

+ CallbackHandlerFrontend(object, receiver(), holder, name, callback);

GenerateLoadCallback(call_optimization);

// Return the generated code.

- return GetCode(kind(), Code::CALLBACKS, name);

+ return GetCode(kind(), Code::FAST, name);

}

Handle<Code> LoadStubCompiler::CompileLoadInterceptor(

- Handle<JSObject> object,

+ Handle<Object> object,

Handle<JSObject> holder,

Handle<Name> name) {

- Label success;

LookupResult lookup(isolate());

LookupPostInterceptor(holder, name, &lookup);

- Register reg = HandlerFrontend(object, receiver(), holder, name, &success);

- __ bind(&success);

+ Register reg = HandlerFrontend(object, receiver(), holder, name);

// TODO(368): Compile in the whole chain: all the interceptors in

// prototypes and ultimate answer.

GenerateLoadInterceptor(reg, object, holder, &lookup, name);

// Return the generated code.

- return GetCode(kind(), Code::INTERCEPTOR, name);

+ return GetCode(kind(), Code::FAST, name);

}

@@ -1296,7 +1327,6 @@ void LoadStubCompiler::GenerateLoadPostInterceptor(

Handle<JSObject> interceptor_holder,

Handle<Name> name,

LookupResult* lookup) {

- Label success;

Handle<JSObject> holder(lookup->holder());

if (lookup->IsField()) {

PropertyIndex field = lookup->GetFieldIndex();

@@ -1307,8 +1337,7 @@ void LoadStubCompiler::GenerateLoadPostInterceptor(

// We found FIELD property in prototype chain of interceptor's holder.

// Retrieve a field from field's holder.

- interceptor_holder, interceptor_reg, holder, name, &success);

- __ bind(&success);

+ interceptor_holder, interceptor_reg, holder, name);

GenerateLoadField(

reg, holder, field, lookup->representation());

}

@@ -1321,39 +1350,35 @@ void LoadStubCompiler::GenerateLoadPostInterceptor(

ASSERT(callback->getter() != NULL);

- interceptor_holder, interceptor_reg, holder, name, &success, callback);

- __ bind(&success);

+ interceptor_holder, interceptor_reg, holder, name, callback);

GenerateLoadCallback(reg, callback);

}

Handle<Code> BaseLoadStoreStubCompiler::CompileMonomorphicIC(

- Handle<Map> receiver_map,

+ Handle<Type> type,

Handle<Code> handler,

Handle<Name> name) {

- MapHandleList receiver_maps(1);

- receiver_maps.Add(receiver_map);

+ TypeHandleList types(1);

CodeHandleList handlers(1);

+ types.Add(type);

handlers.Add(handler);

- Code::StubType type = handler->type();

- return CompilePolymorphicIC(&receiver_maps, &handlers, name, type, PROPERTY);

+ Code::StubType stub_type = handler->type();

+ return CompilePolymorphicIC(&types, &handlers, name, stub_type, PROPERTY);

}

Handle<Code> LoadStubCompiler::CompileLoadViaGetter(

- Handle<JSObject> object,

+ Handle<Object> object,

Handle<JSObject> holder,

Handle<Name> name,

Handle<JSFunction> getter) {

- Label success;

- HandlerFrontend(object, receiver(), holder, name, &success);

- __ bind(&success);

+ HandlerFrontend(object, receiver(), holder, name);

GenerateLoadViaGetter(masm(), receiver(), getter);

// Return the generated code.

- return GetCode(kind(), Code::CALLBACKS, name);

+ return GetCode(kind(), Code::FAST, name);

}

@@ -1410,7 +1435,7 @@ Handle<Code> StoreStubCompiler::CompileStoreTransition(

TailCallBuiltin(masm(), SlowBuiltin(kind()));

// Return the generated code.

- return GetCode(kind(), Code::TRANSITION, name);

+ return GetCode(kind(), Code::FAST, name);

}

@@ -1433,7 +1458,7 @@ Handle<Code> StoreStubCompiler::CompileStoreField(Handle<JSObject> object,

TailCallBuiltin(masm(), MissBuiltin(kind()));

// Return the generated code.

- return GetCode(kind(), Code::FIELD, name);

+ return GetCode(kind(), Code::FAST, name);

}

@@ -1442,13 +1467,10 @@ Handle<Code> StoreStubCompiler::CompileStoreViaSetter(

Handle<JSObject> holder,

Handle<Name> name,

Handle<JSFunction> setter) {

- Label success;

- HandlerFrontend(object, receiver(), holder, name, &success);

- __ bind(&success);

+ HandlerFrontend(object, receiver(), holder, name);

GenerateStoreViaSetter(masm(), setter);

- return GetCode(kind(), Code::CALLBACKS, name);

+ return GetCode(kind(), Code::FAST, name);

}

@@ -1462,8 +1484,9 @@ Handle<Code> KeyedLoadStubCompiler::CompileLoadElement(

elements_kind).GetCode(isolate());

__ DispatchMap(receiver(), scratch1(), receiver_map, stub, DO_SMI_CHECK);

} else {

- Handle<Code> stub =

- KeyedLoadDictionaryElementStub().GetCode(isolate());

+ Handle<Code> stub = FLAG_compiled_keyed_dictionary_loads

+ ? KeyedLoadDictionaryElementStub().GetCode(isolate())

+ : KeyedLoadDictionaryElementPlatformStub().GetCode(isolate());

__ DispatchMap(receiver(), scratch1(), receiver_map, stub, DO_SMI_CHECK);

}

@@ -1555,7 +1578,7 @@ Handle<Code> BaseLoadStoreStubCompiler::GetCode(Code::Kind kind,

Code::StubType type,

Handle<Name> name) {

Code::Flags flags = Code::ComputeFlags(

- Code::HANDLER, MONOMORPHIC, extra_state(), type, kind);

+ Code::HANDLER, MONOMORPHIC, extra_state(), type, kind, cache_holder_);

Handle<Code> code = GetCodeWithFlags(flags, name);

PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name));

JitEvent(name, code);

@@ -1723,11 +1746,8 @@ Handle<Code> CallStubCompiler::CompileCustomCall(

Handle<Code> CallStubCompiler::GetCode(Code::StubType type,

Handle<Name> name) {

int argc = arguments_.immediate();

- Code::Flags flags = Code::ComputeMonomorphicFlags(kind_,

- extra_state_,

- type,

- argc,

- cache_holder_);

+ Code::Flags flags = Code::ComputeMonomorphicFlags(

+ kind_, extra_state_, cache_holder_, type, argc);

return GetCodeWithFlags(flags, name);

}

@@ -1737,7 +1757,7 @@ Handle<Code> CallStubCompiler::GetCode(Handle<JSFunction> function) {

if (function->shared()->name()->IsString()) {

function_name = Handle<String>(String::cast(function->shared()->name()));

}

- return GetCode(Code::CONSTANT, function_name);

+ return GetCode(Code::FAST, function_name);

}

@@ -1765,12 +1785,12 @@ int CallOptimization::GetPrototypeDepthOfExpectedType(

if (expected_receiver_type_.is_null()) return 0;

int depth = 0;

while (!object.is_identical_to(holder)) {

- if (object->IsInstanceOf(*expected_receiver_type_)) return depth;

+ if (expected_receiver_type_->IsTemplateFor(object->map())) return depth;

object = Handle<JSObject>(JSObject::cast(object->GetPrototype()));

if (!object->map()->is_hidden_prototype()) return kInvalidProtoDepth;

++depth;

}

- if (holder->IsInstanceOf(*expected_receiver_type_)) return depth;

+ if (expected_receiver_type_->IsTemplateFor(holder->map())) return depth;

return kInvalidProtoDepth;

}

« include/v8-platform.h ('K') | « src/stub-cache.h ('k') | src/sweeper-thread.h » ('j') | no next file with comments »