Revision: 23652
Author: [email protected]
Date: Wed Sep 3 12:25:13 2014 UTC
Log: CallDescriptors::InitializeForIsolate() is no longer needed.
CallInterfaceDescriptors initialize themselves lazily. Soon we can also tear
down the CodeStubInterfaceDescriptor explicit initialization step.
[email protected]
Review URL: https://codereview.chromium.org/535103002
https://code.google.com/p/v8/source/detail?r=23652
Modified:
/branches/bleeding_edge/src/arm/interface-descriptors-arm.cc
/branches/bleeding_edge/src/arm64/interface-descriptors-arm64.cc
/branches/bleeding_edge/src/ia32/interface-descriptors-ia32.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/interface-descriptors-x64.cc
=======================================
--- /branches/bleeding_edge/src/arm/interface-descriptors-arm.cc Wed Sep 3
10:51:51 2014 UTC
+++ /branches/bleeding_edge/src/arm/interface-descriptors-arm.cc Wed Sep 3
12:25:13 2014 UTC
@@ -59,59 +59,61 @@
const Register InstanceofDescriptor::right() { return r1; }
-void FastNewClosureDescriptor::Initialize(Isolate* isolate) {
+void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
Register registers[] = {cp, r2};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void FastNewContextDescriptor::Initialize(Isolate* isolate) {
+void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
Register registers[] = {cp, r1};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ToNumberDescriptor::Initialize(Isolate* isolate) {
+void ToNumberDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {cp, r0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void NumberToStringDescriptor::Initialize(Isolate* isolate) {
+void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
Register registers[] = {cp, r0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void FastCloneShallowArrayDescriptor::Initialize(Isolate* isolate) {
+void FastCloneShallowArrayDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {cp, r3, r2, r1};
Representation representations[] = {
Representation::Tagged(), Representation::Tagged(),
Representation::Smi(),
Representation::Tagged()};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void FastCloneShallowObjectDescriptor::Initialize(Isolate* isolate) {
+void FastCloneShallowObjectDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {cp, r3, r2, r1, r0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void CreateAllocationSiteDescriptor::Initialize(Isolate* isolate) {
+void CreateAllocationSiteDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {cp, r2, r3};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void CallFunctionDescriptor::Initialize(Isolate* isolate) {
+void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data)
{
Register registers[] = {cp, r1};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void CallConstructDescriptor::Initialize(Isolate* isolate) {
+void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
// r0 : number of arguments
// r1 : the function to call
// r2 : feedback vector
@@ -120,97 +122,100 @@
// 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};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void RegExpConstructResultDescriptor::Initialize(Isolate* isolate) {
+void RegExpConstructResultDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {cp, r2, r1, r0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void TransitionElementsKindDescriptor::Initialize(Isolate* isolate) {
+void TransitionElementsKindDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {cp, r0, r1};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ArrayConstructorConstantArgCountDescriptor::Initialize(Isolate*
isolate) {
+void ArrayConstructorConstantArgCountDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
// register state
// cp -- context
// r0 -- number of arguments
// r1 -- function
// r2 -- allocation site with elements kind
Register registers[] = {cp, r1, r2};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ArrayConstructorDescriptor::Initialize(Isolate* isolate) {
+void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
// 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()};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
void InternalArrayConstructorConstantArgCountDescriptor::Initialize(
- Isolate* isolate) {
+ CallInterfaceDescriptorData* data) {
// register state
// cp -- context
// r0 -- number of arguments
// r1 -- constructor function
Register registers[] = {cp, r1};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void InternalArrayConstructorDescriptor::Initialize(Isolate* isolate) {
+void InternalArrayConstructorDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
// stack param count needs (constructor pointer, and single argument)
Register registers[] = {cp, r1, r0};
Representation representations[] = {Representation::Tagged(),
Representation::Tagged(),
Representation::Integer32()};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void CompareNilDescriptor::Initialize(Isolate* isolate) {
+void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {cp, r0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ToBooleanDescriptor::Initialize(Isolate* isolate) {
+void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {cp, r0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void BinaryOpDescriptor::Initialize(Isolate* isolate) {
+void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {cp, r1, r0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void BinaryOpWithAllocationSiteDescriptor::Initialize(Isolate* isolate) {
+void BinaryOpWithAllocationSiteDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {cp, r2, r1, r0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void StringAddDescriptor::Initialize(Isolate* isolate) {
+void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {cp, r1, r0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void KeyedDescriptor::Initialize(Isolate* isolate) {
+void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
static PlatformInterfaceDescriptor noInlineDescriptor =
PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS);
@@ -222,12 +227,12 @@
Representation::Tagged(), // context
Representation::Tagged(), // key
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations, &noInlineDescriptor);
+ data->Initialize(arraysize(registers), registers, representations,
+ &noInlineDescriptor);
}
-void NamedDescriptor::Initialize(Isolate* isolate) {
+void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
static PlatformInterfaceDescriptor noInlineDescriptor =
PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS);
@@ -239,12 +244,12 @@
Representation::Tagged(), // context
Representation::Tagged(), // name
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations, &noInlineDescriptor);
+ data->Initialize(arraysize(registers), registers, representations,
+ &noInlineDescriptor);
}
-void CallHandlerDescriptor::Initialize(Isolate* isolate) {
+void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) {
static PlatformInterfaceDescriptor default_descriptor =
PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
@@ -256,12 +261,12 @@
Representation::Tagged(), // context
Representation::Tagged(), // receiver
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations, &default_descriptor);
+ data->Initialize(arraysize(registers), registers, representations,
+ &default_descriptor);
}
-void ArgumentAdaptorDescriptor::Initialize(Isolate* isolate) {
+void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
static PlatformInterfaceDescriptor default_descriptor =
PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
@@ -277,12 +282,12 @@
Representation::Integer32(), // actual number of arguments
Representation::Integer32(), // expected number of arguments
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations, &default_descriptor);
+ data->Initialize(arraysize(registers), registers, representations,
+ &default_descriptor);
}
-void ApiFunctionDescriptor::Initialize(Isolate* isolate) {
+void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
static PlatformInterfaceDescriptor default_descriptor =
PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
@@ -300,8 +305,8 @@
Representation::Tagged(), // holder
Representation::External(), // api_function_address
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations, &default_descriptor);
+ data->Initialize(arraysize(registers), registers, representations,
+ &default_descriptor);
}
}
} // namespace v8::internal
=======================================
--- /branches/bleeding_edge/src/arm64/interface-descriptors-arm64.cc Wed
Sep 3 10:51:51 2014 UTC
+++ /branches/bleeding_edge/src/arm64/interface-descriptors-arm64.cc Wed
Sep 3 12:25:13 2014 UTC
@@ -67,39 +67,40 @@
}
-void FastNewClosureDescriptor::Initialize(Isolate* isolate) {
+void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
// cp: context
// x2: function info
Register registers[] = {cp, x2};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void FastNewContextDescriptor::Initialize(Isolate* isolate) {
+void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
// cp: context
// x1: function
Register registers[] = {cp, x1};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ToNumberDescriptor::Initialize(Isolate* isolate) {
+void ToNumberDescriptor::Initialize(CallInterfaceDescriptorData* data) {
// cp: context
// x0: value
Register registers[] = {cp, x0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void NumberToStringDescriptor::Initialize(Isolate* isolate) {
+void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
// cp: context
// x0: value
Register registers[] = {cp, x0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void FastCloneShallowArrayDescriptor::Initialize(Isolate* isolate) {
+void FastCloneShallowArrayDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
// cp: context
// x3: array literals array
// x2: array literal index
@@ -108,39 +109,40 @@
Representation representations[] = {
Representation::Tagged(), Representation::Tagged(),
Representation::Smi(),
Representation::Tagged()};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void FastCloneShallowObjectDescriptor::Initialize(Isolate* isolate) {
+void FastCloneShallowObjectDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
// cp: context
// x3: object literals array
// x2: object literal index
// x1: constant properties
// x0: object literal flags
Register registers[] = {cp, x3, x2, x1, x0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void CreateAllocationSiteDescriptor::Initialize(Isolate* isolate) {
+void CreateAllocationSiteDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
// cp: context
// x2: feedback vector
// x3: call feedback slot
Register registers[] = {cp, x2, x3};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void CallFunctionDescriptor::Initialize(Isolate* isolate) {
+void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data)
{
// x1 function the function to call
Register registers[] = {cp, x1};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void CallConstructDescriptor::Initialize(Isolate* isolate) {
+void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
// x0 : number of arguments
// x1 : the function to call
// x2 : feedback vector
@@ -148,116 +150,119 @@
// 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};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void RegExpConstructResultDescriptor::Initialize(Isolate* isolate) {
+void RegExpConstructResultDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
// cp: context
// x2: length
// x1: index (of last match)
// x0: string
Register registers[] = {cp, x2, x1, x0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void TransitionElementsKindDescriptor::Initialize(Isolate* isolate) {
+void TransitionElementsKindDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
// cp: context
// x0: value (js_array)
// x1: to_map
Register registers[] = {cp, x0, x1};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ArrayConstructorConstantArgCountDescriptor::Initialize(Isolate*
isolate) {
+void ArrayConstructorConstantArgCountDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
// cp: context
// x1: function
// x2: allocation site with elements kind
// x0: number of arguments to the constructor function
Register registers[] = {cp, x1, x2};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ArrayConstructorDescriptor::Initialize(Isolate* isolate) {
+void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
// 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()};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
void InternalArrayConstructorConstantArgCountDescriptor::Initialize(
- Isolate* isolate) {
+ CallInterfaceDescriptorData* data) {
// cp: context
// x1: constructor function
// x0: number of arguments to the constructor function
Register registers[] = {cp, x1};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void InternalArrayConstructorDescriptor::Initialize(Isolate* isolate) {
+void InternalArrayConstructorDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
// stack param count needs (constructor pointer, and single argument)
Register registers[] = {cp, x1, x0};
Representation representations[] = {Representation::Tagged(),
Representation::Tagged(),
Representation::Integer32()};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void CompareNilDescriptor::Initialize(Isolate* isolate) {
+void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) {
// cp: context
// x0: value to compare
Register registers[] = {cp, x0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ToBooleanDescriptor::Initialize(Isolate* isolate) {
+void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) {
// cp: context
// x0: value
Register registers[] = {cp, x0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void BinaryOpDescriptor::Initialize(Isolate* isolate) {
+void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) {
// cp: context
// x1: left operand
// x0: right operand
Register registers[] = {cp, x1, x0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void BinaryOpWithAllocationSiteDescriptor::Initialize(Isolate* isolate) {
+void BinaryOpWithAllocationSiteDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
// cp: context
// x2: allocation site
// x1: left operand
// x0: right operand
Register registers[] = {cp, x2, x1, x0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void StringAddDescriptor::Initialize(Isolate* isolate) {
+void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) {
// cp: context
// x1: left operand
// x0: right operand
Register registers[] = {cp, x1, x0};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void KeyedDescriptor::Initialize(Isolate* isolate) {
+void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
static PlatformInterfaceDescriptor noInlineDescriptor =
PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS);
@@ -269,12 +274,12 @@
Representation::Tagged(), // context
Representation::Tagged(), // key
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations, &noInlineDescriptor);
+ data->Initialize(arraysize(registers), registers, representations,
+ &noInlineDescriptor);
}
-void NamedDescriptor::Initialize(Isolate* isolate) {
+void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
static PlatformInterfaceDescriptor noInlineDescriptor =
PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS);
@@ -286,12 +291,12 @@
Representation::Tagged(), // context
Representation::Tagged(), // name
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations, &noInlineDescriptor);
+ data->Initialize(arraysize(registers), registers, representations,
+ &noInlineDescriptor);
}
-void CallHandlerDescriptor::Initialize(Isolate* isolate) {
+void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) {
static PlatformInterfaceDescriptor default_descriptor =
PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
@@ -303,12 +308,12 @@
Representation::Tagged(), // context
Representation::Tagged(), // receiver
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations, &default_descriptor);
+ data->Initialize(arraysize(registers), registers, representations,
+ &default_descriptor);
}
-void ArgumentAdaptorDescriptor::Initialize(Isolate* isolate) {
+void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
static PlatformInterfaceDescriptor default_descriptor =
PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
@@ -324,12 +329,12 @@
Representation::Integer32(), // actual number of arguments
Representation::Integer32(), // expected number of arguments
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations, &default_descriptor);
+ data->Initialize(arraysize(registers), registers, representations,
+ &default_descriptor);
}
-void ApiFunctionDescriptor::Initialize(Isolate* isolate) {
+void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
static PlatformInterfaceDescriptor default_descriptor =
PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
@@ -347,8 +352,8 @@
Representation::Tagged(), // holder
Representation::External(), // api_function_address
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations, &default_descriptor);
+ data->Initialize(arraysize(registers), registers, representations,
+ &default_descriptor);
}
}
} // namespace v8::internal
=======================================
--- /branches/bleeding_edge/src/ia32/interface-descriptors-ia32.cc Wed Sep
3 10:51:51 2014 UTC
+++ /branches/bleeding_edge/src/ia32/interface-descriptors-ia32.cc Wed Sep
3 12:25:13 2014 UTC
@@ -61,60 +61,62 @@
const Register InstanceofDescriptor::right() { return edx; }
-void FastNewClosureDescriptor::Initialize(Isolate* isolate) {
+void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
Register registers[] = {esi, ebx};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void FastNewContextDescriptor::Initialize(Isolate* isolate) {
+void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
Register registers[] = {esi, edi};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ToNumberDescriptor::Initialize(Isolate* isolate) {
+void ToNumberDescriptor::Initialize(CallInterfaceDescriptorData* data) {
// ToNumberStub invokes a function, and therefore needs a context.
Register registers[] = {esi, eax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void NumberToStringDescriptor::Initialize(Isolate* isolate) {
+void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
Register registers[] = {esi, eax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void FastCloneShallowArrayDescriptor::Initialize(Isolate* isolate) {
+void FastCloneShallowArrayDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {esi, eax, ebx, ecx};
Representation representations[] = {
Representation::Tagged(), Representation::Tagged(),
Representation::Smi(),
Representation::Tagged()};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void FastCloneShallowObjectDescriptor::Initialize(Isolate* isolate) {
+void FastCloneShallowObjectDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {esi, eax, ebx, ecx, edx};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void CreateAllocationSiteDescriptor::Initialize(Isolate* isolate) {
+void CreateAllocationSiteDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {esi, ebx, edx};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void CallFunctionDescriptor::Initialize(Isolate* isolate) {
+void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data)
{
Register registers[] = {esi, edi};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void CallConstructDescriptor::Initialize(Isolate* isolate) {
+void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
// eax : number of arguments
// ebx : feedback vector
// edx : (only if ebx is not the megamorphic symbol) slot in feedback
@@ -123,95 +125,98 @@
// 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};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void RegExpConstructResultDescriptor::Initialize(Isolate* isolate) {
+void RegExpConstructResultDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {esi, ecx, ebx, eax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void TransitionElementsKindDescriptor::Initialize(Isolate* isolate) {
+void TransitionElementsKindDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {esi, eax, ebx};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ArrayConstructorConstantArgCountDescriptor::Initialize(Isolate*
isolate) {
+void ArrayConstructorConstantArgCountDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
// register state
// eax -- number of arguments
// edi -- function
// ebx -- allocation site with elements kind
Register registers[] = {esi, edi, ebx};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ArrayConstructorDescriptor::Initialize(Isolate* isolate) {
+void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
// 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()};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
void InternalArrayConstructorConstantArgCountDescriptor::Initialize(
- Isolate* isolate) {
+ CallInterfaceDescriptorData* data) {
// register state
// eax -- number of arguments
// edi -- function
Register registers[] = {esi, edi};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void InternalArrayConstructorDescriptor::Initialize(Isolate* isolate) {
+void InternalArrayConstructorDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
// stack param count needs (constructor pointer, and single argument)
Register registers[] = {esi, edi, eax};
Representation representations[] = {Representation::Tagged(),
Representation::Tagged(),
Representation::Integer32()};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void CompareNilDescriptor::Initialize(Isolate* isolate) {
+void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {esi, eax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ToBooleanDescriptor::Initialize(Isolate* isolate) {
+void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {esi, eax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void BinaryOpDescriptor::Initialize(Isolate* isolate) {
+void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {esi, edx, eax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void BinaryOpWithAllocationSiteDescriptor::Initialize(Isolate* isolate) {
+void BinaryOpWithAllocationSiteDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {esi, ecx, edx, eax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void StringAddDescriptor::Initialize(Isolate* isolate) {
+void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {esi, edx, eax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void KeyedDescriptor::Initialize(Isolate* isolate) {
+void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {
esi, // context
ecx, // key
@@ -220,12 +225,11 @@
Representation::Tagged(), // context
Representation::Tagged(), // key
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void NamedDescriptor::Initialize(Isolate* isolate) {
+void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {
esi, // context
ecx, // name
@@ -234,12 +238,11 @@
Representation::Tagged(), // context
Representation::Tagged(), // name
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void CallHandlerDescriptor::Initialize(Isolate* isolate) {
+void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {
esi, // context
edx, // name
@@ -248,12 +251,11 @@
Representation::Tagged(), // context
Representation::Tagged(), // receiver
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void ArgumentAdaptorDescriptor::Initialize(Isolate* isolate) {
+void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
Register registers[] = {
esi, // context
edi, // JSFunction
@@ -266,12 +268,11 @@
Representation::Integer32(), // actual number of arguments
Representation::Integer32(), // expected number of arguments
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void ApiFunctionDescriptor::Initialize(Isolate* isolate) {
+void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {
esi, // context
eax, // callee
@@ -286,8 +287,7 @@
Representation::Tagged(), // holder
Representation::External(), // api_function_address
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
}
} // namespace v8::internal
=======================================
--- /branches/bleeding_edge/src/interface-descriptors.cc Wed Sep 3
10:51:51 2014 UTC
+++ /branches/bleeding_edge/src/interface-descriptors.cc Wed Sep 3
12:25:13 2014 UTC
@@ -42,50 +42,39 @@
}
-void LoadDescriptor::Initialize(Isolate* isolate) {
+void LoadDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {ContextRegister(), ReceiverRegister(),
NameRegister()};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void StoreDescriptor::Initialize(Isolate* isolate) {
+void StoreDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {ContextRegister(), ReceiverRegister(),
NameRegister(),
ValueRegister()};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ElementTransitionAndStoreDescriptor::Initialize(Isolate* isolate) {
+void ElementTransitionAndStoreDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {ContextRegister(), ValueRegister(),
MapRegister(),
NameRegister(), ReceiverRegister()};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void InstanceofDescriptor::Initialize(Isolate* isolate) {
+void InstanceofDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {ContextRegister(), left(), right()};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void VectorLoadICDescriptor::Initialize(Isolate* isolate) {
+void VectorLoadICDescriptor::Initialize(CallInterfaceDescriptorData* data)
{
Register registers[] = {ContextRegister(), ReceiverRegister(),
NameRegister(),
SlotRegister(), VectorRegister()};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-
-void CallDescriptors::InitializeForIsolate(Isolate* isolate) {
-// Mechanically initialize all descriptors. The DCHECK makes sure that the
-// Initialize() method did what it is supposed to do.
-
-#define INITIALIZE_DESCRIPTOR(D) \
- D##Descriptor::Initialize(isolate); \
- DCHECK(D##Descriptor(isolate).IsInitialized());
-
- INTERFACE_DESCRIPTOR_LIST(INITIALIZE_DESCRIPTOR)
-#undef INITIALIZE_DESCRIPTOR
-}
}
} // namespace v8::internal
=======================================
--- /branches/bleeding_edge/src/interface-descriptors.h Wed Sep 3 10:51:51
2014 UTC
+++ /branches/bleeding_edge/src/interface-descriptors.h Wed Sep 3 12:25:13
2014 UTC
@@ -104,8 +104,6 @@
#undef DEF_ENUM
NUMBER_OF_DESCRIPTORS
};
-
- static void InitializeForIsolate(Isolate* isolate);
};
@@ -162,25 +160,19 @@
protected:
const CallInterfaceDescriptorData* data() const { return data_; }
-
- static void InitializeData(
- Isolate* isolate, CallDescriptors::Key key, int
register_parameter_count,
- Register* registers, Representation* param_representations,
- PlatformInterfaceDescriptor* platform_descriptor = NULL) {
- isolate->call_descriptor_data(key)
- ->Initialize(register_parameter_count, registers,
param_representations,
- platform_descriptor);
- }
private:
const CallInterfaceDescriptorData* data_;
};
-#define
DECLARE_DESCRIPTOR(name) \
- explicit name(Isolate* isolate) : CallInterfaceDescriptor(isolate,
key()) {} \
- static inline CallDescriptors::Key
key(); \
- static void Initialize(Isolate* isolate);
+#define
DECLARE_DESCRIPTOR(name) \
+ explicit name(Isolate* isolate) : CallInterfaceDescriptor(isolate,
key()) { \
+ if
(!data()->IsInitialized()) \
+
Initialize(isolate->call_descriptor_data(key())); \
+
}
\
+ static inline CallDescriptors::Key
key(); \
+ void Initialize(CallInterfaceDescriptorData* data);
class LoadDescriptor : public CallInterfaceDescriptor {
=======================================
--- /branches/bleeding_edge/src/isolate.cc Wed Sep 3 10:51:51 2014 UTC
+++ /branches/bleeding_edge/src/isolate.cc Wed Sep 3 12:25:13 2014 UTC
@@ -1917,8 +1917,6 @@
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");
=======================================
--- /branches/bleeding_edge/src/x64/interface-descriptors-x64.cc Wed Sep 3
10:51:51 2014 UTC
+++ /branches/bleeding_edge/src/x64/interface-descriptors-x64.cc Wed Sep 3
12:25:13 2014 UTC
@@ -61,60 +61,62 @@
const Register InstanceofDescriptor::right() { return rdx; }
-void FastNewClosureDescriptor::Initialize(Isolate* isolate) {
+void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
Register registers[] = {rsi, rbx};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void FastNewContextDescriptor::Initialize(Isolate* isolate) {
+void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
Register registers[] = {rsi, rdi};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ToNumberDescriptor::Initialize(Isolate* isolate) {
+void ToNumberDescriptor::Initialize(CallInterfaceDescriptorData* data) {
// ToNumberStub invokes a function, and therefore needs a context.
Register registers[] = {rsi, rax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void NumberToStringDescriptor::Initialize(Isolate* isolate) {
+void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
Register registers[] = {rsi, rax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void FastCloneShallowArrayDescriptor::Initialize(Isolate* isolate) {
+void FastCloneShallowArrayDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {rsi, rax, rbx, rcx};
Representation representations[] = {
Representation::Tagged(), Representation::Tagged(),
Representation::Smi(),
Representation::Tagged()};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void FastCloneShallowObjectDescriptor::Initialize(Isolate* isolate) {
+void FastCloneShallowObjectDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {rsi, rax, rbx, rcx, rdx};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void CreateAllocationSiteDescriptor::Initialize(Isolate* isolate) {
+void CreateAllocationSiteDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {rsi, rbx, rdx};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void CallFunctionDescriptor::Initialize(Isolate* isolate) {
+void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data)
{
Register registers[] = {rsi, rdi};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void CallConstructDescriptor::Initialize(Isolate* isolate) {
+void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
// rax : number of arguments
// rbx : feedback vector
// rdx : (only if rbx is not the megamorphic symbol) slot in feedback
@@ -123,96 +125,99 @@
// 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};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void RegExpConstructResultDescriptor::Initialize(Isolate* isolate) {
+void RegExpConstructResultDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {rsi, rcx, rbx, rax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void TransitionElementsKindDescriptor::Initialize(Isolate* isolate) {
+void TransitionElementsKindDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {rsi, rax, rbx};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ArrayConstructorConstantArgCountDescriptor::Initialize(Isolate*
isolate) {
+void ArrayConstructorConstantArgCountDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
// register state
// rax -- number of arguments
// rdi -- function
// rbx -- allocation site with elements kind
Register registers[] = {rsi, rdi, rbx};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ArrayConstructorDescriptor::Initialize(Isolate* isolate) {
+void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
// 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()};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
void InternalArrayConstructorConstantArgCountDescriptor::Initialize(
- Isolate* isolate) {
+ CallInterfaceDescriptorData* data) {
// register state
// rsi -- context
// rax -- number of arguments
// rdi -- constructor function
Register registers[] = {rsi, rdi};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void InternalArrayConstructorDescriptor::Initialize(Isolate* isolate) {
+void InternalArrayConstructorDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
// stack param count needs (constructor pointer, and single argument)
Register registers[] = {rsi, rdi, rax};
Representation representations[] = {Representation::Tagged(),
Representation::Tagged(),
Representation::Integer32()};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void CompareNilDescriptor::Initialize(Isolate* isolate) {
+void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {rsi, rax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void ToBooleanDescriptor::Initialize(Isolate* isolate) {
+void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {rsi, rax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void BinaryOpDescriptor::Initialize(Isolate* isolate) {
+void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {rsi, rdx, rax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void BinaryOpWithAllocationSiteDescriptor::Initialize(Isolate* isolate) {
+void BinaryOpWithAllocationSiteDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
Register registers[] = {rsi, rcx, rdx, rax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void StringAddDescriptor::Initialize(Isolate* isolate) {
+void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {rsi, rdx, rax};
- InitializeData(isolate, key(), arraysize(registers), registers, NULL);
+ data->Initialize(arraysize(registers), registers, NULL);
}
-void KeyedDescriptor::Initialize(Isolate* isolate) {
+void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {
rsi, // context
rcx, // key
@@ -221,12 +226,11 @@
Representation::Tagged(), // context
Representation::Tagged(), // key
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void NamedDescriptor::Initialize(Isolate* isolate) {
+void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {
rsi, // context
rcx, // name
@@ -235,12 +239,11 @@
Representation::Tagged(), // context
Representation::Tagged(), // name
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void CallHandlerDescriptor::Initialize(Isolate* isolate) {
+void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {
rsi, // context
rdx, // receiver
@@ -249,12 +252,11 @@
Representation::Tagged(), // context
Representation::Tagged(), // receiver
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void ArgumentAdaptorDescriptor::Initialize(Isolate* isolate) {
+void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData*
data) {
Register registers[] = {
rsi, // context
rdi, // JSFunction
@@ -267,12 +269,11 @@
Representation::Integer32(), // actual number of arguments
Representation::Integer32(), // expected number of arguments
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
-void ApiFunctionDescriptor::Initialize(Isolate* isolate) {
+void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
Register registers[] = {
rsi, // context
rax, // callee
@@ -287,8 +288,7 @@
Representation::Tagged(), // holder
Representation::External(), // api_function_address
};
- InitializeData(isolate, key(), arraysize(registers), registers,
- representations);
+ data->Initialize(arraysize(registers), registers, representations);
}
}
} // namespace v8::internal
--
--
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.
