2014-08-29 10:40:02 +00:00
|
|
|
// Copyright 2012 the V8 project authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
|
|
// found in the LICENSE file.
|
|
|
|
|
|
|
|
#include "src/interface-descriptors.h"
|
|
|
|
|
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
|
|
|
|
2015-06-24 06:21:47 +00:00
|
|
|
namespace {
|
|
|
|
// Constructors for common combined semantic and representation types.
|
2015-09-03 12:53:19 +00:00
|
|
|
Type* SmiType(Zone* zone) {
|
|
|
|
return Type::Intersect(Type::SignedSmall(), Type::TaggedSigned(), zone);
|
2015-06-24 06:21:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-09-03 12:53:19 +00:00
|
|
|
Type* UntaggedSigned32(Zone* zone) {
|
|
|
|
return Type::Intersect(Type::Signed32(), Type::UntaggedSigned32(), zone);
|
2015-06-24 06:21:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-09-03 12:53:19 +00:00
|
|
|
Type* AnyTagged(Zone* zone) {
|
2015-06-24 06:21:47 +00:00
|
|
|
return Type::Intersect(
|
2015-09-03 12:53:19 +00:00
|
|
|
Type::Any(),
|
|
|
|
Type::Union(Type::TaggedPointer(), Type::TaggedSigned(), zone), zone);
|
2015-06-24 06:21:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-09-03 12:53:19 +00:00
|
|
|
Type* ExternalPointer(Zone* zone) {
|
|
|
|
return Type::Intersect(Type::Internal(), Type::UntaggedPointer(), zone);
|
2015-06-24 06:21:47 +00:00
|
|
|
}
|
2015-09-30 13:46:56 +00:00
|
|
|
} // namespace
|
2015-06-24 06:21:47 +00:00
|
|
|
|
|
|
|
|
|
|
|
Type::FunctionType* CallInterfaceDescriptor::BuildDefaultFunctionType(
|
|
|
|
Isolate* isolate, int parameter_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function = Type::FunctionType::New(
|
|
|
|
AnyTagged(zone), Type::Undefined(), parameter_count, zone);
|
2015-06-24 06:21:47 +00:00
|
|
|
while (parameter_count-- != 0) {
|
2015-09-03 12:53:19 +00:00
|
|
|
function->InitParameter(parameter_count, AnyTagged(zone));
|
2015-06-24 06:21:47 +00:00
|
|
|
}
|
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void CallInterfaceDescriptorData::InitializePlatformSpecific(
|
2014-08-29 10:40:02 +00:00
|
|
|
int register_parameter_count, Register* registers,
|
|
|
|
PlatformInterfaceDescriptor* platform_descriptor) {
|
|
|
|
platform_specific_descriptor_ = platform_descriptor;
|
|
|
|
register_param_count_ = register_parameter_count;
|
|
|
|
|
|
|
|
// InterfaceDescriptor owns a copy of the registers array.
|
|
|
|
register_params_.Reset(NewArray<Register>(register_parameter_count));
|
|
|
|
for (int i = 0; i < register_parameter_count; i++) {
|
|
|
|
register_params_[i] = registers[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-30 09:00:58 +00:00
|
|
|
const char* CallInterfaceDescriptor::DebugName(Isolate* isolate) const {
|
2014-09-08 15:18:54 +00:00
|
|
|
CallInterfaceDescriptorData* start = isolate->call_descriptor_data(0);
|
2014-09-08 16:18:37 +00:00
|
|
|
size_t index = data_ - start;
|
2014-09-08 15:18:54 +00:00
|
|
|
DCHECK(index < CallDescriptors::NUMBER_OF_DESCRIPTORS);
|
|
|
|
CallDescriptors::Key key = static_cast<CallDescriptors::Key>(index);
|
|
|
|
switch (key) {
|
|
|
|
#define DEF_CASE(NAME) \
|
|
|
|
case CallDescriptors::NAME: \
|
|
|
|
return #NAME " Descriptor";
|
|
|
|
INTERFACE_DESCRIPTOR_LIST(DEF_CASE)
|
|
|
|
#undef DEF_CASE
|
|
|
|
case CallDescriptors::NUMBER_OF_DESCRIPTORS:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-06-24 06:21:47 +00:00
|
|
|
Type::FunctionType* LoadDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 3, zone);
|
|
|
|
function->InitParameter(0, AnyTagged(zone));
|
|
|
|
function->InitParameter(1, AnyTagged(zone));
|
|
|
|
function->InitParameter(2, SmiType(zone));
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
void LoadDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
2015-07-01 08:45:05 +00:00
|
|
|
Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister()};
|
2015-06-24 06:21:47 +00:00
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
2014-09-03 10:51:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-06-24 06:21:47 +00:00
|
|
|
void StoreDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
2015-07-01 08:45:05 +00:00
|
|
|
Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister()};
|
2015-06-24 06:21:47 +00:00
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
2014-09-03 10:51:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-08-21 09:04:43 +00:00
|
|
|
void StoreTransitionDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
|
|
|
Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
|
|
|
|
MapRegister()};
|
|
|
|
|
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-07-23 14:00:02 +00:00
|
|
|
Type::FunctionType*
|
|
|
|
StoreTransitionDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 4, zone);
|
|
|
|
function->InitParameter(0, AnyTagged(zone)); // Receiver
|
|
|
|
function->InitParameter(1, AnyTagged(zone)); // Name
|
|
|
|
function->InitParameter(2, AnyTagged(zone)); // Value
|
|
|
|
function->InitParameter(3, AnyTagged(zone)); // Map
|
2015-07-23 14:00:02 +00:00
|
|
|
return function;
|
2014-09-29 13:11:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-07-13 09:18:44 +00:00
|
|
|
Type::FunctionType*
|
|
|
|
LoadGlobalViaContextDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 1, zone);
|
|
|
|
function->InitParameter(0, UntaggedSigned32(zone));
|
2015-07-13 09:18:44 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void LoadGlobalViaContextDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
2015-07-28 06:04:04 +00:00
|
|
|
Register registers[] = {SlotRegister()};
|
2015-07-13 09:18:44 +00:00
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Type::FunctionType*
|
|
|
|
StoreGlobalViaContextDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 2, zone);
|
|
|
|
function->InitParameter(0, UntaggedSigned32(zone));
|
|
|
|
function->InitParameter(1, AnyTagged(zone));
|
2015-07-13 09:18:44 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void StoreGlobalViaContextDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
2015-07-28 06:04:04 +00:00
|
|
|
Register registers[] = {SlotRegister(), ValueRegister()};
|
2015-07-13 09:18:44 +00:00
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-08-25 04:48:36 +00:00
|
|
|
void InstanceOfDescriptor::InitializePlatformSpecific(
|
2015-06-24 06:21:47 +00:00
|
|
|
CallInterfaceDescriptorData* data) {
|
2015-08-25 04:48:36 +00:00
|
|
|
Register registers[] = {LeftRegister(), RightRegister()};
|
2015-06-24 06:21:47 +00:00
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
2014-09-03 10:51:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-09-18 08:30:22 +00:00
|
|
|
void StringCompareDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
|
|
|
Register registers[] = {LeftRegister(), RightRegister()};
|
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-08-28 12:59:51 +00:00
|
|
|
void ToStringDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
|
|
|
Register registers[] = {ReceiverRegister()};
|
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-07-31 12:25:28 +00:00
|
|
|
void ToObjectDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
|
|
|
Register registers[] = {ReceiverRegister()};
|
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-06-24 06:21:47 +00:00
|
|
|
void MathPowTaggedDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
2015-07-01 08:45:05 +00:00
|
|
|
Register registers[] = {exponent()};
|
2015-06-24 06:21:47 +00:00
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
2014-09-11 07:11:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-06-24 06:21:47 +00:00
|
|
|
void MathPowIntegerDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
2015-07-01 08:45:05 +00:00
|
|
|
Register registers[] = {exponent()};
|
2015-06-24 06:21:47 +00:00
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Type::FunctionType*
|
|
|
|
LoadWithVectorDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 4, zone);
|
|
|
|
function->InitParameter(0, AnyTagged(zone));
|
|
|
|
function->InitParameter(1, AnyTagged(zone));
|
|
|
|
function->InitParameter(2, SmiType(zone));
|
|
|
|
function->InitParameter(3, AnyTagged(zone));
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
2014-09-11 07:11:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-06-24 06:21:47 +00:00
|
|
|
void LoadWithVectorDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
2015-07-01 08:45:05 +00:00
|
|
|
Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister(),
|
|
|
|
VectorRegister()};
|
2015-06-24 06:21:47 +00:00
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-08-21 09:04:43 +00:00
|
|
|
Type::FunctionType*
|
|
|
|
VectorStoreTransitionDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 6, zone);
|
|
|
|
function->InitParameter(0, AnyTagged(zone)); // receiver
|
|
|
|
function->InitParameter(1, AnyTagged(zone)); // name
|
|
|
|
function->InitParameter(2, AnyTagged(zone)); // value
|
|
|
|
function->InitParameter(3, SmiType(zone)); // slot
|
|
|
|
function->InitParameter(4, AnyTagged(zone)); // vector
|
|
|
|
function->InitParameter(5, AnyTagged(zone)); // map
|
2015-08-21 09:04:43 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-06-24 06:21:47 +00:00
|
|
|
Type::FunctionType*
|
|
|
|
VectorStoreICDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 5, zone);
|
|
|
|
function->InitParameter(0, AnyTagged(zone));
|
|
|
|
function->InitParameter(1, AnyTagged(zone));
|
|
|
|
function->InitParameter(2, AnyTagged(zone));
|
|
|
|
function->InitParameter(3, SmiType(zone));
|
|
|
|
function->InitParameter(4, AnyTagged(zone));
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
2015-05-22 14:36:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-06-24 06:21:47 +00:00
|
|
|
void VectorStoreICDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
2015-07-01 08:45:05 +00:00
|
|
|
Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
|
|
|
|
SlotRegister(), VectorRegister()};
|
2015-06-24 06:21:47 +00:00
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
2015-05-22 14:36:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-06-24 06:21:47 +00:00
|
|
|
Type::FunctionType*
|
|
|
|
VectorStoreICTrampolineDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 4, zone);
|
|
|
|
function->InitParameter(0, AnyTagged(zone));
|
|
|
|
function->InitParameter(1, AnyTagged(zone));
|
|
|
|
function->InitParameter(2, AnyTagged(zone));
|
|
|
|
function->InitParameter(3, SmiType(zone));
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void VectorStoreICTrampolineDescriptor::InitializePlatformSpecific(
|
2015-05-22 14:36:48 +00:00
|
|
|
CallInterfaceDescriptorData* data) {
|
2015-07-01 08:45:05 +00:00
|
|
|
Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
|
|
|
|
SlotRegister()};
|
2015-06-24 06:21:47 +00:00
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
2014-09-11 07:11:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-06-24 06:21:47 +00:00
|
|
|
Type::FunctionType*
|
|
|
|
ApiGetterDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 1, zone);
|
|
|
|
function->InitParameter(0, ExternalPointer(zone));
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void ApiGetterDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
2015-07-01 08:45:05 +00:00
|
|
|
Register registers[] = {function_address()};
|
2015-06-24 06:21:47 +00:00
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
2014-09-11 07:11:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-06-24 06:21:47 +00:00
|
|
|
void ArgumentsAccessReadDescriptor::InitializePlatformSpecific(
|
2014-09-11 07:11:10 +00:00
|
|
|
CallInterfaceDescriptorData* data) {
|
2015-07-01 08:45:05 +00:00
|
|
|
Register registers[] = {index(), parameter_count()};
|
2015-06-24 06:21:47 +00:00
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
2014-09-11 07:11:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-09-24 15:30:30 +00:00
|
|
|
Type::FunctionType*
|
|
|
|
ArgumentsAccessNewDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 3, zone);
|
|
|
|
function->InitParameter(0, AnyTagged(zone));
|
|
|
|
function->InitParameter(1, SmiType(zone));
|
|
|
|
function->InitParameter(2, ExternalPointer(zone));
|
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void ArgumentsAccessNewDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
|
|
|
Register registers[] = {function(), parameter_count(), parameter_pointer()};
|
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-06-24 06:21:47 +00:00
|
|
|
void ContextOnlyDescriptor::InitializePlatformSpecific(
|
|
|
|
CallInterfaceDescriptorData* data) {
|
2015-07-01 08:45:05 +00:00
|
|
|
data->InitializePlatformSpecific(0, nullptr);
|
2014-09-03 10:51:51 +00:00
|
|
|
}
|
|
|
|
|
2015-04-30 12:34:02 +00:00
|
|
|
|
2015-06-24 06:21:47 +00:00
|
|
|
void GrowArrayElementsDescriptor::InitializePlatformSpecific(
|
2015-04-30 12:34:02 +00:00
|
|
|
CallInterfaceDescriptorData* data) {
|
2015-07-01 08:45:05 +00:00
|
|
|
Register registers[] = {ObjectRegister(), KeyRegister()};
|
2015-06-24 06:21:47 +00:00
|
|
|
data->InitializePlatformSpecific(arraysize(registers), registers);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Type::FunctionType*
|
|
|
|
FastCloneShallowArrayDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 3, zone);
|
|
|
|
function->InitParameter(0, AnyTagged(zone));
|
|
|
|
function->InitParameter(1, SmiType(zone));
|
|
|
|
function->InitParameter(2, AnyTagged(zone));
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Type::FunctionType*
|
|
|
|
CreateAllocationSiteDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 2, zone);
|
|
|
|
function->InitParameter(0, AnyTagged(zone));
|
|
|
|
function->InitParameter(1, SmiType(zone));
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
2015-04-30 12:34:02 +00:00
|
|
|
}
|
2015-06-24 06:21:47 +00:00
|
|
|
|
|
|
|
|
|
|
|
Type::FunctionType*
|
|
|
|
CreateWeakCellDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 3, zone);
|
|
|
|
function->InitParameter(0, AnyTagged(zone));
|
|
|
|
function->InitParameter(1, SmiType(zone));
|
|
|
|
function->InitParameter(2, AnyTagged(zone));
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-09-08 13:35:20 +00:00
|
|
|
Type::FunctionType*
|
|
|
|
CallTrampolineDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 2, zone);
|
|
|
|
function->InitParameter(0, AnyTagged(zone)); // target
|
|
|
|
function->InitParameter(
|
|
|
|
1, UntaggedSigned32(zone)); // actual number of arguments
|
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-06-24 06:21:47 +00:00
|
|
|
Type::FunctionType*
|
|
|
|
CallFunctionWithFeedbackDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 2, zone);
|
2015-07-01 08:45:05 +00:00
|
|
|
function->InitParameter(0, Type::Receiver()); // JSFunction
|
2015-09-03 12:53:19 +00:00
|
|
|
function->InitParameter(1, SmiType(zone));
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Type::FunctionType* CallFunctionWithFeedbackAndVectorDescriptor::
|
|
|
|
BuildCallInterfaceDescriptorFunctionType(Isolate* isolate,
|
|
|
|
int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 3, zone);
|
2015-07-01 08:45:05 +00:00
|
|
|
function->InitParameter(0, Type::Receiver()); // JSFunction
|
2015-09-03 12:53:19 +00:00
|
|
|
function->InitParameter(1, SmiType(zone));
|
|
|
|
function->InitParameter(2, AnyTagged(zone));
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Type::FunctionType*
|
|
|
|
ArrayConstructorDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 3, zone);
|
2015-07-01 08:45:05 +00:00
|
|
|
function->InitParameter(0, Type::Receiver()); // JSFunction
|
2015-09-03 12:53:19 +00:00
|
|
|
function->InitParameter(1, AnyTagged(zone));
|
|
|
|
function->InitParameter(2, UntaggedSigned32(zone));
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Type::FunctionType*
|
|
|
|
InternalArrayConstructorDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 2, zone);
|
2015-07-01 08:45:05 +00:00
|
|
|
function->InitParameter(0, Type::Receiver()); // JSFunction
|
2015-09-03 12:53:19 +00:00
|
|
|
function->InitParameter(1, UntaggedSigned32(zone));
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Type::FunctionType*
|
|
|
|
ArgumentAdaptorDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 3, zone);
|
2015-07-01 08:45:05 +00:00
|
|
|
function->InitParameter(0, Type::Receiver()); // JSFunction
|
2015-09-03 12:53:19 +00:00
|
|
|
function->InitParameter(
|
|
|
|
1, UntaggedSigned32(zone)); // actual number of arguments
|
|
|
|
function->InitParameter(
|
|
|
|
2,
|
|
|
|
UntaggedSigned32(zone)); // expected number of arguments
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Type::FunctionType*
|
|
|
|
ApiFunctionDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 5, zone);
|
|
|
|
function->InitParameter(0, AnyTagged(zone)); // callee
|
|
|
|
function->InitParameter(1, AnyTagged(zone)); // call_data
|
|
|
|
function->InitParameter(2, AnyTagged(zone)); // holder
|
|
|
|
function->InitParameter(3, ExternalPointer(zone)); // api_function_address
|
|
|
|
function->InitParameter(
|
|
|
|
4, UntaggedSigned32(zone)); // actual number of arguments
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Type::FunctionType*
|
|
|
|
ApiAccessorDescriptor::BuildCallInterfaceDescriptorFunctionType(
|
|
|
|
Isolate* isolate, int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 4, zone);
|
|
|
|
function->InitParameter(0, AnyTagged(zone)); // callee
|
|
|
|
function->InitParameter(1, AnyTagged(zone)); // call_data
|
|
|
|
function->InitParameter(2, AnyTagged(zone)); // holder
|
|
|
|
function->InitParameter(3, ExternalPointer(zone)); // api_function_address
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-07-08 16:53:32 +00:00
|
|
|
Type::FunctionType* MathRoundVariantCallFromUnoptimizedCodeDescriptor::
|
|
|
|
BuildCallInterfaceDescriptorFunctionType(Isolate* isolate,
|
|
|
|
int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 4, zone);
|
2015-07-08 16:53:32 +00:00
|
|
|
function->InitParameter(0, Type::Receiver());
|
2015-09-03 12:53:19 +00:00
|
|
|
function->InitParameter(1, SmiType(zone));
|
|
|
|
function->InitParameter(2, AnyTagged(zone));
|
|
|
|
function->InitParameter(3, AnyTagged(zone));
|
2015-06-24 06:21:47 +00:00
|
|
|
return function;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-07-08 16:53:32 +00:00
|
|
|
Type::FunctionType* MathRoundVariantCallFromOptimizedCodeDescriptor::
|
|
|
|
BuildCallInterfaceDescriptorFunctionType(Isolate* isolate,
|
|
|
|
int paramater_count) {
|
2015-09-03 12:53:19 +00:00
|
|
|
Zone* zone = isolate->interface_descriptor_zone();
|
|
|
|
Type::FunctionType* function =
|
|
|
|
Type::FunctionType::New(AnyTagged(zone), Type::Undefined(), 5, zone);
|
2015-07-08 16:53:32 +00:00
|
|
|
function->InitParameter(0, Type::Receiver());
|
2015-09-03 12:53:19 +00:00
|
|
|
function->InitParameter(1, SmiType(zone));
|
|
|
|
function->InitParameter(2, AnyTagged(zone));
|
|
|
|
function->InitParameter(3, AnyTagged(zone));
|
|
|
|
function->InitParameter(4, AnyTagged(zone));
|
2015-07-08 16:53:32 +00:00
|
|
|
return function;
|
|
|
|
}
|
2015-06-01 22:46:54 +00:00
|
|
|
} // namespace internal
|
|
|
|
} // namespace v8
|