// Copyright 2014 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.
|
|
#ifndef V8_INTERFACE_DESCRIPTORS_H_
|
#define V8_INTERFACE_DESCRIPTORS_H_
|
|
#include <memory>
|
|
#include "src/assembler.h"
|
#include "src/globals.h"
|
#include "src/isolate.h"
|
#include "src/macro-assembler.h"
|
|
namespace v8 {
|
namespace internal {
|
|
#define INTERFACE_DESCRIPTOR_LIST(V) \
|
V(CppBuiltinAdaptor) \
|
V(CEntry1ArgvOnStack) \
|
V(Allocate) \
|
V(Void) \
|
V(ContextOnly) \
|
V(NoContext) \
|
V(Load) \
|
V(LoadWithVector) \
|
V(LoadGlobal) \
|
V(LoadGlobalWithVector) \
|
V(Store) \
|
V(StoreWithVector) \
|
V(StoreTransition) \
|
V(StoreGlobal) \
|
V(StoreGlobalWithVector) \
|
V(FastNewFunctionContext) \
|
V(FastNewObject) \
|
V(RecordWrite) \
|
V(TypeConversion) \
|
V(TypeConversionStackParameter) \
|
V(Typeof) \
|
V(CallFunction) \
|
V(CallVarargs) \
|
V(CallForwardVarargs) \
|
V(CallWithSpread) \
|
V(CallWithArrayLike) \
|
V(CallTrampoline) \
|
V(ConstructStub) \
|
V(ConstructVarargs) \
|
V(ConstructForwardVarargs) \
|
V(ConstructWithSpread) \
|
V(ConstructWithArrayLike) \
|
V(JSTrampoline) \
|
V(Abort) \
|
V(AllocateHeapNumber) \
|
V(ArrayConstructor) \
|
V(ArrayNoArgumentConstructor) \
|
V(ArraySingleArgumentConstructor) \
|
V(ArrayNArgumentsConstructor) \
|
V(Compare) \
|
V(BinaryOp) \
|
V(StringAt) \
|
V(StringSubstring) \
|
V(GetProperty) \
|
V(ArgumentAdaptor) \
|
V(ApiCallback) \
|
V(ApiGetter) \
|
V(GrowArrayElements) \
|
V(NewArgumentsElements) \
|
V(InterpreterDispatch) \
|
V(InterpreterPushArgsThenCall) \
|
V(InterpreterPushArgsThenConstruct) \
|
V(InterpreterCEntry1) \
|
V(InterpreterCEntry2) \
|
V(ResumeGenerator) \
|
V(FrameDropperTrampoline) \
|
V(RunMicrotasks) \
|
V(WasmGrowMemory) \
|
V(CloneObjectWithVector) \
|
BUILTIN_LIST_TFS(V)
|
|
class V8_EXPORT_PRIVATE CallInterfaceDescriptorData {
|
public:
|
enum Flag {
|
kNoFlags = 0u,
|
kNoContext = 1u << 0,
|
};
|
typedef base::Flags<Flag> Flags;
|
|
CallInterfaceDescriptorData() = default;
|
|
// A copy of the passed in registers and param_representations is made
|
// and owned by the CallInterfaceDescriptorData.
|
|
void InitializePlatformSpecific(int register_parameter_count,
|
const Register* registers);
|
|
// if machine_types is null, then an array of size
|
// (return_count + parameter_count) will be created with
|
// MachineType::AnyTagged() for each member.
|
//
|
// if machine_types is not null, then it should be of the size
|
// (return_count + parameter_count). Those members of the parameter array will
|
// be initialized from {machine_types}, and the rest initialized to
|
// MachineType::AnyTagged().
|
void InitializePlatformIndependent(Flags flags, int return_count,
|
int parameter_count,
|
const MachineType* machine_types,
|
int machine_types_length);
|
|
void Reset();
|
|
bool IsInitialized() const {
|
return IsInitializedPlatformSpecific() &&
|
IsInitializedPlatformIndependent();
|
}
|
|
Flags flags() const { return flags_; }
|
int return_count() const { return return_count_; }
|
int param_count() const { return param_count_; }
|
int register_param_count() const { return register_param_count_; }
|
Register register_param(int index) const { return register_params_[index]; }
|
Register* register_params() const { return register_params_; }
|
MachineType return_type(int index) const {
|
DCHECK_LT(index, return_count_);
|
return machine_types_[index];
|
}
|
MachineType param_type(int index) const {
|
DCHECK_LT(index, param_count_);
|
return machine_types_[return_count_ + index];
|
}
|
|
void RestrictAllocatableRegisters(const Register* registers, int num) {
|
DCHECK_EQ(allocatable_registers_, 0);
|
for (int i = 0; i < num; ++i) {
|
allocatable_registers_ |= registers[i].bit();
|
}
|
DCHECK_GT(NumRegs(allocatable_registers_), 0);
|
}
|
|
RegList allocatable_registers() const { return allocatable_registers_; }
|
|
private:
|
bool IsInitializedPlatformSpecific() const {
|
const bool initialized =
|
register_param_count_ >= 0 && register_params_ != nullptr;
|
// Platform-specific initialization happens before platform-independent.
|
return initialized;
|
}
|
bool IsInitializedPlatformIndependent() const {
|
const bool initialized =
|
return_count_ >= 0 && param_count_ >= 0 && machine_types_ != nullptr;
|
// Platform-specific initialization happens before platform-independent.
|
return initialized;
|
}
|
|
#ifdef DEBUG
|
bool AllStackParametersAreTagged() const;
|
#endif // DEBUG
|
|
int register_param_count_ = -1;
|
int return_count_ = -1;
|
int param_count_ = -1;
|
Flags flags_ = kNoFlags;
|
|
// Specifying the set of registers that could be used by the register
|
// allocator. Currently, it's only used by RecordWrite code stub.
|
RegList allocatable_registers_ = 0;
|
|
// |registers_params_| defines registers that are used for parameter passing.
|
// |machine_types_| defines machine types for resulting values and incomping
|
// parameters.
|
// Both arrays are allocated dynamically by the InterfaceDescriptor and
|
// freed on destruction. This is because static arrays cause creation of
|
// runtime static initializers which we don't want.
|
Register* register_params_ = nullptr;
|
MachineType* machine_types_ = nullptr;
|
|
DISALLOW_COPY_AND_ASSIGN(CallInterfaceDescriptorData);
|
};
|
|
class V8_EXPORT_PRIVATE CallDescriptors : public AllStatic {
|
public:
|
enum Key {
|
#define DEF_ENUM(name, ...) name,
|
INTERFACE_DESCRIPTOR_LIST(DEF_ENUM)
|
#undef DEF_ENUM
|
NUMBER_OF_DESCRIPTORS
|
};
|
|
static void InitializeOncePerProcess();
|
static void TearDown();
|
|
static CallInterfaceDescriptorData* call_descriptor_data(
|
CallDescriptors::Key key) {
|
return &call_descriptor_data_[key];
|
}
|
|
static Key GetKey(const CallInterfaceDescriptorData* data) {
|
ptrdiff_t index = data - call_descriptor_data_;
|
DCHECK_LE(0, index);
|
DCHECK_LT(index, CallDescriptors::NUMBER_OF_DESCRIPTORS);
|
return static_cast<CallDescriptors::Key>(index);
|
}
|
|
private:
|
static CallInterfaceDescriptorData
|
call_descriptor_data_[NUMBER_OF_DESCRIPTORS];
|
};
|
|
class V8_EXPORT_PRIVATE CallInterfaceDescriptor {
|
public:
|
typedef CallInterfaceDescriptorData::Flags Flags;
|
|
CallInterfaceDescriptor() : data_(nullptr) {}
|
virtual ~CallInterfaceDescriptor() {}
|
|
CallInterfaceDescriptor(CallDescriptors::Key key)
|
: data_(CallDescriptors::call_descriptor_data(key)) {}
|
|
Flags flags() const { return data()->flags(); }
|
|
bool HasContextParameter() const {
|
return (flags() & CallInterfaceDescriptorData::kNoContext) == 0;
|
}
|
|
int GetReturnCount() const { return data()->return_count(); }
|
|
MachineType GetReturnType(int index) const {
|
DCHECK_LT(index, data()->return_count());
|
return data()->return_type(index);
|
}
|
|
int GetParameterCount() const { return data()->param_count(); }
|
|
int GetRegisterParameterCount() const {
|
return data()->register_param_count();
|
}
|
|
int GetStackParameterCount() const {
|
return data()->param_count() - data()->register_param_count();
|
}
|
|
Register GetRegisterParameter(int index) const {
|
return data()->register_param(index);
|
}
|
|
MachineType GetParameterType(int index) const {
|
DCHECK_LT(index, data()->param_count());
|
return data()->param_type(index);
|
}
|
|
RegList allocatable_registers() const {
|
return data()->allocatable_registers();
|
}
|
|
static const Register ContextRegister();
|
|
const char* DebugName() const;
|
|
protected:
|
const CallInterfaceDescriptorData* data() const { return data_; }
|
|
virtual void InitializePlatformSpecific(CallInterfaceDescriptorData* data) {
|
UNREACHABLE();
|
}
|
|
virtual void InitializePlatformIndependent(
|
CallInterfaceDescriptorData* data) {
|
// Default descriptor configuration: one result, all parameters are passed
|
// in registers and all parameters have MachineType::AnyTagged() type.
|
data->InitializePlatformIndependent(CallInterfaceDescriptorData::kNoFlags,
|
1, data->register_param_count(),
|
nullptr, 0);
|
}
|
|
// Initializes |data| using the platform dependent default set of registers.
|
// It is intended to be used for TurboFan stubs when particular set of
|
// registers does not matter.
|
static void DefaultInitializePlatformSpecific(
|
CallInterfaceDescriptorData* data, int register_parameter_count);
|
|
// Initializes |data| using the platform dependent default set of registers
|
// for JavaScript-compatible calling convention.
|
// It is intended to be used for TurboFan stubs being called with JavaScript
|
// linkage + additional parameters on registers and stack.
|
static void JSDefaultInitializePlatformSpecific(
|
CallInterfaceDescriptorData* data, int non_js_register_parameter_count);
|
|
private:
|
// {CallDescriptors} is allowed to call the private {Initialize} method.
|
friend class CallDescriptors;
|
|
const CallInterfaceDescriptorData* data_;
|
|
void Initialize(CallInterfaceDescriptorData* data) {
|
// The passed pointer should be a modifiable pointer to our own data.
|
DCHECK_EQ(data, data_);
|
DCHECK(!data->IsInitialized());
|
InitializePlatformSpecific(data);
|
InitializePlatformIndependent(data);
|
DCHECK(data->IsInitialized());
|
}
|
};
|
|
#define DECLARE_DESCRIPTOR_WITH_BASE(name, base) \
|
public: \
|
explicit name() : base(key()) {} \
|
static inline CallDescriptors::Key key();
|
|
#if defined(V8_TARGET_ARCH_IA32) && defined(V8_EMBEDDED_BUILTINS)
|
// TODO(jgruber,v8:6666): Keep kRootRegister free unconditionally.
|
constexpr int kMaxBuiltinRegisterParams = 4;
|
#else
|
constexpr int kMaxBuiltinRegisterParams = 5;
|
#endif
|
|
#define DECLARE_DEFAULT_DESCRIPTOR(name, base) \
|
DECLARE_DESCRIPTOR_WITH_BASE(name, base) \
|
protected: \
|
static const int kRegisterParams = \
|
kParameterCount > kMaxBuiltinRegisterParams ? kMaxBuiltinRegisterParams \
|
: kParameterCount; \
|
static const int kStackParams = kParameterCount - kRegisterParams; \
|
void InitializePlatformSpecific(CallInterfaceDescriptorData* data) \
|
override { \
|
DefaultInitializePlatformSpecific(data, kRegisterParams); \
|
} \
|
void InitializePlatformIndependent(CallInterfaceDescriptorData* data) \
|
override { \
|
data->InitializePlatformIndependent(Flags(kDescriptorFlags), kReturnCount, \
|
kParameterCount, nullptr, 0); \
|
} \
|
name(CallDescriptors::Key key) : base(key) {} \
|
\
|
public:
|
|
#define DECLARE_JS_COMPATIBLE_DESCRIPTOR(name, base, \
|
non_js_reg_parameters_count) \
|
DECLARE_DESCRIPTOR_WITH_BASE(name, base) \
|
protected: \
|
void InitializePlatformSpecific(CallInterfaceDescriptorData* data) \
|
override { \
|
JSDefaultInitializePlatformSpecific(data, non_js_reg_parameters_count); \
|
} \
|
name(CallDescriptors::Key key) : base(key) {} \
|
\
|
public:
|
|
#define DEFINE_RESULT_AND_PARAMETERS(return_count, ...) \
|
static constexpr int kDescriptorFlags = \
|
CallInterfaceDescriptorData::kNoFlags; \
|
static constexpr int kReturnCount = return_count; \
|
enum ParameterIndices { \
|
__dummy = -1, /* to be able to pass zero arguments */ \
|
##__VA_ARGS__, \
|
\
|
kParameterCount, \
|
kContext = kParameterCount /* implicit parameter */ \
|
};
|
|
#define DEFINE_RESULT_AND_PARAMETERS_NO_CONTEXT(return_count, ...) \
|
static constexpr int kDescriptorFlags = \
|
CallInterfaceDescriptorData::kNoContext; \
|
static constexpr int kReturnCount = return_count; \
|
enum ParameterIndices { \
|
__dummy = -1, /* to be able to pass zero arguments */ \
|
##__VA_ARGS__, \
|
\
|
kParameterCount \
|
};
|
|
#define DEFINE_PARAMETERS(...) DEFINE_RESULT_AND_PARAMETERS(1, ##__VA_ARGS__)
|
|
#define DEFINE_PARAMETERS_NO_CONTEXT(...) \
|
DEFINE_RESULT_AND_PARAMETERS_NO_CONTEXT(1, ##__VA_ARGS__)
|
|
#define DEFINE_RESULT_AND_PARAMETER_TYPES(...) \
|
void InitializePlatformIndependent(CallInterfaceDescriptorData* data) \
|
override { \
|
MachineType machine_types[] = {__VA_ARGS__}; \
|
static_assert( \
|
kReturnCount + kParameterCount == arraysize(machine_types), \
|
"Parameter names definition is not consistent with parameter types"); \
|
data->InitializePlatformIndependent(Flags(kDescriptorFlags), kReturnCount, \
|
kParameterCount, machine_types, \
|
arraysize(machine_types)); \
|
}
|
|
#define DEFINE_PARAMETER_TYPES(...) \
|
DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged() /* result */, \
|
##__VA_ARGS__)
|
|
#define DEFINE_JS_PARAMETERS(...) \
|
static constexpr int kDescriptorFlags = \
|
CallInterfaceDescriptorData::kNoFlags; \
|
static constexpr int kReturnCount = 1; \
|
enum ParameterIndices { \
|
kTarget, \
|
kNewTarget, \
|
kActualArgumentsCount, \
|
##__VA_ARGS__, \
|
\
|
kParameterCount, \
|
kContext = kParameterCount /* implicit parameter */ \
|
};
|
|
#define DEFINE_JS_PARAMETER_TYPES(...) \
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), /* kTarget */ \
|
MachineType::AnyTagged(), /* kNewTarget */ \
|
MachineType::Int32(), /* kActualArgumentsCount */ \
|
##__VA_ARGS__)
|
|
#define DECLARE_DESCRIPTOR(name, base) \
|
DECLARE_DESCRIPTOR_WITH_BASE(name, base) \
|
protected: \
|
void InitializePlatformSpecific(CallInterfaceDescriptorData* data) override; \
|
name(CallDescriptors::Key key) : base(key) {} \
|
\
|
public:
|
|
class V8_EXPORT_PRIVATE VoidDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS()
|
DEFINE_PARAMETER_TYPES()
|
DECLARE_DESCRIPTOR(VoidDescriptor, CallInterfaceDescriptor)
|
};
|
|
class AllocateDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS_NO_CONTEXT(kRequestedSize)
|
DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::TaggedPointer(), // result 1
|
MachineType::Int32()) // kRequestedSize
|
DECLARE_DESCRIPTOR(AllocateDescriptor, CallInterfaceDescriptor)
|
};
|
|
// This descriptor defines the JavaScript calling convention that can be used
|
// by stubs: target, new.target, argc (not including the receiver) and context
|
// are passed in registers while receiver and the rest of the JS arguments are
|
// passed on the stack.
|
class JSTrampolineDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_JS_PARAMETERS()
|
DEFINE_JS_PARAMETER_TYPES()
|
|
DECLARE_JS_COMPATIBLE_DESCRIPTOR(JSTrampolineDescriptor,
|
CallInterfaceDescriptor, 0)
|
};
|
|
class ContextOnlyDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS()
|
DEFINE_PARAMETER_TYPES()
|
DECLARE_DESCRIPTOR(ContextOnlyDescriptor, CallInterfaceDescriptor)
|
};
|
|
class NoContextDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS_NO_CONTEXT()
|
DEFINE_PARAMETER_TYPES()
|
DECLARE_DESCRIPTOR(NoContextDescriptor, CallInterfaceDescriptor)
|
};
|
|
// LoadDescriptor is used by all stubs that implement Load/KeyedLoad ICs.
|
class LoadDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kReceiver, kName, kSlot)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
|
MachineType::AnyTagged(), // kName
|
MachineType::TaggedSigned()) // kSlot
|
DECLARE_DESCRIPTOR(LoadDescriptor, CallInterfaceDescriptor)
|
|
static const Register ReceiverRegister();
|
static const Register NameRegister();
|
static const Register SlotRegister();
|
};
|
|
class LoadGlobalDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kName, kSlot)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
|
MachineType::TaggedSigned()) // kSlot
|
DECLARE_DESCRIPTOR(LoadGlobalDescriptor, CallInterfaceDescriptor)
|
|
static const Register NameRegister() {
|
return LoadDescriptor::NameRegister();
|
}
|
|
static const Register SlotRegister() {
|
return LoadDescriptor::SlotRegister();
|
}
|
};
|
|
class StoreDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kReceiver, kName, kValue, kSlot)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
|
MachineType::AnyTagged(), // kName
|
MachineType::AnyTagged(), // kValue
|
MachineType::TaggedSigned()) // kSlot
|
DECLARE_DESCRIPTOR(StoreDescriptor, CallInterfaceDescriptor)
|
|
static const Register ReceiverRegister();
|
static const Register NameRegister();
|
static const Register ValueRegister();
|
static const Register SlotRegister();
|
|
#if V8_TARGET_ARCH_IA32
|
static const bool kPassLastArgsOnStack = true;
|
#else
|
static const bool kPassLastArgsOnStack = false;
|
#endif
|
|
// Pass value and slot through the stack.
|
static const int kStackArgumentsCount = kPassLastArgsOnStack ? 2 : 0;
|
};
|
|
class StoreTransitionDescriptor : public StoreDescriptor {
|
public:
|
DEFINE_PARAMETERS(kReceiver, kName, kMap, kValue, kSlot, kVector)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
|
MachineType::AnyTagged(), // kName
|
MachineType::AnyTagged(), // kMap
|
MachineType::AnyTagged(), // kValue
|
MachineType::TaggedSigned(), // kSlot
|
MachineType::AnyTagged()) // kVector
|
DECLARE_DESCRIPTOR(StoreTransitionDescriptor, StoreDescriptor)
|
|
static const Register MapRegister();
|
static const Register SlotRegister();
|
static const Register VectorRegister();
|
|
// Pass value, slot and vector through the stack.
|
static const int kStackArgumentsCount = kPassLastArgsOnStack ? 3 : 0;
|
};
|
|
class StoreWithVectorDescriptor : public StoreDescriptor {
|
public:
|
DEFINE_PARAMETERS(kReceiver, kName, kValue, kSlot, kVector)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
|
MachineType::AnyTagged(), // kName
|
MachineType::AnyTagged(), // kValue
|
MachineType::TaggedSigned(), // kSlot
|
MachineType::AnyTagged()) // kVector
|
DECLARE_DESCRIPTOR(StoreWithVectorDescriptor, StoreDescriptor)
|
|
static const Register VectorRegister();
|
|
// Pass value, slot and vector through the stack.
|
static const int kStackArgumentsCount = kPassLastArgsOnStack ? 3 : 0;
|
};
|
|
class StoreGlobalDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kName, kValue, kSlot)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
|
MachineType::AnyTagged(), // kValue
|
MachineType::TaggedSigned()) // kSlot
|
DECLARE_DESCRIPTOR(StoreGlobalDescriptor, CallInterfaceDescriptor)
|
|
static const bool kPassLastArgsOnStack =
|
StoreDescriptor::kPassLastArgsOnStack;
|
// Pass value and slot through the stack.
|
static const int kStackArgumentsCount = kPassLastArgsOnStack ? 2 : 0;
|
|
static const Register NameRegister() {
|
return StoreDescriptor::NameRegister();
|
}
|
|
static const Register ValueRegister() {
|
return StoreDescriptor::ValueRegister();
|
}
|
|
static const Register SlotRegister() {
|
return StoreDescriptor::SlotRegister();
|
}
|
};
|
|
class StoreGlobalWithVectorDescriptor : public StoreGlobalDescriptor {
|
public:
|
DEFINE_PARAMETERS(kName, kValue, kSlot, kVector)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
|
MachineType::AnyTagged(), // kValue
|
MachineType::TaggedSigned(), // kSlot
|
MachineType::AnyTagged()) // kVector
|
DECLARE_DESCRIPTOR(StoreGlobalWithVectorDescriptor, StoreGlobalDescriptor)
|
|
static const Register VectorRegister() {
|
return StoreWithVectorDescriptor::VectorRegister();
|
}
|
|
// Pass value, slot and vector through the stack.
|
static const int kStackArgumentsCount = kPassLastArgsOnStack ? 3 : 0;
|
};
|
|
class LoadWithVectorDescriptor : public LoadDescriptor {
|
public:
|
DEFINE_PARAMETERS(kReceiver, kName, kSlot, kVector)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
|
MachineType::AnyTagged(), // kName
|
MachineType::TaggedSigned(), // kSlot
|
MachineType::AnyTagged()) // kVector
|
DECLARE_DESCRIPTOR(LoadWithVectorDescriptor, LoadDescriptor)
|
|
static const Register VectorRegister();
|
};
|
|
class LoadGlobalWithVectorDescriptor : public LoadGlobalDescriptor {
|
public:
|
DEFINE_PARAMETERS(kName, kSlot, kVector)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
|
MachineType::TaggedSigned(), // kSlot
|
MachineType::AnyTagged()) // kVector
|
DECLARE_DESCRIPTOR(LoadGlobalWithVectorDescriptor, LoadGlobalDescriptor)
|
|
static const Register VectorRegister() {
|
return LoadWithVectorDescriptor::VectorRegister();
|
}
|
};
|
|
class FastNewFunctionContextDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kScopeInfo, kSlots)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kScopeInfo
|
MachineType::Int32()) // kSlots
|
DECLARE_DESCRIPTOR(FastNewFunctionContextDescriptor, CallInterfaceDescriptor)
|
|
static const Register ScopeInfoRegister();
|
static const Register SlotsRegister();
|
};
|
|
class FastNewObjectDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kTarget, kNewTarget)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
|
MachineType::AnyTagged()) // kNewTarget
|
DECLARE_DESCRIPTOR(FastNewObjectDescriptor, CallInterfaceDescriptor)
|
static const Register TargetRegister();
|
static const Register NewTargetRegister();
|
};
|
|
class RecordWriteDescriptor final : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kObject, kSlot, kIsolate, kRememberedSet, kFPMode)
|
DEFINE_PARAMETER_TYPES(MachineType::TaggedPointer(), // kObject
|
MachineType::Pointer(), // kSlot
|
MachineType::Pointer(), // kIsolate
|
MachineType::TaggedSigned(), // kRememberedSet
|
MachineType::TaggedSigned()) // kFPMode
|
|
DECLARE_DESCRIPTOR(RecordWriteDescriptor, CallInterfaceDescriptor)
|
};
|
|
class TypeConversionDescriptor final : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kArgument)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged())
|
DECLARE_DESCRIPTOR(TypeConversionDescriptor, CallInterfaceDescriptor)
|
|
static const Register ArgumentRegister();
|
};
|
|
class TypeConversionStackParameterDescriptor final
|
: public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kArgument)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged())
|
DECLARE_DESCRIPTOR(TypeConversionStackParameterDescriptor,
|
CallInterfaceDescriptor)
|
};
|
|
class GetPropertyDescriptor final : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kObject, kKey)
|
DECLARE_DEFAULT_DESCRIPTOR(GetPropertyDescriptor, CallInterfaceDescriptor)
|
};
|
|
class TypeofDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kObject)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged())
|
DECLARE_DESCRIPTOR(TypeofDescriptor, CallInterfaceDescriptor)
|
};
|
|
class CallTrampolineDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kFunction, kActualArgumentsCount)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction
|
MachineType::Int32()) // kActualArgumentsCount
|
DECLARE_DESCRIPTOR(CallTrampolineDescriptor, CallInterfaceDescriptor)
|
};
|
|
class CallVarargsDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kTarget, kActualArgumentsCount, kArgumentsList,
|
kArgumentsLength)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
|
MachineType::Int32(), // kActualArgumentsCount
|
MachineType::AnyTagged(), // kArgumentsList
|
MachineType::Int32()) // kArgumentsLength
|
DECLARE_DESCRIPTOR(CallVarargsDescriptor, CallInterfaceDescriptor)
|
};
|
|
class CallForwardVarargsDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kTarget, kActualArgumentsCount, kStartIndex)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
|
MachineType::Int32(), // kActualArgumentsCount
|
MachineType::Int32()) // kStartIndex
|
DECLARE_DESCRIPTOR(CallForwardVarargsDescriptor, CallInterfaceDescriptor)
|
};
|
|
class CallWithSpreadDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kTarget, kArgumentsCount, kSpread)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
|
MachineType::Int32(), // kArgumentsCount
|
MachineType::AnyTagged()) // kSpread
|
DECLARE_DESCRIPTOR(CallWithSpreadDescriptor, CallInterfaceDescriptor)
|
};
|
|
class CallWithArrayLikeDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kTarget, kArgumentsList)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
|
MachineType::AnyTagged()) // kArgumentsList
|
DECLARE_DESCRIPTOR(CallWithArrayLikeDescriptor, CallInterfaceDescriptor)
|
};
|
|
class ConstructVarargsDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_JS_PARAMETERS(kArgumentsList, kArgumentsLength)
|
DEFINE_JS_PARAMETER_TYPES(MachineType::AnyTagged(), // kArgumentsList
|
MachineType::Int32()) // kArgumentsLength
|
DECLARE_DESCRIPTOR(ConstructVarargsDescriptor, CallInterfaceDescriptor)
|
};
|
|
class ConstructForwardVarargsDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_JS_PARAMETERS(kStartIndex)
|
DEFINE_JS_PARAMETER_TYPES(MachineType::Int32())
|
DECLARE_DESCRIPTOR(ConstructForwardVarargsDescriptor, CallInterfaceDescriptor)
|
};
|
|
class ConstructWithSpreadDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_JS_PARAMETERS(kSpread)
|
DEFINE_JS_PARAMETER_TYPES(MachineType::AnyTagged())
|
DECLARE_DESCRIPTOR(ConstructWithSpreadDescriptor, CallInterfaceDescriptor)
|
};
|
|
class ConstructWithArrayLikeDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kTarget, kNewTarget, kArgumentsList)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
|
MachineType::AnyTagged(), // kNewTarget
|
MachineType::AnyTagged()) // kArgumentsList
|
DECLARE_DESCRIPTOR(ConstructWithArrayLikeDescriptor, CallInterfaceDescriptor)
|
};
|
|
// TODO(ishell): consider merging this with ArrayConstructorDescriptor
|
class ConstructStubDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_JS_PARAMETERS(kAllocationSite)
|
DEFINE_JS_PARAMETER_TYPES(MachineType::AnyTagged());
|
|
// TODO(ishell): Use DECLARE_JS_COMPATIBLE_DESCRIPTOR if registers match
|
DECLARE_DESCRIPTOR(ConstructStubDescriptor, CallInterfaceDescriptor)
|
};
|
|
class CallFunctionDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kTarget)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged())
|
DECLARE_DESCRIPTOR(CallFunctionDescriptor, CallInterfaceDescriptor)
|
};
|
|
class AbortDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS_NO_CONTEXT(kMessageOrMessageId)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged())
|
DECLARE_DESCRIPTOR(AbortDescriptor, CallInterfaceDescriptor)
|
};
|
|
class AllocateHeapNumberDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS_NO_CONTEXT()
|
DEFINE_PARAMETER_TYPES()
|
DECLARE_DESCRIPTOR(AllocateHeapNumberDescriptor, CallInterfaceDescriptor)
|
};
|
|
class ArrayConstructorDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_JS_PARAMETERS(kAllocationSite)
|
DEFINE_JS_PARAMETER_TYPES(MachineType::AnyTagged());
|
|
DECLARE_JS_COMPATIBLE_DESCRIPTOR(ArrayConstructorDescriptor,
|
CallInterfaceDescriptor, 1)
|
};
|
|
class ArrayNArgumentsConstructorDescriptor : public CallInterfaceDescriptor {
|
public:
|
// This descriptor declares only register arguments while respective number
|
// of JS arguments stay on the expression stack.
|
// The ArrayNArgumentsConstructor builtin does not access stack arguments
|
// directly it just forwards them to the runtime function.
|
DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction,
|
MachineType::AnyTagged(), // kAllocationSite
|
MachineType::Int32()) // kActualArgumentsCount
|
DECLARE_DESCRIPTOR(ArrayNArgumentsConstructorDescriptor,
|
CallInterfaceDescriptor)
|
};
|
|
class ArrayNoArgumentConstructorDescriptor
|
: public ArrayNArgumentsConstructorDescriptor {
|
public:
|
// This descriptor declares same register arguments as the parent
|
// ArrayNArgumentsConstructorDescriptor and it declares indices for
|
// JS arguments passed on the expression stack.
|
DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount,
|
kFunctionParameter)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction
|
MachineType::AnyTagged(), // kAllocationSite
|
MachineType::Int32(), // kActualArgumentsCount
|
MachineType::AnyTagged()) // kFunctionParameter
|
DECLARE_DESCRIPTOR(ArrayNoArgumentConstructorDescriptor,
|
ArrayNArgumentsConstructorDescriptor)
|
};
|
|
class ArraySingleArgumentConstructorDescriptor
|
: public ArrayNArgumentsConstructorDescriptor {
|
public:
|
// This descriptor declares same register arguments as the parent
|
// ArrayNArgumentsConstructorDescriptor and it declares indices for
|
// JS arguments passed on the expression stack.
|
DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount,
|
kFunctionParameter, kArraySizeSmiParameter)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction
|
MachineType::AnyTagged(), // kAllocationSite
|
MachineType::Int32(), // kActualArgumentsCount
|
MachineType::AnyTagged(), // kFunctionParameter
|
MachineType::AnyTagged()) // kArraySizeSmiParameter
|
DECLARE_DESCRIPTOR(ArraySingleArgumentConstructorDescriptor,
|
ArrayNArgumentsConstructorDescriptor)
|
};
|
|
class CompareDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kLeft, kRight)
|
DECLARE_DESCRIPTOR(CompareDescriptor, CallInterfaceDescriptor)
|
};
|
|
|
class BinaryOpDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kLeft, kRight)
|
DECLARE_DESCRIPTOR(BinaryOpDescriptor, CallInterfaceDescriptor)
|
};
|
|
// This desciptor is shared among String.p.charAt/charCodeAt/codePointAt
|
// as they all have the same interface.
|
class StringAtDescriptor final : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kReceiver, kPosition)
|
// TODO(turbofan): Return untagged value here.
|
DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::TaggedSigned(), // result 1
|
MachineType::AnyTagged(), // kReceiver
|
MachineType::IntPtr()) // kPosition
|
DECLARE_DESCRIPTOR(StringAtDescriptor, CallInterfaceDescriptor)
|
};
|
|
class StringSubstringDescriptor final : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kString, kFrom, kTo)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kString
|
MachineType::IntPtr(), // kFrom
|
MachineType::IntPtr()) // kTo
|
|
// TODO(turbofan): Allow builtins to return untagged values.
|
DECLARE_DESCRIPTOR(StringSubstringDescriptor, CallInterfaceDescriptor)
|
};
|
|
class ArgumentAdaptorDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_JS_PARAMETERS(kExpectedArgumentsCount)
|
DEFINE_JS_PARAMETER_TYPES(MachineType::Int32())
|
DECLARE_DESCRIPTOR(ArgumentAdaptorDescriptor, CallInterfaceDescriptor)
|
};
|
|
class CppBuiltinAdaptorDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_JS_PARAMETERS(kCFunction)
|
DEFINE_JS_PARAMETER_TYPES(MachineType::Pointer())
|
DECLARE_JS_COMPATIBLE_DESCRIPTOR(CppBuiltinAdaptorDescriptor,
|
CallInterfaceDescriptor, 1)
|
};
|
|
class CEntry1ArgvOnStackDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kArity, // register argument
|
kCFunction, // register argument
|
kPadding, // stack argument 1 (just padding)
|
kArgcSmi, // stack argument 2
|
kTargetCopy, // stack argument 3
|
kNewTargetCopy) // stack argument 4
|
DEFINE_PARAMETER_TYPES(MachineType::Int32(), // kArity
|
MachineType::Pointer(), // kCFunction
|
MachineType::AnyTagged(), // kPadding
|
MachineType::AnyTagged(), // kArgcSmi
|
MachineType::AnyTagged(), // kTargetCopy
|
MachineType::AnyTagged()) // kNewTargetCopy
|
DECLARE_DESCRIPTOR(CEntry1ArgvOnStackDescriptor, CallInterfaceDescriptor)
|
};
|
|
class ApiCallbackDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS_NO_CONTEXT(kTargetContext, kCallData, kHolder,
|
kApiFunctionAddress)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTargetContext
|
MachineType::AnyTagged(), // kCallData
|
MachineType::AnyTagged(), // kHolder
|
MachineType::Pointer()) // kApiFunctionAddress
|
DECLARE_DESCRIPTOR(ApiCallbackDescriptor, CallInterfaceDescriptor)
|
};
|
|
class ApiGetterDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kReceiver, kHolder, kCallback)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
|
MachineType::AnyTagged(), // kHolder
|
MachineType::AnyTagged()) // kCallback
|
DECLARE_DESCRIPTOR(ApiGetterDescriptor, CallInterfaceDescriptor)
|
|
static const Register ReceiverRegister();
|
static const Register HolderRegister();
|
static const Register CallbackRegister();
|
};
|
|
// TODO(turbofan): We should probably rename this to GrowFastElementsDescriptor.
|
class GrowArrayElementsDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kObject, kKey)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kObject
|
MachineType::AnyTagged()) // kKey
|
DECLARE_DESCRIPTOR(GrowArrayElementsDescriptor, CallInterfaceDescriptor)
|
|
static const Register ObjectRegister();
|
static const Register KeyRegister();
|
};
|
|
class NewArgumentsElementsDescriptor final : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kFrame, kLength, kMappedCount)
|
DEFINE_PARAMETER_TYPES(MachineType::Pointer(), // kFrame
|
MachineType::TaggedSigned(), // kLength
|
MachineType::TaggedSigned()) // kMappedCount
|
DECLARE_DESCRIPTOR(NewArgumentsElementsDescriptor, CallInterfaceDescriptor)
|
};
|
|
class V8_EXPORT_PRIVATE InterpreterDispatchDescriptor
|
: public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kAccumulator, kBytecodeOffset, kBytecodeArray,
|
kDispatchTable)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kAccumulator
|
MachineType::IntPtr(), // kBytecodeOffset
|
MachineType::AnyTagged(), // kBytecodeArray
|
MachineType::IntPtr()) // kDispatchTable
|
DECLARE_DESCRIPTOR(InterpreterDispatchDescriptor, CallInterfaceDescriptor)
|
};
|
|
class InterpreterPushArgsThenCallDescriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kNumberOfArguments, kFirstArgument, kFunction)
|
DEFINE_PARAMETER_TYPES(MachineType::Int32(), // kNumberOfArguments
|
MachineType::Pointer(), // kFirstArgument
|
MachineType::AnyTagged()) // kFunction
|
DECLARE_DESCRIPTOR(InterpreterPushArgsThenCallDescriptor,
|
CallInterfaceDescriptor)
|
};
|
|
class InterpreterPushArgsThenConstructDescriptor
|
: public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kNumberOfArguments, kNewTarget, kConstructor,
|
kFeedbackElement, kFirstArgument)
|
DEFINE_PARAMETER_TYPES(MachineType::Int32(), // kNumberOfArguments
|
MachineType::AnyTagged(), // kNewTarget
|
MachineType::AnyTagged(), // kConstructor
|
MachineType::AnyTagged(), // kFeedbackElement
|
MachineType::Pointer()) // kFirstArgument
|
DECLARE_DESCRIPTOR(InterpreterPushArgsThenConstructDescriptor,
|
CallInterfaceDescriptor)
|
};
|
|
class InterpreterCEntry1Descriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_RESULT_AND_PARAMETERS(1, kNumberOfArguments, kFirstArgument,
|
kFunctionEntry)
|
DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result 1
|
MachineType::Int32(), // kNumberOfArguments
|
MachineType::Pointer(), // kFirstArgument
|
MachineType::Pointer()) // kFunctionEntry
|
DECLARE_DESCRIPTOR(InterpreterCEntry1Descriptor, CallInterfaceDescriptor)
|
};
|
|
class InterpreterCEntry2Descriptor : public CallInterfaceDescriptor {
|
public:
|
DEFINE_RESULT_AND_PARAMETERS(2, kNumberOfArguments, kFirstArgument,
|
kFunctionEntry)
|
DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result 1
|
MachineType::AnyTagged(), // result 2
|
MachineType::Int32(), // kNumberOfArguments
|
MachineType::Pointer(), // kFirstArgument
|
MachineType::Pointer()) // kFunctionEntry
|
DECLARE_DESCRIPTOR(InterpreterCEntry2Descriptor, CallInterfaceDescriptor)
|
};
|
|
class ResumeGeneratorDescriptor final : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kValue, kGenerator)
|
DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kValue
|
MachineType::AnyTagged()) // kGenerator
|
DECLARE_DESCRIPTOR(ResumeGeneratorDescriptor, CallInterfaceDescriptor)
|
};
|
|
class FrameDropperTrampolineDescriptor final : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kRestartFp)
|
DEFINE_PARAMETER_TYPES(MachineType::Pointer())
|
DECLARE_DESCRIPTOR(FrameDropperTrampolineDescriptor, CallInterfaceDescriptor)
|
};
|
|
class RunMicrotasksDescriptor final : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS()
|
DECLARE_DEFAULT_DESCRIPTOR(RunMicrotasksDescriptor, CallInterfaceDescriptor)
|
};
|
|
class WasmGrowMemoryDescriptor final : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS_NO_CONTEXT(kNumPages)
|
DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::Int32(), // result 1
|
MachineType::Int32()) // kNumPages
|
DECLARE_DESCRIPTOR(WasmGrowMemoryDescriptor, CallInterfaceDescriptor)
|
};
|
|
class CloneObjectWithVectorDescriptor final : public CallInterfaceDescriptor {
|
public:
|
DEFINE_PARAMETERS(kSource, kFlags, kSlot, kVector)
|
DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::TaggedPointer(), // result 1
|
MachineType::AnyTagged(), // kSource
|
MachineType::TaggedSigned(), // kFlags
|
MachineType::TaggedSigned(), // kSlot
|
MachineType::AnyTagged()) // kVector
|
DECLARE_DESCRIPTOR(CloneObjectWithVectorDescriptor, CallInterfaceDescriptor)
|
};
|
|
#define DEFINE_TFS_BUILTIN_DESCRIPTOR(Name, ...) \
|
class Name##Descriptor : public CallInterfaceDescriptor { \
|
public: \
|
DEFINE_PARAMETERS(__VA_ARGS__) \
|
DECLARE_DEFAULT_DESCRIPTOR(Name##Descriptor, CallInterfaceDescriptor) \
|
};
|
BUILTIN_LIST_TFS(DEFINE_TFS_BUILTIN_DESCRIPTOR)
|
#undef DEFINE_TFS_BUILTIN_DESCRIPTOR
|
|
#undef DECLARE_DEFAULT_DESCRIPTOR
|
#undef DECLARE_DESCRIPTOR_WITH_BASE
|
#undef DECLARE_DESCRIPTOR
|
#undef DECLARE_JS_COMPATIBLE_DESCRIPTOR
|
#undef DEFINE_RESULT_AND_PARAMETERS
|
#undef DEFINE_RESULT_AND_PARAMETERS_NO_CONTEXT
|
#undef DEFINE_PARAMETERS
|
#undef DEFINE_PARAMETERS_NO_CONTEXT
|
#undef DEFINE_RESULT_AND_PARAMETER_TYPES
|
#undef DEFINE_PARAMETER_TYPES
|
#undef DEFINE_JS_PARAMETERS
|
#undef DEFINE_JS_PARAMETER_TYPES
|
|
// We define the association between CallDescriptors::Key and the specialized
|
// descriptor here to reduce boilerplate and mistakes.
|
#define DEF_KEY(name, ...) \
|
CallDescriptors::Key name##Descriptor::key() { return CallDescriptors::name; }
|
INTERFACE_DESCRIPTOR_LIST(DEF_KEY)
|
#undef DEF_KEY
|
} // namespace internal
|
} // namespace v8
|
|
#endif // V8_INTERFACE_DESCRIPTORS_H_
|
