From: kmillikin@chromium.org Date: Mon, 24 Oct 2011 09:33:11 +0000 (+0000) Subject: Handlify call cases for pre-monomorphic, normal, and miss. X-Git-Tag: upstream/4.7.83~18114 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=ec007b46d1455d303f34c9dc8933f05422ac7996;p=platform%2Fupstream%2Fv8.git Handlify call cases for pre-monomorphic, normal, and miss. These cases turn out to be easy. There is a lingering raw pointer implementation of TryCompileCallMiss because it's need by some of the unconverted call stubs. R=ulan@chromium.org BUG= TEST= Review URL: http://codereview.chromium.org/8366036 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@9749 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- diff --git a/src/arm/ic-arm.cc b/src/arm/ic-arm.cc index f0c2fbf..88a68f8 100644 --- a/src/arm/ic-arm.cc +++ b/src/arm/ic-arm.cc @@ -464,7 +464,7 @@ static void GenerateFunctionTailCall(MacroAssembler* masm, } -static void GenerateCallNormal(MacroAssembler* masm, int argc) { +void CallICBase::GenerateNormal(MacroAssembler* masm, int argc) { // ----------- S t a t e ------------- // -- r2 : name // -- lr : return address @@ -568,17 +568,6 @@ void CallIC::GenerateMegamorphic(MacroAssembler* masm, } -void CallIC::GenerateNormal(MacroAssembler* masm, int argc) { - // ----------- S t a t e ------------- - // -- r2 : name - // -- lr : return address - // ----------------------------------- - - GenerateCallNormal(masm, argc); - GenerateMiss(masm, argc, Code::kNoExtraICState); -} - - void KeyedCallIC::GenerateMegamorphic(MacroAssembler* masm, int argc) { // ----------- S t a t e ------------- // -- r2 : name @@ -696,7 +685,7 @@ void KeyedCallIC::GenerateNormal(MacroAssembler* masm, int argc) { __ JumpIfSmi(r2, &miss); __ IsObjectJSStringType(r2, r0, &miss); - GenerateCallNormal(masm, argc); + CallICBase::GenerateNormal(masm, argc); __ bind(&miss); GenerateMiss(masm, argc); } diff --git a/src/ia32/ic-ia32.cc b/src/ia32/ic-ia32.cc index 157c4f8..1cd7549 100644 --- a/src/ia32/ic-ia32.cc +++ b/src/ia32/ic-ia32.cc @@ -944,8 +944,9 @@ static void GenerateFunctionTailCall(MacroAssembler* masm, NullCallWrapper(), CALL_AS_METHOD); } + // The generated code falls through if the call should be handled by runtime. -static void GenerateCallNormal(MacroAssembler* masm, int argc) { +void CallICBase::GenerateNormal(MacroAssembler* masm, int argc) { // ----------- S t a t e ------------- // -- ecx : name // -- esp[0] : return address @@ -1060,20 +1061,6 @@ void CallIC::GenerateMegamorphic(MacroAssembler* masm, } -void CallIC::GenerateNormal(MacroAssembler* masm, int argc) { - // ----------- S t a t e ------------- - // -- ecx : name - // -- esp[0] : return address - // -- esp[(argc - n) * 4] : arg[n] (zero-based) - // -- ... - // -- esp[(argc + 1) * 4] : receiver - // ----------------------------------- - - GenerateCallNormal(masm, argc); - GenerateMiss(masm, argc, Code::kNoExtraICState); -} - - void KeyedCallIC::GenerateMegamorphic(MacroAssembler* masm, int argc) { // ----------- S t a t e ------------- // -- ecx : name @@ -1238,7 +1225,7 @@ void KeyedCallIC::GenerateNormal(MacroAssembler* masm, int argc) { __ JumpIfSmi(ecx, &miss); Condition cond = masm->IsObjectStringType(ecx, eax, eax); __ j(NegateCondition(cond), &miss); - GenerateCallNormal(masm, argc); + CallICBase::GenerateNormal(masm, argc); __ bind(&miss); GenerateMiss(masm, argc); } diff --git a/src/ic.h b/src/ic.h index 3fc593d..b1c4302 100644 --- a/src/ic.h +++ b/src/ic.h @@ -236,12 +236,15 @@ class CallICBase: public IC { static void Clear(Address address, Code* target); - // Platform-specific generation of misses for call and keyed call. + // Platform-specific code generation functions used by both call and + // keyed call. static void GenerateMiss(MacroAssembler* masm, int argc, IC::UtilityId id, Code::ExtraICState extra_state); + static void GenerateNormal(MacroAssembler* masm, int argc); + Code::Kind kind_; friend class IC; @@ -271,7 +274,10 @@ class CallIC: public CallICBase { int argc, Code::ExtraICState extra_ic_state); - static void GenerateNormal(MacroAssembler* masm, int argc); + static void GenerateNormal(MacroAssembler* masm, int argc) { + CallICBase::GenerateNormal(masm, argc); + GenerateMiss(masm, argc, Code::kNoExtraICState); + } }; diff --git a/src/mips/ic-mips.cc b/src/mips/ic-mips.cc index afa2ccf..4203d03 100644 --- a/src/mips/ic-mips.cc +++ b/src/mips/ic-mips.cc @@ -463,7 +463,7 @@ static void GenerateFunctionTailCall(MacroAssembler* masm, } -static void GenerateCallNormal(MacroAssembler* masm, int argc) { +void CallICBase::GenerateNormal(MacroAssembler* masm, int argc) { // ----------- S t a t e ------------- // -- a2 : name // -- ra : return address @@ -567,17 +567,6 @@ void CallIC::GenerateMegamorphic(MacroAssembler* masm, } -void CallIC::GenerateNormal(MacroAssembler* masm, int argc) { - // ----------- S t a t e ------------- - // -- a2 : name - // -- ra : return address - // ----------------------------------- - - GenerateCallNormal(masm, argc); - GenerateMiss(masm, argc, Code::kNoExtraICState); -} - - void KeyedCallIC::GenerateMegamorphic(MacroAssembler* masm, int argc) { // ----------- S t a t e ------------- // -- a2 : name @@ -694,7 +683,7 @@ void KeyedCallIC::GenerateNormal(MacroAssembler* masm, int argc) { __ JumpIfSmi(a2, &miss); __ IsObjectJSStringType(a2, a0, &miss); - GenerateCallNormal(masm, argc); + CallICBase::GenerateNormal(masm, argc); __ bind(&miss); GenerateMiss(masm, argc); } diff --git a/src/stub-cache.cc b/src/stub-cache.cc index bebee71..67e2a14 100644 --- a/src/stub-cache.cc +++ b/src/stub-cache.cc @@ -1466,14 +1466,6 @@ Handle StubCompiler::CompileCallInitialize(Code::Flags flags) { Handle StubCompiler::CompileCallPreMonomorphic(Code::Flags flags) { - CALL_HEAP_FUNCTION(isolate(), - (set_failure(NULL), TryCompileCallPreMonomorphic(flags)), - Code); -} - - -MaybeObject* StubCompiler::TryCompileCallPreMonomorphic(Code::Flags flags) { - HandleScope scope(isolate()); int argc = Code::ExtractArgumentsCountFromFlags(flags); // The code of the PreMonomorphic stub is the same as the code // of the Initialized stub. They just differ on the code object flags. @@ -1484,31 +1476,17 @@ MaybeObject* StubCompiler::TryCompileCallPreMonomorphic(Code::Flags flags) { } else { KeyedCallIC::GenerateInitialize(masm(), argc); } - Object* result; - { MaybeObject* maybe_result = - TryGetCodeWithFlags(flags, "CompileCallPreMonomorphic"); - if (!maybe_result->ToObject(&result)) return maybe_result; - } + Handle code = GetCodeWithFlags(flags, "CompileCallPreMonomorphic"); isolate()->counters()->call_premonomorphic_stubs()->Increment(); - Code* code = Code::cast(result); - USE(code); PROFILE(isolate(), CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_PRE_MONOMORPHIC_TAG), - code, code->arguments_count())); - GDBJIT(AddCode(GDBJITInterface::CALL_PRE_MONOMORPHIC, Code::cast(code))); - return result; + *code, code->arguments_count())); + GDBJIT(AddCode(GDBJITInterface::CALL_PRE_MONOMORPHIC, *code)); + return code; } Handle StubCompiler::CompileCallNormal(Code::Flags flags) { - CALL_HEAP_FUNCTION(isolate(), - (set_failure(NULL), TryCompileCallNormal(flags)), - Code); -} - - -MaybeObject* StubCompiler::TryCompileCallNormal(Code::Flags flags) { - HandleScope scope(isolate()); int argc = Code::ExtractArgumentsCountFromFlags(flags); Code::Kind kind = Code::ExtractKindFromFlags(flags); if (kind == Code::CALL_IC) { @@ -1519,18 +1497,13 @@ MaybeObject* StubCompiler::TryCompileCallNormal(Code::Flags flags) { } else { KeyedCallIC::GenerateNormal(masm(), argc); } - Object* result; - { MaybeObject* maybe_result = TryGetCodeWithFlags(flags, "CompileCallNormal"); - if (!maybe_result->ToObject(&result)) return maybe_result; - } + Handle code = GetCodeWithFlags(flags, "CompileCallNormal"); isolate()->counters()->call_normal_stubs()->Increment(); - Code* code = Code::cast(result); - USE(code); PROFILE(isolate(), CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_NORMAL_TAG), - code, code->arguments_count())); - GDBJIT(AddCode(GDBJITInterface::CALL_NORMAL, Code::cast(code))); - return result; + *code, code->arguments_count())); + GDBJIT(AddCode(GDBJITInterface::CALL_NORMAL, *code)); + return code; } @@ -1595,12 +1568,26 @@ MaybeObject* StubCompiler::TryCompileCallArguments(Code::Flags flags) { Handle StubCompiler::CompileCallMiss(Code::Flags flags) { - CALL_HEAP_FUNCTION(isolate(), - (set_failure(NULL), TryCompileCallMiss(flags)), - Code); + int argc = Code::ExtractArgumentsCountFromFlags(flags); + Code::Kind kind = Code::ExtractKindFromFlags(flags); + Code::ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags); + if (kind == Code::CALL_IC) { + CallIC::GenerateMiss(masm(), argc, extra_state); + } else { + KeyedCallIC::GenerateMiss(masm(), argc); + } + Handle code = GetCodeWithFlags(flags, "CompileCallMiss"); + isolate()->counters()->call_megamorphic_stubs()->Increment(); + PROFILE(isolate(), + CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_MISS_TAG), + *code, code->arguments_count())); + GDBJIT(AddCode(GDBJITInterface::CALL_MISS, *code)); + return code; } +// TODO(kmillikin): This annoying raw pointer implementation should be +// eliminated when the stub compiler no longer needs it. MaybeObject* StubCompiler::TryCompileCallMiss(Code::Flags flags) { HandleScope scope(isolate()); int argc = Code::ExtractArgumentsCountFromFlags(flags); diff --git a/src/stub-cache.h b/src/stub-cache.h index 3545b44..4f99472 100644 --- a/src/stub-cache.h +++ b/src/stub-cache.h @@ -392,8 +392,6 @@ class StubCompiler BASE_EMBEDDED { Handle CompileCallArguments(Code::Flags flags); Handle CompileCallMiss(Code::Flags flags); - MUST_USE_RESULT MaybeObject* TryCompileCallPreMonomorphic(Code::Flags flags); - MUST_USE_RESULT MaybeObject* TryCompileCallNormal(Code::Flags flags); MUST_USE_RESULT MaybeObject* TryCompileCallMegamorphic(Code::Flags flags); MUST_USE_RESULT MaybeObject* TryCompileCallArguments(Code::Flags flags); MUST_USE_RESULT MaybeObject* TryCompileCallMiss(Code::Flags flags); diff --git a/src/x64/ic-x64.cc b/src/x64/ic-x64.cc index 0855738..12225f0 100644 --- a/src/x64/ic-x64.cc +++ b/src/x64/ic-x64.cc @@ -821,7 +821,7 @@ static void GenerateFunctionTailCall(MacroAssembler* masm, // The generated code falls through if the call should be handled by runtime. -static void GenerateCallNormal(MacroAssembler* masm, int argc) { +void CallICBase::GenerateNormal(MacroAssembler* masm, int argc) { // ----------- S t a t e ------------- // rcx : function name // rsp[0] : return address @@ -941,22 +941,6 @@ void CallIC::GenerateMegamorphic(MacroAssembler* masm, } -void CallIC::GenerateNormal(MacroAssembler* masm, int argc) { - // ----------- S t a t e ------------- - // rcx : function name - // rsp[0] : return address - // rsp[8] : argument argc - // rsp[16] : argument argc - 1 - // ... - // rsp[argc * 8] : argument 1 - // rsp[(argc + 1) * 8] : argument 0 = receiver - // ----------------------------------- - - GenerateCallNormal(masm, argc); - GenerateMiss(masm, argc, Code::kNoExtraICState); -} - - void KeyedCallIC::GenerateMegamorphic(MacroAssembler* masm, int argc) { // ----------- S t a t e ------------- // rcx : function name @@ -1084,7 +1068,7 @@ void KeyedCallIC::GenerateNormal(MacroAssembler* masm, int argc) { __ JumpIfSmi(rcx, &miss); Condition cond = masm->IsObjectStringType(rcx, rax, rax); __ j(NegateCondition(cond), &miss); - GenerateCallNormal(masm, argc); + CallICBase::GenerateNormal(masm, argc); __ bind(&miss); GenerateMiss(masm, argc); }