From 8786006022bc723bd883a9ca3b5d55b63581f2ce Mon Sep 17 00:00:00 2001 From: "mvstanton@chromium.org" Date: Mon, 1 Sep 2014 09:18:39 +0000 Subject: [PATCH] Multiple stubs can point to the same calling convention. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/523583002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23546 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/arm/code-stubs-arm.cc | 223 ++++---------------------- src/arm/interface-descriptors-arm.cc | 150 ++++++++++++++++++ src/arm64/code-stubs-arm64.cc | 262 ++++--------------------------- src/arm64/interface-descriptors-arm64.cc | 189 ++++++++++++++++++++++ src/code-stubs.cc | 255 ++++++++++++++++++++++-------- src/code-stubs.h | 56 +++++-- src/compiler/js-generic-lowering.cc | 30 ++-- src/ia32/code-stubs-ia32.cc | 204 +++--------------------- src/ia32/interface-descriptors-ia32.cc | 150 ++++++++++++++++++ src/ic/arm/ic-conventions-arm.cc | 14 +- src/ic/arm64/ic-conventions-arm64.cc | 23 ++- src/ic/ia32/ic-conventions-ia32.cc | 14 +- src/ic/ic-conventions.h | 8 + src/ic/x64/ic-conventions-x64.cc | 15 +- src/interface-descriptors.cc | 49 ++++++ src/interface-descriptors.h | 28 ++++ src/isolate.cc | 4 +- src/x64/code-stubs-x64.cc | 218 ++++--------------------- src/x64/interface-descriptors-x64.cc | 150 ++++++++++++++++++ 19 files changed, 1109 insertions(+), 933 deletions(-) diff --git a/src/arm/code-stubs-arm.cc b/src/arm/code-stubs-arm.cc index d7e1fd5..691d192 100644 --- a/src/arm/code-stubs-arm.cc +++ b/src/arm/code-stubs-arm.cc @@ -19,146 +19,23 @@ namespace v8 { namespace internal { -void FastNewClosureStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { cp, r2 }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kNewClosureFromStubFailure)->entry); -} - - -void FastNewContextStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { cp, r1 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void ToNumberStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { cp, r0 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void NumberToStringStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { cp, r0 }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kNumberToStringRT)->entry); -} - - -void FastCloneShallowArrayStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { cp, r3, r2, r1 }; - Representation representations[] = { - Representation::Tagged(), - Representation::Tagged(), - Representation::Smi(), - Representation::Tagged() }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kCreateArrayLiteralStubBailout)->entry, - representations); -} - - -void FastCloneShallowObjectStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { cp, r3, r2, r1, r0 }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kCreateObjectLiteral)->entry); -} - - -void CreateAllocationSiteStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { cp, r2, r3 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void CallFunctionStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // r1 function the function to call - Register registers[] = {cp, r1}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void CallConstructStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // r0 : number of arguments - // r1 : the function to call - // r2 : feedback vector - // r3 : (only if r2 is not the megamorphic symbol) slot in feedback - // vector (Smi) - // TODO(turbofan): So far we don't gather type feedback and hence skip the - // slot parameter, but ArrayConstructStub needs the vector to be undefined. - Register registers[] = {cp, r0, r1, r2}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void RegExpConstructResultStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { cp, r2, r1, r0 }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kRegExpConstructResult)->entry); -} - - -void TransitionElementsKindStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { cp, r0, r1 }; - Address entry = - Runtime::FunctionForId(Runtime::kTransitionElementsKind)->entry; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(entry)); -} - - -void CompareNilICStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { cp, r0 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(CompareNilIC_Miss)); - descriptor->SetMissHandler( - ExternalReference(IC_Utility(IC::kCompareNilIC_Miss), isolate())); -} - - static void InitializeArrayConstructorDescriptor( - CodeStub::Major major, CodeStubInterfaceDescriptor* descriptor, + Isolate* isolate, CodeStub::Major major, + CodeStubInterfaceDescriptor* descriptor, int constant_stack_parameter_count) { - // register state - // cp -- context - // r0 -- number of arguments - // r1 -- function - // r2 -- allocation site with elements kind Address deopt_handler = Runtime::FunctionForId( Runtime::kArrayConstructor)->entry; if (constant_stack_parameter_count == 0) { - Register registers[] = { cp, r1, r2 }; - descriptor->Initialize(major, arraysize(registers), registers, - deopt_handler, NULL, constant_stack_parameter_count, + CallInterfaceDescriptor* call_descriptor = isolate->call_descriptor( + CallDescriptorKey::ArrayConstructorConstantArgCountCall); + descriptor->Initialize(major, call_descriptor, deopt_handler, + constant_stack_parameter_count, JS_FUNCTION_STUB_MODE); } else { - // stack param count needs (constructor pointer, and single argument) - Register registers[] = { cp, r1, r2, r0 }; - Representation representations[] = { - Representation::Tagged(), - Representation::Tagged(), - Representation::Tagged(), - Representation::Integer32() }; - descriptor->Initialize(major, arraysize(registers), registers, r0, - deopt_handler, representations, + CallInterfaceDescriptor* call_descriptor = + isolate->call_descriptor(CallDescriptorKey::ArrayConstructorCall); + descriptor->Initialize(major, call_descriptor, r0, deopt_handler, constant_stack_parameter_count, JS_FUNCTION_STUB_MODE, PASS_ARGUMENTS); } @@ -166,29 +43,22 @@ static void InitializeArrayConstructorDescriptor( static void InitializeInternalArrayConstructorDescriptor( - CodeStub::Major major, CodeStubInterfaceDescriptor* descriptor, + Isolate* isolate, CodeStub::Major major, + CodeStubInterfaceDescriptor* descriptor, int constant_stack_parameter_count) { - // register state - // cp -- context - // r0 -- number of arguments - // r1 -- constructor function Address deopt_handler = Runtime::FunctionForId( Runtime::kInternalArrayConstructor)->entry; if (constant_stack_parameter_count == 0) { - Register registers[] = { cp, r1 }; - descriptor->Initialize(major, arraysize(registers), registers, - deopt_handler, NULL, constant_stack_parameter_count, + CallInterfaceDescriptor* call_descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorConstantArgCountCall); + descriptor->Initialize(major, call_descriptor, deopt_handler, + constant_stack_parameter_count, JS_FUNCTION_STUB_MODE); } else { - // stack param count needs (constructor pointer, and single argument) - Register registers[] = { cp, r1, r0 }; - Representation representations[] = { - Representation::Tagged(), - Representation::Tagged(), - Representation::Integer32() }; - descriptor->Initialize(major, arraysize(registers), registers, r0, - deopt_handler, representations, + CallInterfaceDescriptor* call_descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorCall); + descriptor->Initialize(major, call_descriptor, r0, deopt_handler, constant_stack_parameter_count, JS_FUNCTION_STUB_MODE, PASS_ARGUMENTS); } @@ -197,73 +67,40 @@ static void InitializeInternalArrayConstructorDescriptor( void ArrayNoArgumentConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeArrayConstructorDescriptor(MajorKey(), descriptor, 0); + InitializeArrayConstructorDescriptor(isolate(), MajorKey(), descriptor, 0); } void ArraySingleArgumentConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeArrayConstructorDescriptor(MajorKey(), descriptor, 1); + InitializeArrayConstructorDescriptor(isolate(), MajorKey(), descriptor, 1); } void ArrayNArgumentsConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeArrayConstructorDescriptor(MajorKey(), descriptor, -1); -} - - -void ToBooleanStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { cp, r0 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(ToBooleanIC_Miss)); - descriptor->SetMissHandler( - ExternalReference(IC_Utility(IC::kToBooleanIC_Miss), isolate())); + InitializeArrayConstructorDescriptor(isolate(), MajorKey(), descriptor, -1); } void InternalArrayNoArgumentConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeInternalArrayConstructorDescriptor(MajorKey(), descriptor, 0); + InitializeInternalArrayConstructorDescriptor(isolate(), MajorKey(), + descriptor, 0); } void InternalArraySingleArgumentConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeInternalArrayConstructorDescriptor(MajorKey(), descriptor, 1); + InitializeInternalArrayConstructorDescriptor(isolate(), MajorKey(), + descriptor, 1); } void InternalArrayNArgumentsConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeInternalArrayConstructorDescriptor(MajorKey(), descriptor, -1); -} - - -void BinaryOpICStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { cp, r1, r0 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(BinaryOpIC_Miss)); - descriptor->SetMissHandler( - ExternalReference(IC_Utility(IC::kBinaryOpIC_Miss), isolate())); -} - - -void BinaryOpWithAllocationSiteStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { cp, r2, r1, r0 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(BinaryOpIC_MissWithAllocationSite)); -} - - -void StringAddStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { cp, r1, r0 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kStringAdd)->entry); + InitializeInternalArrayConstructorDescriptor(isolate(), MajorKey(), + descriptor, -1); } @@ -1797,12 +1634,6 @@ void FunctionPrototypeStub::Generate(MacroAssembler* masm) { } -Register InstanceofStub::left() { return r0; } - - -Register InstanceofStub::right() { return r1; } - - void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) { // The displacement is the offset of the last parameter (if any) // relative to the frame pointer. diff --git a/src/arm/interface-descriptors-arm.cc b/src/arm/interface-descriptors-arm.cc index e577278..6a5f12d 100644 --- a/src/arm/interface-descriptors-arm.cc +++ b/src/arm/interface-descriptors-arm.cc @@ -21,6 +21,156 @@ void CallDescriptors::InitializeForIsolate(Isolate* isolate) { static PlatformInterfaceDescriptor noInlineDescriptor = PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS); + InitializeForIsolateAllPlatforms(isolate); + + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastNewClosureCall); + Register registers[] = {cp, r2}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastNewContextCall); + Register registers[] = {cp, r1}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::ToNumberCall); + Register registers[] = {cp, r0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::NumberToStringCall); + Register registers[] = {cp, r0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastCloneShallowArrayCall); + Register registers[] = {cp, r3, r2, r1}; + Representation representations[] = { + Representation::Tagged(), Representation::Tagged(), + Representation::Smi(), Representation::Tagged()}; + descriptor->Initialize(arraysize(registers), registers, representations); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastCloneShallowObjectCall); + Register registers[] = {cp, r3, r2, r1, r0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CreateAllocationSiteCall); + Register registers[] = {cp, r2, r3}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CallFunctionCall); + Register registers[] = {cp, r1}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CallConstructCall); + // r0 : number of arguments + // r1 : the function to call + // r2 : feedback vector + // r3 : (only if r2 is not the megamorphic symbol) slot in feedback + // vector (Smi) + // TODO(turbofan): So far we don't gather type feedback and hence skip the + // slot parameter, but ArrayConstructStub needs the vector to be undefined. + Register registers[] = {cp, r0, r1, r2}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::RegExpConstructResultCall); + Register registers[] = {cp, r2, r1, r0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::TransitionElementsKindCall); + Register registers[] = {cp, r0, r1}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::ArrayConstructorConstantArgCountCall); + // register state + // cp -- context + // r0 -- number of arguments + // r1 -- function + // r2 -- allocation site with elements kind + Register registers[] = {cp, r1, r2}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::ArrayConstructorCall); + // stack param count needs (constructor pointer, and single argument) + Register registers[] = {cp, r1, r2, r0}; + Representation representations[] = { + Representation::Tagged(), Representation::Tagged(), + Representation::Tagged(), Representation::Integer32()}; + descriptor->Initialize(arraysize(registers), registers, representations); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorConstantArgCountCall); + // register state + // cp -- context + // r0 -- number of arguments + // r1 -- constructor function + Register registers[] = {cp, r1}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorCall); + // stack param count needs (constructor pointer, and single argument) + Register registers[] = {cp, r1, r0}; + Representation representations[] = {Representation::Tagged(), + Representation::Tagged(), + Representation::Integer32()}; + descriptor->Initialize(arraysize(registers), registers, representations); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CompareNilCall); + Register registers[] = {cp, r0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::ToBooleanCall); + Register registers[] = {cp, r0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::BinaryOpCall); + Register registers[] = {cp, r1, r0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::BinaryOpWithAllocationSiteCall); + Register registers[] = {cp, r2, r1, r0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::StringAddCall); + Register registers[] = {cp, r1, r0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { CallInterfaceDescriptor* descriptor = isolate->call_descriptor(CallDescriptorKey::ArgumentAdaptorCall); diff --git a/src/arm64/code-stubs-arm64.cc b/src/arm64/code-stubs-arm64.cc index 1a88f7d..6c334d9 100644 --- a/src/arm64/code-stubs-arm64.cc +++ b/src/arm64/code-stubs-arm64.cc @@ -18,150 +18,10 @@ namespace v8 { namespace internal { -void FastNewClosureStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // cp: context - // x2: function info - Register registers[] = { cp, x2 }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kNewClosureFromStubFailure)->entry); -} - - -void FastNewContextStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // cp: context - // x1: function - Register registers[] = { cp, x1 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void ToNumberStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // cp: context - // x0: value - Register registers[] = { cp, x0 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void NumberToStringStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // cp: context - // x0: value - Register registers[] = { cp, x0 }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kNumberToStringRT)->entry); -} - - -void FastCloneShallowArrayStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // cp: context - // x3: array literals array - // x2: array literal index - // x1: constant elements - Register registers[] = { cp, x3, x2, x1 }; - Representation representations[] = { - Representation::Tagged(), - Representation::Tagged(), - Representation::Smi(), - Representation::Tagged() }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kCreateArrayLiteralStubBailout)->entry, - representations); -} - - -void FastCloneShallowObjectStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // cp: context - // x3: object literals array - // x2: object literal index - // x1: constant properties - // x0: object literal flags - Register registers[] = { cp, x3, x2, x1, x0 }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kCreateObjectLiteral)->entry); -} - - -void CreateAllocationSiteStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // cp: context - // x2: feedback vector - // x3: call feedback slot - Register registers[] = { cp, x2, x3 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void CallFunctionStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // x1 function the function to call - Register registers[] = {cp, x1}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void CallConstructStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // x0 : number of arguments - // x1 : the function to call - // x2 : feedback vector - // x3 : slot in feedback vector (smi) (if r2 is not the megamorphic symbol) - // TODO(turbofan): So far we don't gather type feedback and hence skip the - // slot parameter, but ArrayConstructStub needs the vector to be undefined. - Register registers[] = {cp, x0, x1, x2}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void RegExpConstructResultStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // cp: context - // x2: length - // x1: index (of last match) - // x0: string - Register registers[] = { cp, x2, x1, x0 }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kRegExpConstructResult)->entry); -} - - -void TransitionElementsKindStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // cp: context - // x0: value (js_array) - // x1: to_map - Register registers[] = { cp, x0, x1 }; - Address entry = - Runtime::FunctionForId(Runtime::kTransitionElementsKind)->entry; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(entry)); -} - - -void CompareNilICStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // cp: context - // x0: value to compare - Register registers[] = { cp, x0 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(CompareNilIC_Miss)); - descriptor->SetMissHandler( - ExternalReference(IC_Utility(IC::kCompareNilIC_Miss), isolate())); -} - static void InitializeArrayConstructorDescriptor( - CodeStub::Major major, CodeStubInterfaceDescriptor* descriptor, + Isolate* isolate, CodeStub::Major major, + CodeStubInterfaceDescriptor* descriptor, int constant_stack_parameter_count) { // cp: context // x1: function @@ -171,20 +31,15 @@ static void InitializeArrayConstructorDescriptor( Runtime::kArrayConstructor)->entry; if (constant_stack_parameter_count == 0) { - Register registers[] = { cp, x1, x2 }; - descriptor->Initialize(major, arraysize(registers), registers, - deopt_handler, NULL, constant_stack_parameter_count, + CallInterfaceDescriptor* call_descriptor = isolate->call_descriptor( + CallDescriptorKey::ArrayConstructorConstantArgCountCall); + descriptor->Initialize(major, call_descriptor, deopt_handler, + constant_stack_parameter_count, JS_FUNCTION_STUB_MODE); } else { - // stack param count needs (constructor pointer, and single argument) - Register registers[] = { cp, x1, x2, x0 }; - Representation representations[] = { - Representation::Tagged(), - Representation::Tagged(), - Representation::Tagged(), - Representation::Integer32() }; - descriptor->Initialize(major, arraysize(registers), registers, x0, - deopt_handler, representations, + CallInterfaceDescriptor* call_descriptor = + isolate->call_descriptor(CallDescriptorKey::ArrayConstructorCall); + descriptor->Initialize(major, call_descriptor, x0, deopt_handler, constant_stack_parameter_count, JS_FUNCTION_STUB_MODE, PASS_ARGUMENTS); } @@ -193,45 +48,39 @@ static void InitializeArrayConstructorDescriptor( void ArrayNoArgumentConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeArrayConstructorDescriptor(MajorKey(), descriptor, 0); + InitializeArrayConstructorDescriptor(isolate(), MajorKey(), descriptor, 0); } void ArraySingleArgumentConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeArrayConstructorDescriptor(MajorKey(), descriptor, 1); + InitializeArrayConstructorDescriptor(isolate(), MajorKey(), descriptor, 1); } void ArrayNArgumentsConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeArrayConstructorDescriptor(MajorKey(), descriptor, -1); + InitializeArrayConstructorDescriptor(isolate(), MajorKey(), descriptor, -1); } static void InitializeInternalArrayConstructorDescriptor( - CodeStub::Major major, CodeStubInterfaceDescriptor* descriptor, + Isolate* isolate, CodeStub::Major major, + CodeStubInterfaceDescriptor* descriptor, int constant_stack_parameter_count) { - // cp: context - // x1: constructor function - // x0: number of arguments to the constructor function Address deopt_handler = Runtime::FunctionForId( Runtime::kInternalArrayConstructor)->entry; if (constant_stack_parameter_count == 0) { - Register registers[] = { cp, x1 }; - descriptor->Initialize(major, arraysize(registers), registers, - deopt_handler, NULL, constant_stack_parameter_count, + CallInterfaceDescriptor* call_descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorConstantArgCountCall); + descriptor->Initialize(major, call_descriptor, deopt_handler, + constant_stack_parameter_count, JS_FUNCTION_STUB_MODE); } else { - // stack param count needs (constructor pointer, and single argument) - Register registers[] = { cp, x1, x0 }; - Representation representations[] = { - Representation::Tagged(), - Representation::Tagged(), - Representation::Integer32() }; - descriptor->Initialize(major, arraysize(registers), registers, x0, - deopt_handler, representations, + CallInterfaceDescriptor* call_descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorCall); + descriptor->Initialize(major, call_descriptor, x0, deopt_handler, constant_stack_parameter_count, JS_FUNCTION_STUB_MODE, PASS_ARGUMENTS); } @@ -240,67 +89,22 @@ static void InitializeInternalArrayConstructorDescriptor( void InternalArrayNoArgumentConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeInternalArrayConstructorDescriptor(MajorKey(), descriptor, 0); + InitializeInternalArrayConstructorDescriptor(isolate(), MajorKey(), + descriptor, 0); } void InternalArraySingleArgumentConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeInternalArrayConstructorDescriptor(MajorKey(), descriptor, 1); + InitializeInternalArrayConstructorDescriptor(isolate(), MajorKey(), + descriptor, 1); } void InternalArrayNArgumentsConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeInternalArrayConstructorDescriptor(MajorKey(), descriptor, -1); -} - - -void ToBooleanStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // cp: context - // x0: value - Register registers[] = { cp, x0 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(ToBooleanIC_Miss)); - descriptor->SetMissHandler( - ExternalReference(IC_Utility(IC::kToBooleanIC_Miss), isolate())); -} - - -void BinaryOpICStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // cp: context - // x1: left operand - // x0: right operand - Register registers[] = { cp, x1, x0 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(BinaryOpIC_Miss)); - descriptor->SetMissHandler( - ExternalReference(IC_Utility(IC::kBinaryOpIC_Miss), isolate())); -} - - -void BinaryOpWithAllocationSiteStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // cp: context - // x2: allocation site - // x1: left operand - // x0: right operand - Register registers[] = { cp, x2, x1, x0 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(BinaryOpIC_MissWithAllocationSite)); -} - - -void StringAddStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // cp: context - // x1: left operand - // x0: right operand - Register registers[] = { cp, x1, x0 }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kStringAdd)->entry); + InitializeInternalArrayConstructorDescriptor(isolate(), MajorKey(), + descriptor, -1); } @@ -1818,18 +1622,6 @@ void InstanceofStub::Generate(MacroAssembler* masm) { } -Register InstanceofStub::left() { - // Object to check (instanceof lhs). - return x11; -} - - -Register InstanceofStub::right() { - // Constructor function (instanceof rhs). - return x10; -} - - void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) { Register arg_count = x0; Register key = x1; diff --git a/src/arm64/interface-descriptors-arm64.cc b/src/arm64/interface-descriptors-arm64.cc index cc1dc87..1bea2ba 100644 --- a/src/arm64/interface-descriptors-arm64.cc +++ b/src/arm64/interface-descriptors-arm64.cc @@ -21,6 +21,195 @@ void CallDescriptors::InitializeForIsolate(Isolate* isolate) { static PlatformInterfaceDescriptor noInlineDescriptor = PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS); + InitializeForIsolateAllPlatforms(isolate); + + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastNewClosureCall); + // cp: context + // x2: function info + Register registers[] = {cp, x2}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastNewContextCall); + // cp: context + // x1: function + Register registers[] = {cp, x1}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::ToNumberCall); + // cp: context + // x0: value + Register registers[] = {cp, x0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::NumberToStringCall); + // cp: context + // x0: value + Register registers[] = {cp, x0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastCloneShallowArrayCall); + // cp: context + // x3: array literals array + // x2: array literal index + // x1: constant elements + Register registers[] = {cp, x3, x2, x1}; + Representation representations[] = { + Representation::Tagged(), Representation::Tagged(), + Representation::Smi(), Representation::Tagged()}; + descriptor->Initialize(arraysize(registers), registers, representations); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastCloneShallowObjectCall); + // cp: context + // x3: object literals array + // x2: object literal index + // x1: constant properties + // x0: object literal flags + Register registers[] = {cp, x3, x2, x1, x0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CreateAllocationSiteCall); + // cp: context + // x2: feedback vector + // x3: call feedback slot + Register registers[] = {cp, x2, x3}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CallFunctionCall); + // x1 function the function to call + Register registers[] = {cp, x1}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CallConstructCall); + // x0 : number of arguments + // x1 : the function to call + // x2 : feedback vector + // x3 : slot in feedback vector (smi) (if r2 is not the megamorphic symbol) + // TODO(turbofan): So far we don't gather type feedback and hence skip the + // slot parameter, but ArrayConstructStub needs the vector to be undefined. + Register registers[] = {cp, x0, x1, x2}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::RegExpConstructResultCall); + // cp: context + // x2: length + // x1: index (of last match) + // x0: string + Register registers[] = {cp, x2, x1, x0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::TransitionElementsKindCall); + // cp: context + // x0: value (js_array) + // x1: to_map + Register registers[] = {cp, x0, x1}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::ArrayConstructorConstantArgCountCall); + // cp: context + // x1: function + // x2: allocation site with elements kind + // x0: number of arguments to the constructor function + Register registers[] = {cp, x1, x2}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::ArrayConstructorCall); + // stack param count needs (constructor pointer, and single argument) + Register registers[] = {cp, x1, x2, x0}; + Representation representations[] = { + Representation::Tagged(), Representation::Tagged(), + Representation::Tagged(), Representation::Integer32()}; + descriptor->Initialize(arraysize(registers), registers, representations); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorConstantArgCountCall); + // cp: context + // x1: constructor function + // x0: number of arguments to the constructor function + Register registers[] = {cp, x1}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorCall); + // stack param count needs (constructor pointer, and single argument) + Register registers[] = {cp, x1, x0}; + Representation representations[] = {Representation::Tagged(), + Representation::Tagged(), + Representation::Integer32()}; + descriptor->Initialize(arraysize(registers), registers, representations); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CompareNilCall); + // cp: context + // x0: value to compare + Register registers[] = {cp, x0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::ToBooleanCall); + // cp: context + // x0: value + Register registers[] = {cp, x0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::BinaryOpCall); + // cp: context + // x1: left operand + // x0: right operand + Register registers[] = {cp, x1, x0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::BinaryOpWithAllocationSiteCall); + // cp: context + // x2: allocation site + // x1: left operand + // x0: right operand + Register registers[] = {cp, x2, x1, x0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::StringAddCall); + // cp: context + // x1: left operand + // x0: right operand + Register registers[] = {cp, x1, x0}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { CallInterfaceDescriptor* descriptor = isolate->call_descriptor(CallDescriptorKey::ArgumentAdaptorCall); diff --git a/src/code-stubs.cc b/src/code-stubs.cc index a07a7eb..00cbc7a 100644 --- a/src/code-stubs.cc +++ b/src/code-stubs.cc @@ -17,25 +17,22 @@ namespace internal { CodeStubInterfaceDescriptor::CodeStubInterfaceDescriptor() - : stack_parameter_count_(no_reg), + : call_descriptor_(NULL), + stack_parameter_count_(no_reg), hint_stack_parameter_count_(-1), function_mode_(NOT_JS_FUNCTION_STUB_MODE), deoptimization_handler_(NULL), handler_arguments_mode_(DONT_PASS_ARGUMENTS), miss_handler_(), - has_miss_handler_(false) { } + has_miss_handler_(false) {} void CodeStubInterfaceDescriptor::Initialize( - CodeStub::Major major, int register_parameter_count, Register* registers, - Address deoptimization_handler, - Representation* register_param_representations, - int hint_stack_parameter_count, StubFunctionMode function_mode) { - InterfaceDescriptor::Initialize(register_parameter_count, registers, - register_param_representations); - + CodeStub::Major major, CallInterfaceDescriptor* call_descriptor, + Address deoptimization_handler, int hint_stack_parameter_count, + StubFunctionMode function_mode) { + call_descriptor_ = call_descriptor; deoptimization_handler_ = deoptimization_handler; - hint_stack_parameter_count_ = hint_stack_parameter_count; function_mode_ = function_mode; major_ = major; @@ -43,14 +40,12 @@ void CodeStubInterfaceDescriptor::Initialize( void CodeStubInterfaceDescriptor::Initialize( - CodeStub::Major major, int register_parameter_count, Register* registers, + CodeStub::Major major, CallInterfaceDescriptor* call_descriptor, Register stack_parameter_count, Address deoptimization_handler, - Representation* register_param_representations, int hint_stack_parameter_count, StubFunctionMode function_mode, HandlerArgumentsMode handler_mode) { - Initialize(major, register_parameter_count, registers, deoptimization_handler, - register_param_representations, hint_stack_parameter_count, - function_mode); + Initialize(major, call_descriptor, deoptimization_handler, + hint_stack_parameter_count, function_mode); stack_parameter_count_ = stack_parameter_count; handler_arguments_mode_ = handler_mode; } @@ -535,34 +530,28 @@ void JSEntryStub::FinishCode(Handle code) { void LoadFastElementStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = {InterfaceDescriptor::ContextRegister(), - LoadConvention::ReceiverRegister(), - LoadConvention::NameRegister()}; - STATIC_ASSERT(LoadConvention::kParameterCount == 2); - descriptor->Initialize(MajorKey(), arraysize(registers), registers, + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::LoadICCall); + descriptor->Initialize(MajorKey(), call_descriptor, FUNCTION_ADDR(KeyedLoadIC_MissFromStubFailure)); } void LoadDictionaryElementStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = {InterfaceDescriptor::ContextRegister(), - LoadConvention::ReceiverRegister(), - LoadConvention::NameRegister()}; - STATIC_ASSERT(LoadConvention::kParameterCount == 2); - descriptor->Initialize(MajorKey(), arraysize(registers), registers, + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::LoadICCall); + descriptor->Initialize(MajorKey(), call_descriptor, FUNCTION_ADDR(KeyedLoadIC_MissFromStubFailure)); } void KeyedLoadGenericStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = {InterfaceDescriptor::ContextRegister(), - LoadConvention::ReceiverRegister(), - LoadConvention::NameRegister()}; - STATIC_ASSERT(LoadConvention::kParameterCount == 2); + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::LoadICCall); descriptor->Initialize( - MajorKey(), arraysize(registers), registers, + MajorKey(), call_descriptor, Runtime::FunctionForId(Runtime::kKeyedGetProperty)->entry); } @@ -570,17 +559,14 @@ void KeyedLoadGenericStub::InitializeInterfaceDescriptor( void HandlerStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { if (kind() == Code::LOAD_IC) { - Register registers[] = {InterfaceDescriptor::ContextRegister(), - LoadConvention::ReceiverRegister(), - LoadConvention::NameRegister()}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::LoadICCall); + descriptor->Initialize(MajorKey(), call_descriptor); } else { DCHECK_EQ(Code::STORE_IC, kind()); - Register registers[] = {InterfaceDescriptor::ContextRegister(), - StoreConvention::ReceiverRegister(), - StoreConvention::NameRegister(), - StoreConvention::ValueRegister()}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::StoreICCall); + descriptor->Initialize(MajorKey(), call_descriptor, FUNCTION_ADDR(StoreIC_MissFromStubFailure)); } } @@ -588,53 +574,44 @@ void HandlerStub::InitializeInterfaceDescriptor( void StoreFastElementStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = {InterfaceDescriptor::ContextRegister(), - StoreConvention::ReceiverRegister(), - StoreConvention::NameRegister(), - StoreConvention::ValueRegister()}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::StoreICCall); + descriptor->Initialize(MajorKey(), call_descriptor, FUNCTION_ADDR(KeyedStoreIC_MissFromStubFailure)); } void ElementsTransitionAndStoreStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { InterfaceDescriptor::ContextRegister(), - ValueRegister(), - MapRegister(), - KeyRegister(), - ObjectRegister() }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, + CallInterfaceDescriptor* call_descriptor = isolate()->call_descriptor( + CallDescriptorKey::ElementTransitionAndStoreCall); + descriptor->Initialize(MajorKey(), call_descriptor, FUNCTION_ADDR(ElementsTransitionAndStoreIC_Miss)); } void InstanceofStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { InterfaceDescriptor::ContextRegister(), - InstanceofStub::left(), - InstanceofStub::right() }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::InstanceofCall); + descriptor->Initialize(MajorKey(), call_descriptor); } -static void InitializeVectorLoadStub(CodeStubInterfaceDescriptor* descriptor, +static void InitializeVectorLoadStub(Isolate* isolate, + CodeStubInterfaceDescriptor* descriptor, CodeStub::Major major, Address deoptimization_handler) { DCHECK(FLAG_vector_ics); - Register registers[] = {InterfaceDescriptor::ContextRegister(), - FullVectorLoadConvention::ReceiverRegister(), - FullVectorLoadConvention::NameRegister(), - FullVectorLoadConvention::SlotRegister(), - FullVectorLoadConvention::VectorRegister()}; - descriptor->Initialize(major, arraysize(registers), registers, - deoptimization_handler); + CallInterfaceDescriptor* call_descriptor = + isolate->call_descriptor(CallDescriptorKey::VectorLoadICCall); + descriptor->Initialize(major, call_descriptor, deoptimization_handler); } void VectorLoadStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeVectorLoadStub(descriptor, MajorKey(), + InitializeVectorLoadStub(isolate(), descriptor, MajorKey(), FUNCTION_ADDR(VectorLoadIC_MissFromStubFailure)); } @@ -642,11 +619,161 @@ void VectorLoadStub::InitializeInterfaceDescriptor( void VectorKeyedLoadStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { InitializeVectorLoadStub( - descriptor, MajorKey(), + isolate(), descriptor, MajorKey(), FUNCTION_ADDR(VectorKeyedLoadIC_MissFromStubFailure)); } +void FastNewClosureStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::FastNewClosureCall); + descriptor->Initialize( + MajorKey(), call_descriptor, + Runtime::FunctionForId(Runtime::kNewClosureFromStubFailure)->entry); +} + + +void FastNewContextStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::FastNewContextCall); + descriptor->Initialize(MajorKey(), call_descriptor); +} + + +void ToNumberStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::ToNumberCall); + descriptor->Initialize(MajorKey(), call_descriptor); +} + + +void NumberToStringStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::NumberToStringCall); + descriptor->Initialize( + MajorKey(), call_descriptor, + Runtime::FunctionForId(Runtime::kNumberToStringRT)->entry); +} + + +void FastCloneShallowArrayStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::FastCloneShallowArrayCall); + descriptor->Initialize( + MajorKey(), call_descriptor, + Runtime::FunctionForId(Runtime::kCreateArrayLiteralStubBailout)->entry); +} + + +void FastCloneShallowObjectStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::FastCloneShallowObjectCall); + descriptor->Initialize( + MajorKey(), call_descriptor, + Runtime::FunctionForId(Runtime::kCreateObjectLiteral)->entry); +} + + +void CreateAllocationSiteStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::CreateAllocationSiteCall); + descriptor->Initialize(MajorKey(), call_descriptor); +} + + +void CallFunctionStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::CallFunctionCall); + descriptor->Initialize(MajorKey(), call_descriptor); +} + + +void CallConstructStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::CallConstructCall); + descriptor->Initialize(MajorKey(), call_descriptor); +} + + +void RegExpConstructResultStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::RegExpConstructResultCall); + descriptor->Initialize( + MajorKey(), call_descriptor, + Runtime::FunctionForId(Runtime::kRegExpConstructResult)->entry); +} + + +void TransitionElementsKindStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::TransitionElementsKindCall); + descriptor->Initialize( + MajorKey(), call_descriptor, + Runtime::FunctionForId(Runtime::kTransitionElementsKind)->entry); +} + + +void CompareNilICStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::CompareNilCall); + descriptor->Initialize(MajorKey(), call_descriptor, + FUNCTION_ADDR(CompareNilIC_Miss)); + descriptor->SetMissHandler( + ExternalReference(IC_Utility(IC::kCompareNilIC_Miss), isolate())); +} + +void ToBooleanStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::ToBooleanCall); + descriptor->Initialize(MajorKey(), call_descriptor, + FUNCTION_ADDR(ToBooleanIC_Miss)); + descriptor->SetMissHandler( + ExternalReference(IC_Utility(IC::kToBooleanIC_Miss), isolate())); +} + + +void BinaryOpICStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::BinaryOpCall); + descriptor->Initialize(MajorKey(), call_descriptor, + FUNCTION_ADDR(BinaryOpIC_Miss)); + descriptor->SetMissHandler( + ExternalReference(IC_Utility(IC::kBinaryOpIC_Miss), isolate())); +} + + +void BinaryOpWithAllocationSiteStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = isolate()->call_descriptor( + CallDescriptorKey::BinaryOpWithAllocationSiteCall); + descriptor->Initialize(MajorKey(), call_descriptor, + FUNCTION_ADDR(BinaryOpIC_MissWithAllocationSite)); +} + + +void StringAddStub::InitializeInterfaceDescriptor( + CodeStubInterfaceDescriptor* descriptor) { + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::StringAddCall); + descriptor->Initialize(MajorKey(), call_descriptor, + Runtime::FunctionForId(Runtime::kStringAdd)->entry); +} + + void LoadDictionaryElementPlatformStub::Generate(MacroAssembler* masm) { ElementHandlerCompiler::GenerateLoadDictionaryElement(masm); } diff --git a/src/code-stubs.h b/src/code-stubs.h index e689cb5..5bc59f4 100644 --- a/src/code-stubs.h +++ b/src/code-stubs.h @@ -281,19 +281,19 @@ enum StubFunctionMode { NOT_JS_FUNCTION_STUB_MODE, JS_FUNCTION_STUB_MODE }; enum HandlerArgumentsMode { DONT_PASS_ARGUMENTS, PASS_ARGUMENTS }; -class CodeStubInterfaceDescriptor: public InterfaceDescriptor { +class CodeStubInterfaceDescriptor { public: CodeStubInterfaceDescriptor(); - void Initialize(CodeStub::Major major, int register_parameter_count, - Register* registers, Address deoptimization_handler = NULL, - Representation* register_param_representations = NULL, + void Initialize(CodeStub::Major major, + CallInterfaceDescriptor* call_descriptor, + Address deoptimization_handler = NULL, int hint_stack_parameter_count = -1, StubFunctionMode function_mode = NOT_JS_FUNCTION_STUB_MODE); - void Initialize(CodeStub::Major major, int register_parameter_count, - Register* registers, Register stack_parameter_count, + void Initialize(CodeStub::Major major, + CallInterfaceDescriptor* call_descriptor, + Register stack_parameter_count, Address deoptimization_handler = NULL, - Representation* register_param_representations = NULL, int hint_stack_parameter_count = -1, StubFunctionMode function_mode = NOT_JS_FUNCTION_STUB_MODE, HandlerArgumentsMode handler_mode = DONT_PASS_ARGUMENTS); @@ -306,6 +306,38 @@ class CodeStubInterfaceDescriptor: public InterfaceDescriptor { DCHECK(!stack_parameter_count_.is_valid()); } + bool IsInitialized() const { return call_descriptor_ != NULL; } + + CallInterfaceDescriptor* call_descriptor() const { return call_descriptor_; } + + int GetEnvironmentLength() const { + return call_descriptor()->GetEnvironmentLength(); + } + + int GetRegisterParameterCount() const { + return call_descriptor()->GetRegisterParameterCount(); + } + + Register GetParameterRegister(int index) const { + return call_descriptor()->GetParameterRegister(index); + } + + Representation GetParameterRepresentation(int index) const { + return call_descriptor()->GetParameterRepresentation(index); + } + + int GetEnvironmentParameterCount() const { + return call_descriptor()->GetEnvironmentParameterCount(); + } + + Register GetEnvironmentParameterRegister(int index) const { + return call_descriptor()->GetEnvironmentParameterRegister(index); + } + + Representation GetEnvironmentParameterRepresentation(int index) const { + return call_descriptor()->GetEnvironmentParameterRepresentation(index); + } + ExternalReference miss_handler() const { DCHECK(has_miss_handler_); return miss_handler_; @@ -316,11 +348,12 @@ class CodeStubInterfaceDescriptor: public InterfaceDescriptor { } bool IsEnvironmentParameterCountRegister(int index) const { - return GetEnvironmentParameterRegister(index).is(stack_parameter_count_); + return call_descriptor()->GetEnvironmentParameterRegister(index).is( + stack_parameter_count_); } int GetHandlerParameterCount() const { - int params = GetEnvironmentParameterCount(); + int params = call_descriptor()->GetEnvironmentParameterCount(); if (handler_arguments_mode_ == PASS_ARGUMENTS) { params += 1; } @@ -334,6 +367,7 @@ class CodeStubInterfaceDescriptor: public InterfaceDescriptor { CodeStub::Major MajorKey() const { return major_; } private: + CallInterfaceDescriptor* call_descriptor_; Register stack_parameter_count_; // If hint_stack_parameter_count_ > 0, the code stub can optimize the // return sequence. Default value is -1, which means it is ignored. @@ -671,8 +705,8 @@ class InstanceofStub: public PlatformCodeStub { void Generate(MacroAssembler* masm); - static Register left(); - static Register right(); + static Register left() { return InstanceofConvention::left(); } + static Register right() { return InstanceofConvention::right(); } virtual void InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor); diff --git a/src/compiler/js-generic-lowering.cc b/src/compiler/js-generic-lowering.cc index b8cf803..f83b244 100644 --- a/src/compiler/js-generic-lowering.cc +++ b/src/compiler/js-generic-lowering.cc @@ -46,10 +46,9 @@ class LoadICStubShim : public HydrogenCodeStub { virtual void InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE { - Register registers[] = {InterfaceDescriptor::ContextRegister(), - LoadConvention::ReceiverRegister(), - LoadConvention::NameRegister()}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::LoadICCall); + descriptor->Initialize(MajorKey(), call_descriptor); } private: @@ -76,10 +75,9 @@ class KeyedLoadICStubShim : public HydrogenCodeStub { virtual void InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE { - Register registers[] = {InterfaceDescriptor::ContextRegister(), - LoadConvention::ReceiverRegister(), - LoadConvention::NameRegister()}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::LoadICCall); + descriptor->Initialize(MajorKey(), call_descriptor); } private: @@ -105,11 +103,9 @@ class StoreICStubShim : public HydrogenCodeStub { virtual void InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE { - Register registers[] = {InterfaceDescriptor::ContextRegister(), - StoreConvention::ReceiverRegister(), - StoreConvention::NameRegister(), - StoreConvention::ValueRegister()}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::StoreICCall); + descriptor->Initialize(MajorKey(), call_descriptor); } private: @@ -139,11 +135,9 @@ class KeyedStoreICStubShim : public HydrogenCodeStub { virtual void InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE { - Register registers[] = {InterfaceDescriptor::ContextRegister(), - StoreConvention::ReceiverRegister(), - StoreConvention::NameRegister(), - StoreConvention::ValueRegister()}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); + CallInterfaceDescriptor* call_descriptor = + isolate()->call_descriptor(CallDescriptorKey::StoreICCall); + descriptor->Initialize(MajorKey(), call_descriptor); } private: diff --git a/src/ia32/code-stubs-ia32.cc b/src/ia32/code-stubs-ia32.cc index 88d2c9e..25299ef 100644 --- a/src/ia32/code-stubs-ia32.cc +++ b/src/ia32/code-stubs-ia32.cc @@ -19,110 +19,6 @@ namespace v8 { namespace internal { -void FastNewClosureStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { esi, ebx }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kNewClosureFromStubFailure)->entry); -} - - -void FastNewContextStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { esi, edi }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void ToNumberStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // ToNumberStub invokes a function, and therefore needs a context. - Register registers[] = { esi, eax }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void NumberToStringStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { esi, eax }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kNumberToStringRT)->entry); -} - - -void FastCloneShallowArrayStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { esi, eax, ebx, ecx }; - Representation representations[] = { - Representation::Tagged(), - Representation::Tagged(), - Representation::Smi(), - Representation::Tagged() }; - - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kCreateArrayLiteralStubBailout)->entry, - representations); -} - - -void FastCloneShallowObjectStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { esi, eax, ebx, ecx, edx }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kCreateObjectLiteral)->entry); -} - - -void CreateAllocationSiteStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { esi, ebx, edx }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void CallFunctionStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = {esi, edi}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void CallConstructStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // eax : number of arguments - // ebx : feedback vector - // edx : (only if ebx is not the megamorphic symbol) slot in feedback - // vector (Smi) - // edi : constructor function - // TODO(turbofan): So far we don't gather type feedback and hence skip the - // slot parameter, but ArrayConstructStub needs the vector to be undefined. - Register registers[] = {esi, eax, edi, ebx}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void RegExpConstructResultStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { esi, ecx, ebx, eax }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kRegExpConstructResult)->entry); -} - - -void TransitionElementsKindStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { esi, eax, ebx }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kTransitionElementsKind)->entry); -} - - static void InitializeArrayConstructorDescriptor( Isolate* isolate, CodeStub::Major major, CodeStubInterfaceDescriptor* descriptor, @@ -135,20 +31,15 @@ static void InitializeArrayConstructorDescriptor( Runtime::kArrayConstructor)->entry; if (constant_stack_parameter_count == 0) { - Register registers[] = { esi, edi, ebx }; - descriptor->Initialize(major, arraysize(registers), registers, - deopt_handler, NULL, constant_stack_parameter_count, + CallInterfaceDescriptor* call_descriptor = isolate->call_descriptor( + CallDescriptorKey::ArrayConstructorConstantArgCountCall); + descriptor->Initialize(major, call_descriptor, deopt_handler, + constant_stack_parameter_count, JS_FUNCTION_STUB_MODE); } else { - // stack param count needs (constructor pointer, and single argument) - Register registers[] = { esi, edi, ebx, eax }; - Representation representations[] = { - Representation::Tagged(), - Representation::Tagged(), - Representation::Tagged(), - Representation::Integer32() }; - descriptor->Initialize(major, arraysize(registers), registers, eax, - deopt_handler, representations, + CallInterfaceDescriptor* call_descriptor = + isolate->call_descriptor(CallDescriptorKey::ArrayConstructorCall); + descriptor->Initialize(major, call_descriptor, eax, deopt_handler, constant_stack_parameter_count, JS_FUNCTION_STUB_MODE, PASS_ARGUMENTS); } @@ -156,7 +47,8 @@ static void InitializeArrayConstructorDescriptor( static void InitializeInternalArrayConstructorDescriptor( - CodeStub::Major major, CodeStubInterfaceDescriptor* descriptor, + Isolate* isolate, CodeStub::Major major, + CodeStubInterfaceDescriptor* descriptor, int constant_stack_parameter_count) { // register state // eax -- number of arguments @@ -165,19 +57,15 @@ static void InitializeInternalArrayConstructorDescriptor( Runtime::kInternalArrayConstructor)->entry; if (constant_stack_parameter_count == 0) { - Register registers[] = { esi, edi }; - descriptor->Initialize(major, arraysize(registers), registers, - deopt_handler, NULL, constant_stack_parameter_count, + CallInterfaceDescriptor* call_descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorConstantArgCountCall); + descriptor->Initialize(major, call_descriptor, deopt_handler, + constant_stack_parameter_count, JS_FUNCTION_STUB_MODE); } else { - // stack param count needs (constructor pointer, and single argument) - Register registers[] = { esi, edi, eax }; - Representation representations[] = { - Representation::Tagged(), - Representation::Tagged(), - Representation::Integer32() }; - descriptor->Initialize(major, arraysize(registers), registers, eax, - deopt_handler, representations, + CallInterfaceDescriptor* call_descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorCall); + descriptor->Initialize(major, call_descriptor, eax, deopt_handler, constant_stack_parameter_count, JS_FUNCTION_STUB_MODE, PASS_ARGUMENTS); } @@ -204,64 +92,22 @@ void ArrayNArgumentsConstructorStub::InitializeInterfaceDescriptor( void InternalArrayNoArgumentConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeInternalArrayConstructorDescriptor(MajorKey(), descriptor, 0); + InitializeInternalArrayConstructorDescriptor(isolate(), MajorKey(), + descriptor, 0); } void InternalArraySingleArgumentConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeInternalArrayConstructorDescriptor(MajorKey(), descriptor, 1); + InitializeInternalArrayConstructorDescriptor(isolate(), MajorKey(), + descriptor, 1); } void InternalArrayNArgumentsConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeInternalArrayConstructorDescriptor(MajorKey(), descriptor, -1); -} - - -void CompareNilICStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { esi, eax }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(CompareNilIC_Miss)); - descriptor->SetMissHandler( - ExternalReference(IC_Utility(IC::kCompareNilIC_Miss), isolate())); -} - -void ToBooleanStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { esi, eax }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(ToBooleanIC_Miss)); - descriptor->SetMissHandler( - ExternalReference(IC_Utility(IC::kToBooleanIC_Miss), isolate())); -} - - -void BinaryOpICStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { esi, edx, eax }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(BinaryOpIC_Miss)); - descriptor->SetMissHandler( - ExternalReference(IC_Utility(IC::kBinaryOpIC_Miss), isolate())); -} - - -void BinaryOpWithAllocationSiteStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { esi, ecx, edx, eax }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(BinaryOpIC_MissWithAllocationSite)); -} - - -void StringAddStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { esi, edx, eax }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kStringAdd)->entry); + InitializeInternalArrayConstructorDescriptor(isolate(), MajorKey(), + descriptor, -1); } @@ -2888,12 +2734,6 @@ void InstanceofStub::Generate(MacroAssembler* masm) { } -Register InstanceofStub::left() { return eax; } - - -Register InstanceofStub::right() { return edx; } - - // ------------------------------------------------------------------------- // StringCharCodeAtGenerator diff --git a/src/ia32/interface-descriptors-ia32.cc b/src/ia32/interface-descriptors-ia32.cc index 3d3b7a0..9f7cf26 100644 --- a/src/ia32/interface-descriptors-ia32.cc +++ b/src/ia32/interface-descriptors-ia32.cc @@ -6,6 +6,7 @@ #if V8_TARGET_ARCH_IA32 +#include "src/ic/ic-conventions.h" #include "src/interface-descriptors.h" namespace v8 { @@ -15,6 +16,155 @@ const Register InterfaceDescriptor::ContextRegister() { return esi; } void CallDescriptors::InitializeForIsolate(Isolate* isolate) { + InitializeForIsolateAllPlatforms(isolate); + + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastNewClosureCall); + Register registers[] = {esi, ebx}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastNewContextCall); + Register registers[] = {esi, edi}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::ToNumberCall); + // ToNumberStub invokes a function, and therefore needs a context. + Register registers[] = {esi, eax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::NumberToStringCall); + Register registers[] = {esi, eax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastCloneShallowArrayCall); + Register registers[] = {esi, eax, ebx, ecx}; + Representation representations[] = { + Representation::Tagged(), Representation::Tagged(), + Representation::Smi(), Representation::Tagged()}; + descriptor->Initialize(arraysize(registers), registers, representations); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastCloneShallowObjectCall); + Register registers[] = {esi, eax, ebx, ecx, edx}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CreateAllocationSiteCall); + Register registers[] = {esi, ebx, edx}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CallFunctionCall); + Register registers[] = {esi, edi}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CallConstructCall); + // eax : number of arguments + // ebx : feedback vector + // edx : (only if ebx is not the megamorphic symbol) slot in feedback + // vector (Smi) + // edi : constructor function + // TODO(turbofan): So far we don't gather type feedback and hence skip the + // slot parameter, but ArrayConstructStub needs the vector to be undefined. + Register registers[] = {esi, eax, edi, ebx}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::RegExpConstructResultCall); + Register registers[] = {esi, ecx, ebx, eax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::TransitionElementsKindCall); + Register registers[] = {esi, eax, ebx}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::ArrayConstructorConstantArgCountCall); + // register state + // eax -- number of arguments + // edi -- function + // ebx -- allocation site with elements kind + Register registers[] = {esi, edi, ebx}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::ArrayConstructorCall); + // stack param count needs (constructor pointer, and single argument) + Register registers[] = {esi, edi, ebx, eax}; + Representation representations[] = { + Representation::Tagged(), Representation::Tagged(), + Representation::Tagged(), Representation::Integer32()}; + descriptor->Initialize(arraysize(registers), registers, representations); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorConstantArgCountCall); + // register state + // eax -- number of arguments + // edi -- function + Register registers[] = {esi, edi}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorCall); + // stack param count needs (constructor pointer, and single argument) + Register registers[] = {esi, edi, eax}; + Representation representations[] = {Representation::Tagged(), + Representation::Tagged(), + Representation::Integer32()}; + descriptor->Initialize(arraysize(registers), registers, representations); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CompareNilCall); + Register registers[] = {esi, eax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::ToBooleanCall); + Register registers[] = {esi, eax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::BinaryOpCall); + Register registers[] = {esi, edx, eax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::BinaryOpWithAllocationSiteCall); + Register registers[] = {esi, ecx, edx, eax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::StringAddCall); + Register registers[] = {esi, edx, eax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { CallInterfaceDescriptor* descriptor = isolate->call_descriptor(CallDescriptorKey::ArgumentAdaptorCall); diff --git a/src/ic/arm/ic-conventions-arm.cc b/src/ic/arm/ic-conventions-arm.cc index 5e22858..6192cba 100644 --- a/src/ic/arm/ic-conventions-arm.cc +++ b/src/ic/arm/ic-conventions-arm.cc @@ -17,24 +17,20 @@ const Register LoadConvention::ReceiverRegister() { return r1; } const Register LoadConvention::NameRegister() { return r2; } -const Register VectorLoadConvention::SlotRegister() { - DCHECK(FLAG_vector_ics); - return r0; -} +const Register VectorLoadConvention::SlotRegister() { return r0; } -const Register FullVectorLoadConvention::VectorRegister() { - DCHECK(FLAG_vector_ics); - return r3; -} +const Register FullVectorLoadConvention::VectorRegister() { return r3; } const Register StoreConvention::ReceiverRegister() { return r1; } const Register StoreConvention::NameRegister() { return r2; } const Register StoreConvention::ValueRegister() { return r0; } +const Register StoreConvention::MapRegister() { return r3; } -const Register StoreConvention::MapRegister() { return r3; } +const Register InstanceofConvention::left() { return r0; } +const Register InstanceofConvention::right() { return r1; } } } // namespace v8::internal diff --git a/src/ic/arm64/ic-conventions-arm64.cc b/src/ic/arm64/ic-conventions-arm64.cc index 53c846e..4de2a57 100644 --- a/src/ic/arm64/ic-conventions-arm64.cc +++ b/src/ic/arm64/ic-conventions-arm64.cc @@ -16,16 +16,11 @@ namespace internal { const Register LoadConvention::ReceiverRegister() { return x1; } const Register LoadConvention::NameRegister() { return x2; } -const Register VectorLoadConvention::SlotRegister() { - DCHECK(FLAG_vector_ics); - return x0; -} +const Register VectorLoadConvention::SlotRegister() { return x0; } -const Register FullVectorLoadConvention::VectorRegister() { - DCHECK(FLAG_vector_ics); - return x3; -} + +const Register FullVectorLoadConvention::VectorRegister() { return x3; } const Register StoreConvention::ReceiverRegister() { return x1; } @@ -34,6 +29,18 @@ const Register StoreConvention::ValueRegister() { return x0; } const Register StoreConvention::MapRegister() { return x3; } + + +const Register InstanceofConvention::left() { + // Object to check (instanceof lhs). + return x11; +} + + +const Register InstanceofConvention::right() { + // Constructor function (instanceof rhs). + return x10; +} } } // namespace v8::internal diff --git a/src/ic/ia32/ic-conventions-ia32.cc b/src/ic/ia32/ic-conventions-ia32.cc index cef55e9..cafd86d 100644 --- a/src/ic/ia32/ic-conventions-ia32.cc +++ b/src/ic/ia32/ic-conventions-ia32.cc @@ -18,22 +18,20 @@ const Register LoadConvention::ReceiverRegister() { return edx; } const Register LoadConvention::NameRegister() { return ecx; } -const Register VectorLoadConvention::SlotRegister() { - DCHECK(FLAG_vector_ics); - return eax; -} +const Register VectorLoadConvention::SlotRegister() { return eax; } -const Register FullVectorLoadConvention::VectorRegister() { - DCHECK(FLAG_vector_ics); - return ebx; -} +const Register FullVectorLoadConvention::VectorRegister() { return ebx; } const Register StoreConvention::ReceiverRegister() { return edx; } const Register StoreConvention::NameRegister() { return ecx; } const Register StoreConvention::ValueRegister() { return eax; } const Register StoreConvention::MapRegister() { return ebx; } + + +const Register InstanceofConvention::left() { return eax; } +const Register InstanceofConvention::right() { return edx; } } } // namespace v8::internal diff --git a/src/ic/ic-conventions.h b/src/ic/ic-conventions.h index 35ef65d..28d4d66 100644 --- a/src/ic/ic-conventions.h +++ b/src/ic/ic-conventions.h @@ -58,6 +58,14 @@ class StoreConvention { // stub implementations requires it to be initialized. static const Register MapRegister(); }; + + +class InstanceofConvention { + public: + enum ParameterIndices { kLeftIndex, kRightIndex, kParameterCount }; + static const Register left(); + static const Register right(); +}; } } // namespace v8::internal diff --git a/src/ic/x64/ic-conventions-x64.cc b/src/ic/x64/ic-conventions-x64.cc index cd19f3f..0873da5 100644 --- a/src/ic/x64/ic-conventions-x64.cc +++ b/src/ic/x64/ic-conventions-x64.cc @@ -17,24 +17,21 @@ const Register LoadConvention::ReceiverRegister() { return rdx; } const Register LoadConvention::NameRegister() { return rcx; } -const Register VectorLoadConvention::SlotRegister() { - DCHECK(FLAG_vector_ics); - return rax; -} +const Register VectorLoadConvention::SlotRegister() { return rax; } -const Register FullVectorLoadConvention::VectorRegister() { - DCHECK(FLAG_vector_ics); - return rbx; -} +const Register FullVectorLoadConvention::VectorRegister() { return rbx; } const Register StoreConvention::ReceiverRegister() { return rdx; } const Register StoreConvention::NameRegister() { return rcx; } const Register StoreConvention::ValueRegister() { return rax; } +const Register StoreConvention::MapRegister() { return rbx; } -const Register StoreConvention::MapRegister() { return rbx; } +// Passing arguments in registers is not supported. +const Register InstanceofConvention::left() { return rax; } +const Register InstanceofConvention::right() { return rdx; } } } // namespace v8::internal diff --git a/src/interface-descriptors.cc b/src/interface-descriptors.cc index dd0be43..2324c62 100644 --- a/src/interface-descriptors.cc +++ b/src/interface-descriptors.cc @@ -4,6 +4,7 @@ #include "src/v8.h" +#include "src/ic/ic-conventions.h" #include "src/interface-descriptors.h" namespace v8 { @@ -51,5 +52,53 @@ void CallInterfaceDescriptor::Initialize( InterfaceDescriptor::Initialize(register_parameter_count, registers, param_representations, platform_descriptor); } + + +void CallDescriptors::InitializeForIsolateAllPlatforms(Isolate* isolate) { + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::LoadICCall); + Register registers[] = {InterfaceDescriptor::ContextRegister(), + LoadConvention::ReceiverRegister(), + LoadConvention::NameRegister()}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::StoreICCall); + Register registers[] = {InterfaceDescriptor::ContextRegister(), + StoreConvention::ReceiverRegister(), + StoreConvention::NameRegister(), + StoreConvention::ValueRegister()}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::ElementTransitionAndStoreCall); + Register registers[] = { + InterfaceDescriptor::ContextRegister(), + StoreConvention::ValueRegister(), StoreConvention::MapRegister(), + StoreConvention::NameRegister(), StoreConvention::ReceiverRegister()}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::InstanceofCall); + Register registers[] = {InterfaceDescriptor::ContextRegister(), + InstanceofConvention::left(), + InstanceofConvention::right()}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::VectorLoadICCall); + Register registers[] = {InterfaceDescriptor::ContextRegister(), + FullVectorLoadConvention::ReceiverRegister(), + FullVectorLoadConvention::NameRegister(), + FullVectorLoadConvention::SlotRegister(), + FullVectorLoadConvention::VectorRegister()}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } +} } } // namespace v8::internal diff --git a/src/interface-descriptors.h b/src/interface-descriptors.h index 97dc272..639b1f0 100644 --- a/src/interface-descriptors.h +++ b/src/interface-descriptors.h @@ -84,6 +84,31 @@ class InterfaceDescriptor { enum CallDescriptorKey { + LoadICCall, + StoreICCall, + ElementTransitionAndStoreCall, + InstanceofCall, + VectorLoadICCall, + FastNewClosureCall, + FastNewContextCall, + ToNumberCall, + NumberToStringCall, + FastCloneShallowArrayCall, + FastCloneShallowObjectCall, + CreateAllocationSiteCall, + CallFunctionCall, + CallConstructCall, + RegExpConstructResultCall, + TransitionElementsKindCall, + ArrayConstructorConstantArgCountCall, + ArrayConstructorCall, + InternalArrayConstructorConstantArgCountCall, + InternalArrayConstructorCall, + CompareNilCall, + ToBooleanCall, + BinaryOpCall, + BinaryOpWithAllocationSiteCall, + StringAddCall, KeyedCall, NamedCall, CallHandler, @@ -113,6 +138,9 @@ class CallInterfaceDescriptor : public InterfaceDescriptor { class CallDescriptors { public: static void InitializeForIsolate(Isolate* isolate); + + private: + static void InitializeForIsolateAllPlatforms(Isolate* isolate); }; } } // namespace v8::internal diff --git a/src/isolate.cc b/src/isolate.cc index f049208..2a8b7b2 100644 --- a/src/isolate.cc +++ b/src/isolate.cc @@ -1917,6 +1917,8 @@ bool Isolate::Init(Deserializer* des) { deoptimizer_data_ = new DeoptimizerData(memory_allocator_); + CallDescriptors::InitializeForIsolate(this); + const bool create_heap_objects = (des == NULL); if (create_heap_objects && !heap_.CreateHeapObjects()) { V8::FatalProcessOutOfMemory("heap object creation"); @@ -2027,8 +2029,6 @@ bool Isolate::Init(Deserializer* des) { kDeoptTableSerializeEntryCount - 1); } - CallDescriptors::InitializeForIsolate(this); - if (!serializer_enabled()) { // Ensure that all stubs which need to be generated ahead of time, but // cannot be serialized into the snapshot have been generated. diff --git a/src/x64/code-stubs-x64.cc b/src/x64/code-stubs-x64.cc index 3a50e63..3f364e7 100644 --- a/src/x64/code-stubs-x64.cc +++ b/src/x64/code-stubs-x64.cc @@ -19,134 +19,23 @@ namespace v8 { namespace internal { -void FastNewClosureStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { rsi, rbx }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kNewClosureFromStubFailure)->entry); -} - - -void FastNewContextStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { rsi, rdi }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void ToNumberStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { rsi, rax }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void NumberToStringStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { rsi, rax }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kNumberToStringRT)->entry); -} - - -void FastCloneShallowArrayStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { rsi, rax, rbx, rcx }; - Representation representations[] = { - Representation::Tagged(), - Representation::Tagged(), - Representation::Smi(), - Representation::Tagged() }; - - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kCreateArrayLiteralStubBailout)->entry, - representations); -} - - -void FastCloneShallowObjectStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { rsi, rax, rbx, rcx, rdx }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kCreateObjectLiteral)->entry); -} - - -void CreateAllocationSiteStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { rsi, rbx, rdx }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void CallFunctionStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = {rsi, rdi}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void CallConstructStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - // rax : number of arguments - // rbx : feedback vector - // rdx : (only if rbx is not the megamorphic symbol) slot in feedback - // vector (Smi) - // rdi : constructor function - // TODO(turbofan): So far we don't gather type feedback and hence skip the - // slot parameter, but ArrayConstructStub needs the vector to be undefined. - Register registers[] = {rsi, rax, rdi, rbx}; - descriptor->Initialize(MajorKey(), arraysize(registers), registers); -} - - -void RegExpConstructResultStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { rsi, rcx, rbx, rax }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kRegExpConstructResult)->entry); -} - - -void TransitionElementsKindStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { rsi, rax, rbx }; - descriptor->Initialize( - MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kTransitionElementsKind)->entry); -} - - static void InitializeArrayConstructorDescriptor( - CodeStub::Major major, CodeStubInterfaceDescriptor* descriptor, + Isolate* isolate, CodeStub::Major major, + CodeStubInterfaceDescriptor* descriptor, int constant_stack_parameter_count) { - // register state - // rax -- number of arguments - // rdi -- function - // rbx -- allocation site with elements kind Address deopt_handler = Runtime::FunctionForId( Runtime::kArrayConstructor)->entry; if (constant_stack_parameter_count == 0) { - Register registers[] = { rsi, rdi, rbx }; - descriptor->Initialize(major, arraysize(registers), registers, - deopt_handler, NULL, constant_stack_parameter_count, + CallInterfaceDescriptor* call_descriptor = isolate->call_descriptor( + CallDescriptorKey::ArrayConstructorConstantArgCountCall); + descriptor->Initialize(major, call_descriptor, deopt_handler, + constant_stack_parameter_count, JS_FUNCTION_STUB_MODE); } else { - // stack param count needs (constructor pointer, and single argument) - Register registers[] = { rsi, rdi, rbx, rax }; - Representation representations[] = { - Representation::Tagged(), - Representation::Tagged(), - Representation::Tagged(), - Representation::Integer32() }; - descriptor->Initialize(major, arraysize(registers), registers, rax, - deopt_handler, representations, + CallInterfaceDescriptor* call_descriptor = + isolate->call_descriptor(CallDescriptorKey::ArrayConstructorCall); + descriptor->Initialize(major, call_descriptor, rax, deopt_handler, constant_stack_parameter_count, JS_FUNCTION_STUB_MODE, PASS_ARGUMENTS); } @@ -154,7 +43,8 @@ static void InitializeArrayConstructorDescriptor( static void InitializeInternalArrayConstructorDescriptor( - CodeStub::Major major, CodeStubInterfaceDescriptor* descriptor, + Isolate* isolate, CodeStub::Major major, + CodeStubInterfaceDescriptor* descriptor, int constant_stack_parameter_count) { // register state // rsi -- context @@ -164,19 +54,15 @@ static void InitializeInternalArrayConstructorDescriptor( Runtime::kInternalArrayConstructor)->entry; if (constant_stack_parameter_count == 0) { - Register registers[] = { rsi, rdi }; - descriptor->Initialize(major, arraysize(registers), registers, - deopt_handler, NULL, constant_stack_parameter_count, + CallInterfaceDescriptor* call_descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorConstantArgCountCall); + descriptor->Initialize(major, call_descriptor, deopt_handler, + constant_stack_parameter_count, JS_FUNCTION_STUB_MODE); } else { - // stack param count needs (constructor pointer, and single argument) - Register registers[] = { rsi, rdi, rax }; - Representation representations[] = { - Representation::Tagged(), - Representation::Tagged(), - Representation::Integer32() }; - descriptor->Initialize(major, arraysize(registers), registers, rax, - deopt_handler, representations, + CallInterfaceDescriptor* call_descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorCall); + descriptor->Initialize(major, call_descriptor, rax, deopt_handler, constant_stack_parameter_count, JS_FUNCTION_STUB_MODE, PASS_ARGUMENTS); } @@ -185,83 +71,40 @@ static void InitializeInternalArrayConstructorDescriptor( void ArrayNoArgumentConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeArrayConstructorDescriptor(MajorKey(), descriptor, 0); + InitializeArrayConstructorDescriptor(isolate(), MajorKey(), descriptor, 0); } void ArraySingleArgumentConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeArrayConstructorDescriptor(MajorKey(), descriptor, 1); + InitializeArrayConstructorDescriptor(isolate(), MajorKey(), descriptor, 1); } void ArrayNArgumentsConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeArrayConstructorDescriptor(MajorKey(), descriptor, -1); + InitializeArrayConstructorDescriptor(isolate(), MajorKey(), descriptor, -1); } void InternalArrayNoArgumentConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeInternalArrayConstructorDescriptor(MajorKey(), descriptor, 0); + InitializeInternalArrayConstructorDescriptor(isolate(), MajorKey(), + descriptor, 0); } void InternalArraySingleArgumentConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeInternalArrayConstructorDescriptor(MajorKey(), descriptor, 1); + InitializeInternalArrayConstructorDescriptor(isolate(), MajorKey(), + descriptor, 1); } void InternalArrayNArgumentsConstructorStub::InitializeInterfaceDescriptor( CodeStubInterfaceDescriptor* descriptor) { - InitializeInternalArrayConstructorDescriptor(MajorKey(), descriptor, -1); -} - - -void CompareNilICStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { rsi, rax }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(CompareNilIC_Miss)); - descriptor->SetMissHandler( - ExternalReference(IC_Utility(IC::kCompareNilIC_Miss), isolate())); -} - - -void ToBooleanStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { rsi, rax }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(ToBooleanIC_Miss)); - descriptor->SetMissHandler( - ExternalReference(IC_Utility(IC::kToBooleanIC_Miss), isolate())); -} - - -void BinaryOpICStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { rsi, rdx, rax }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(BinaryOpIC_Miss)); - descriptor->SetMissHandler( - ExternalReference(IC_Utility(IC::kBinaryOpIC_Miss), isolate())); -} - - -void BinaryOpWithAllocationSiteStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { rsi, rcx, rdx, rax }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - FUNCTION_ADDR(BinaryOpIC_MissWithAllocationSite)); -} - - -void StringAddStub::InitializeInterfaceDescriptor( - CodeStubInterfaceDescriptor* descriptor) { - Register registers[] = { rsi, rdx, rax }; - descriptor->Initialize(MajorKey(), arraysize(registers), registers, - Runtime::FunctionForId(Runtime::kStringAdd)->entry); + InitializeInternalArrayConstructorDescriptor(isolate(), MajorKey(), + descriptor, -1); } @@ -2858,13 +2701,6 @@ void InstanceofStub::Generate(MacroAssembler* masm) { } -// Passing arguments in registers is not supported. -Register InstanceofStub::left() { return rax; } - - -Register InstanceofStub::right() { return rdx; } - - // ------------------------------------------------------------------------- // StringCharCodeAtGenerator diff --git a/src/x64/interface-descriptors-x64.cc b/src/x64/interface-descriptors-x64.cc index 27737ec..dfb8c4d 100644 --- a/src/x64/interface-descriptors-x64.cc +++ b/src/x64/interface-descriptors-x64.cc @@ -15,6 +15,156 @@ const Register InterfaceDescriptor::ContextRegister() { return rsi; } void CallDescriptors::InitializeForIsolate(Isolate* isolate) { + InitializeForIsolateAllPlatforms(isolate); + + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastNewClosureCall); + Register registers[] = {rsi, rbx}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastNewContextCall); + Register registers[] = {rsi, rdi}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::ToNumberCall); + // ToNumberStub invokes a function, and therefore needs a context. + Register registers[] = {rsi, rax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::NumberToStringCall); + Register registers[] = {rsi, rax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastCloneShallowArrayCall); + Register registers[] = {rsi, rax, rbx, rcx}; + Representation representations[] = { + Representation::Tagged(), Representation::Tagged(), + Representation::Smi(), Representation::Tagged()}; + descriptor->Initialize(arraysize(registers), registers, representations); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::FastCloneShallowObjectCall); + Register registers[] = {rsi, rax, rbx, rcx, rdx}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CreateAllocationSiteCall); + Register registers[] = {rsi, rbx, rdx}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CallFunctionCall); + Register registers[] = {rsi, rdi}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CallConstructCall); + // rax : number of arguments + // rbx : feedback vector + // rdx : (only if rbx is not the megamorphic symbol) slot in feedback + // vector (Smi) + // rdi : constructor function + // TODO(turbofan): So far we don't gather type feedback and hence skip the + // slot parameter, but ArrayConstructStub needs the vector to be undefined. + Register registers[] = {rsi, rax, rdi, rbx}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::RegExpConstructResultCall); + Register registers[] = {rsi, rcx, rbx, rax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::TransitionElementsKindCall); + Register registers[] = {rsi, rax, rbx}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::ArrayConstructorConstantArgCountCall); + // register state + // rax -- number of arguments + // rdi -- function + // rbx -- allocation site with elements kind + Register registers[] = {rsi, rdi, rbx}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::ArrayConstructorCall); + // stack param count needs (constructor pointer, and single argument) + Register registers[] = {rsi, rdi, rbx, rax}; + Representation representations[] = { + Representation::Tagged(), Representation::Tagged(), + Representation::Tagged(), Representation::Integer32()}; + descriptor->Initialize(arraysize(registers), registers, representations); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorConstantArgCountCall); + // register state + // rsi -- context + // rax -- number of arguments + // rdi -- constructor function + Register registers[] = {rsi, rdi}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::InternalArrayConstructorCall); + // stack param count needs (constructor pointer, and single argument) + Register registers[] = {rsi, rdi, rax}; + Representation representations[] = {Representation::Tagged(), + Representation::Tagged(), + Representation::Integer32()}; + descriptor->Initialize(arraysize(registers), registers, representations); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::CompareNilCall); + Register registers[] = {rsi, rax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::ToBooleanCall); + Register registers[] = {rsi, rax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::BinaryOpCall); + Register registers[] = {rsi, rdx, rax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = isolate->call_descriptor( + CallDescriptorKey::BinaryOpWithAllocationSiteCall); + Register registers[] = {rsi, rcx, rdx, rax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { + CallInterfaceDescriptor* descriptor = + isolate->call_descriptor(CallDescriptorKey::StringAddCall); + Register registers[] = {rsi, rdx, rax}; + descriptor->Initialize(arraysize(registers), registers, NULL); + } + { CallInterfaceDescriptor* descriptor = isolate->call_descriptor(CallDescriptorKey::ArgumentAdaptorCall); -- 2.7.4