Revision: 23546
Author: [email protected]
Date: Mon Sep 1 09:18:39 2014 UTC
Log: Multiple stubs can point to the same calling convention.
[email protected]
Review URL: https://codereview.chromium.org/523583002
https://code.google.com/p/v8/source/detail?r=23546
Modified:
/branches/bleeding_edge/src/arm/code-stubs-arm.cc
/branches/bleeding_edge/src/arm/interface-descriptors-arm.cc
/branches/bleeding_edge/src/arm64/code-stubs-arm64.cc
/branches/bleeding_edge/src/arm64/interface-descriptors-arm64.cc
/branches/bleeding_edge/src/code-stubs.cc
/branches/bleeding_edge/src/code-stubs.h
/branches/bleeding_edge/src/compiler/js-generic-lowering.cc
/branches/bleeding_edge/src/ia32/code-stubs-ia32.cc
/branches/bleeding_edge/src/ia32/interface-descriptors-ia32.cc
/branches/bleeding_edge/src/ic/arm/ic-conventions-arm.cc
/branches/bleeding_edge/src/ic/arm64/ic-conventions-arm64.cc
/branches/bleeding_edge/src/ic/ia32/ic-conventions-ia32.cc
/branches/bleeding_edge/src/ic/ic-conventions.h
/branches/bleeding_edge/src/ic/x64/ic-conventions-x64.cc
/branches/bleeding_edge/src/interface-descriptors.cc
/branches/bleeding_edge/src/interface-descriptors.h
/branches/bleeding_edge/src/isolate.cc
/branches/bleeding_edge/src/x64/code-stubs-x64.cc
/branches/bleeding_edge/src/x64/interface-descriptors-x64.cc
=======================================
--- /branches/bleeding_edge/src/arm/code-stubs-arm.cc Fri Aug 29 10:40:02
2014 UTC
+++ /branches/bleeding_edge/src/arm/code-stubs-arm.cc Mon Sep 1 09:18:39
2014 UTC
@@ -17,148 +17,25 @@
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 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 @@
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);
}
@@ -1795,12 +1632,6 @@
PropertyAccessCompiler::TailCallBuiltin(
masm, PropertyAccessCompiler::MissBuiltin(Code::LOAD_IC));
}
-
-
-Register InstanceofStub::left() { return r0; }
-
-
-Register InstanceofStub::right() { return r1; }
void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) {
=======================================
--- /branches/bleeding_edge/src/arm/interface-descriptors-arm.cc Fri Aug 29
10:40:02 2014 UTC
+++ /branches/bleeding_edge/src/arm/interface-descriptors-arm.cc Mon Sep 1
09:18:39 2014 UTC
@@ -20,6 +20,156 @@
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 =
=======================================
--- /branches/bleeding_edge/src/arm64/code-stubs-arm64.cc Fri Aug 29
10:40:02 2014 UTC
+++ /branches/bleeding_edge/src/arm64/code-stubs-arm64.cc Mon Sep 1
09:18:39 2014 UTC
@@ -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 @@
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 @@
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 @@
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);
}
@@ -1816,18 +1620,6 @@
}
__ Ret();
}
-
-
-Register InstanceofStub::left() {
- // Object to check (instanceof lhs).
- return x11;
-}
-
-
-Register InstanceofStub::right() {
- // Constructor function (instanceof rhs).
- return x10;
-}
void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) {
=======================================
--- /branches/bleeding_edge/src/arm64/interface-descriptors-arm64.cc Fri
Aug 29 10:40:02 2014 UTC
+++ /branches/bleeding_edge/src/arm64/interface-descriptors-arm64.cc Mon
Sep 1 09:18:39 2014 UTC
@@ -20,6 +20,195 @@
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 =
=======================================
--- /branches/bleeding_edge/src/code-stubs.cc Fri Aug 29 10:40:02 2014 UTC
+++ /branches/bleeding_edge/src/code-stubs.cc Mon Sep 1 09:18:39 2014 UTC
@@ -17,25 +17,22 @@
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(
- 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 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 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 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,9 +619,159 @@
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) {
=======================================
--- /branches/bleeding_edge/src/code-stubs.h Fri Aug 29 10:40:02 2014 UTC
+++ /branches/bleeding_edge/src/code-stubs.h Mon Sep 1 09:18:39 2014 UTC
@@ -281,19 +281,19 @@
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);
@@ -305,6 +305,38 @@
// variable stack parameter counts.
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_);
@@ -316,11 +348,12 @@
}
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 @@
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 @@
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);
=======================================
--- /branches/bleeding_edge/src/compiler/js-generic-lowering.cc Fri Aug 29
15:01:50 2014 UTC
+++ /branches/bleeding_edge/src/compiler/js-generic-lowering.cc Mon Sep 1
09:18:39 2014 UTC
@@ -46,10 +46,9 @@
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 @@
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 @@
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 @@
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:
=======================================
--- /branches/bleeding_edge/src/ia32/code-stubs-ia32.cc Fri Aug 29 10:40:02
2014 UTC
+++ /branches/bleeding_edge/src/ia32/code-stubs-ia32.cc Mon Sep 1 09:18:39
2014 UTC
@@ -17,110 +17,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(
@@ -135,20 +31,15 @@
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 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 @@
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,66 +92,24 @@
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()));
+ InitializeInternalArrayConstructorDescriptor(isolate(), MajorKey(),
+ descriptor, -1);
}
-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);
-}
-
#define __ ACCESS_MASM(masm)
@@ -2886,12 +2732,6 @@
__ ret((HasArgsInRegisters() ? 0 : 2) * kPointerSize);
}
}
-
-
-Register InstanceofStub::left() { return eax; }
-
-
-Register InstanceofStub::right() { return edx; }
//
-------------------------------------------------------------------------
=======================================
--- /branches/bleeding_edge/src/ia32/interface-descriptors-ia32.cc Fri Aug
29 10:40:02 2014 UTC
+++ /branches/bleeding_edge/src/ia32/interface-descriptors-ia32.cc Mon Sep
1 09:18:39 2014 UTC
@@ -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 @@
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);
=======================================
--- /branches/bleeding_edge/src/ic/arm/ic-conventions-arm.cc Tue Aug 26
09:50:09 2014 UTC
+++ /branches/bleeding_edge/src/ic/arm/ic-conventions-arm.cc Mon Sep 1
09:18:39 2014 UTC
@@ -17,24 +17,20 @@
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
=======================================
--- /branches/bleeding_edge/src/ic/arm64/ic-conventions-arm64.cc Tue Aug 26
09:50:09 2014 UTC
+++ /branches/bleeding_edge/src/ic/arm64/ic-conventions-arm64.cc Mon Sep 1
09:18:39 2014 UTC
@@ -16,17 +16,12 @@
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; }
const Register StoreConvention::NameRegister() { return x2; }
@@ -34,6 +29,18 @@
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
=======================================
--- /branches/bleeding_edge/src/ic/ia32/ic-conventions-ia32.cc Tue Aug 26
09:50:09 2014 UTC
+++ /branches/bleeding_edge/src/ic/ia32/ic-conventions-ia32.cc Mon Sep 1
09:18:39 2014 UTC
@@ -18,22 +18,20 @@
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
=======================================
--- /branches/bleeding_edge/src/ic/ic-conventions.h Tue Aug 26 09:50:09
2014 UTC
+++ /branches/bleeding_edge/src/ic/ic-conventions.h Mon Sep 1 09:18:39
2014 UTC
@@ -58,6 +58,14 @@
// 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
=======================================
--- /branches/bleeding_edge/src/ic/x64/ic-conventions-x64.cc Tue Aug 26
09:50:09 2014 UTC
+++ /branches/bleeding_edge/src/ic/x64/ic-conventions-x64.cc Mon Sep 1
09:18:39 2014 UTC
@@ -17,24 +17,21 @@
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
=======================================
--- /branches/bleeding_edge/src/interface-descriptors.cc Fri Aug 29
10:40:02 2014 UTC
+++ /branches/bleeding_edge/src/interface-descriptors.cc Mon Sep 1
09:18:39 2014 UTC
@@ -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 @@
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
=======================================
--- /branches/bleeding_edge/src/interface-descriptors.h Fri Aug 29 10:40:02
2014 UTC
+++ /branches/bleeding_edge/src/interface-descriptors.h Mon Sep 1 09:18:39
2014 UTC
@@ -84,6 +84,31 @@
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 CallDescriptors {
public:
static void InitializeForIsolate(Isolate* isolate);
+
+ private:
+ static void InitializeForIsolateAllPlatforms(Isolate* isolate);
};
}
} // namespace v8::internal
=======================================
--- /branches/bleeding_edge/src/isolate.cc Mon Sep 1 09:11:44 2014 UTC
+++ /branches/bleeding_edge/src/isolate.cc Mon Sep 1 09:18:39 2014 UTC
@@ -1917,6 +1917,8 @@
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");
@@ -2026,8 +2028,6 @@
Deoptimizer::LAZY,
kDeoptTableSerializeEntryCount - 1);
}
-
- CallDescriptors::InitializeForIsolate(this);
if (!serializer_enabled()) {
// Ensure that all stubs which need to be generated ahead of time, but
=======================================
--- /branches/bleeding_edge/src/x64/code-stubs-x64.cc Fri Aug 29 10:40:02
2014 UTC
+++ /branches/bleeding_edge/src/x64/code-stubs-x64.cc Mon Sep 1 09:18:39
2014 UTC
@@ -17,136 +17,25 @@
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 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 @@
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 @@
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);
}
@@ -2856,13 +2699,6 @@
kPointerSize);
}
}
-
-
-// Passing arguments in registers is not supported.
-Register InstanceofStub::left() { return rax; }
-
-
-Register InstanceofStub::right() { return rdx; }
//
-------------------------------------------------------------------------
=======================================
--- /branches/bleeding_edge/src/x64/interface-descriptors-x64.cc Fri Aug 29
10:40:02 2014 UTC
+++ /branches/bleeding_edge/src/x64/interface-descriptors-x64.cc Mon Sep 1
09:18:39 2014 UTC
@@ -15,6 +15,156 @@
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);
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
