1 // Copyright 2014 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef V8_CODEGEN_INTERFACE_DESCRIPTORS_H_
6 #define V8_CODEGEN_INTERFACE_DESCRIPTORS_H_
7
8 #include <memory>
9
10 #include "src/base/logging.h"
11 #include "src/codegen/machine-type.h"
12 #include "src/codegen/register.h"
13 #include "src/codegen/tnode.h"
14 #include "src/common/globals.h"
15 #include "src/execution/isolate.h"
16
17 namespace v8 {
18 namespace internal {
19
20 #define TORQUE_BUILTIN_LIST_TFC(V) \
21 BUILTIN_LIST_FROM_TORQUE(IGNORE_BUILTIN, IGNORE_BUILTIN, V, IGNORE_BUILTIN, \
22 IGNORE_BUILTIN, IGNORE_BUILTIN)
23
24 #define INTERFACE_DESCRIPTOR_LIST(V) \
25 V(Abort) \
26 V(Allocate) \
27 V(ApiCallback) \
28 V(ApiGetter) \
29 V(ArrayConstructor) \
30 V(ArrayNArgumentsConstructor) \
31 V(ArrayNoArgumentConstructor) \
32 V(ArraySingleArgumentConstructor) \
33 V(AsyncFunctionStackParameter) \
34 V(BigIntToI32Pair) \
35 V(BigIntToI64) \
36 V(BinaryOp) \
37 V(BinaryOp_Baseline) \
38 V(BinarySmiOp_Baseline) \
39 V(BinaryOp_WithFeedback) \
40 V(CallForwardVarargs) \
41 V(CallFunctionTemplate) \
42 V(CopyDataPropertiesWithExcludedProperties) \
43 V(CopyDataPropertiesWithExcludedPropertiesOnStack) \
44 V(CallTrampoline) \
45 V(CallTrampoline_Baseline) \
46 V(CallTrampoline_Baseline_Compact) \
47 V(CallTrampoline_WithFeedback) \
48 V(CallVarargs) \
49 V(CallWithArrayLike) \
50 V(CallWithArrayLike_WithFeedback) \
51 V(CallWithSpread) \
52 V(CallWithSpread_Baseline) \
53 V(CallWithSpread_WithFeedback) \
54 V(CEntry1ArgvOnStack) \
55 V(CloneObjectBaseline) \
56 V(CloneObjectWithVector) \
57 V(Compare) \
58 V(Compare_Baseline) \
59 V(Compare_WithFeedback) \
60 V(ConstructForwardVarargs) \
61 V(ConstructStub) \
62 V(ConstructVarargs) \
63 V(ConstructWithArrayLike) \
64 V(ConstructWithArrayLike_WithFeedback) \
65 V(Construct_WithFeedback) \
66 V(Construct_Baseline) \
67 V(ConstructWithSpread) \
68 V(ConstructWithSpread_Baseline) \
69 V(ConstructWithSpread_WithFeedback) \
70 V(ContextOnly) \
71 V(CppBuiltinAdaptor) \
72 V(FastNewObject) \
73 V(ForInPrepare) \
74 V(GetIteratorStackParameter) \
75 V(GetProperty) \
76 V(GrowArrayElements) \
77 V(I32PairToBigInt) \
78 V(I64ToBigInt) \
79 V(InterpreterCEntry1) \
80 V(InterpreterCEntry2) \
81 V(InterpreterDispatch) \
82 V(InterpreterPushArgsThenCall) \
83 V(InterpreterPushArgsThenConstruct) \
84 V(JSTrampoline) \
85 V(BaselineOutOfLinePrologue) \
86 V(BaselineLeaveFrame) \
87 V(Load) \
88 V(LoadBaseline) \
89 V(LoadGlobal) \
90 V(LoadGlobalBaseline) \
91 V(LoadGlobalNoFeedback) \
92 V(LoadGlobalWithVector) \
93 V(LoadNoFeedback) \
94 V(LoadWithVector) \
95 V(KeyedLoad) \
96 V(KeyedLoadBaseline) \
97 V(KeyedLoadWithVector) \
98 V(KeyedHasICBaseline) \
99 V(KeyedHasICWithVector) \
100 V(LoadWithReceiverAndVector) \
101 V(LoadWithReceiverBaseline) \
102 V(LookupBaseline) \
103 V(NoContext) \
104 V(ResumeGenerator) \
105 V(SuspendGeneratorBaseline) \
106 V(ResumeGeneratorBaseline) \
107 V(RunMicrotasks) \
108 V(RunMicrotasksEntry) \
109 V(SingleParameterOnStack) \
110 V(Store) \
111 V(StoreBaseline) \
112 V(StoreGlobal) \
113 V(StoreGlobalBaseline) \
114 V(StoreGlobalWithVector) \
115 V(StoreTransition) \
116 V(StoreWithVector) \
117 V(StringAtAsString) \
118 V(StringSubstring) \
119 IF_TSAN(V, TSANStore) \
120 IF_TSAN(V, TSANLoad) \
121 V(TypeConversion) \
122 V(TypeConversionNoContext) \
123 V(TypeConversion_Baseline) \
124 V(Typeof) \
125 V(UnaryOp_Baseline) \
126 V(UnaryOp_WithFeedback) \
127 V(Void) \
128 V(WasmFloat32ToNumber) \
129 V(WasmFloat64ToNumber) \
130 V(WasmI32AtomicWait32) \
131 V(WasmI64AtomicWait32) \
132 V(WasmSuspend) \
133 V(WriteBarrier) \
134 BUILTIN_LIST_TFS(V) \
135 TORQUE_BUILTIN_LIST_TFC(V)
136
137 enum class StackArgumentOrder {
138 kDefault, // Arguments in the stack are pushed in the default/stub order (the
139 // first argument is pushed first).
140 kJS, // Arguments in the stack are pushed in the same order as the one used
141 // by JS-to-JS function calls. This should be used if calling a
142 // JSFunction or if the builtin is expected to be called directly from a
143 // JSFunction. This order is reversed compared to kDefault.
144 };
145
146 class V8_EXPORT_PRIVATE CallInterfaceDescriptorData {
147 public:
148 enum Flag {
149 kNoFlags = 0u,
150 kNoContext = 1u << 0,
151 // This indicates that the code uses a special frame that does not scan the
152 // stack arguments, e.g. EntryFrame. And this allows the code to use
153 // untagged stack arguments.
154 kNoStackScan = 1u << 1,
155 // In addition to the specified parameters, additional arguments can be
156 // passed on the stack.
157 // This does not indicate if arguments adaption is used or not.
158 kAllowVarArgs = 1u << 2,
159 // Callee save allocatable_registers.
160 kCalleeSaveRegisters = 1u << 3,
161 };
162 using Flags = base::Flags<Flag>;
163
164 static constexpr int kUninitializedCount = -1;
165
166 CallInterfaceDescriptorData() = default;
167
168 CallInterfaceDescriptorData(const CallInterfaceDescriptorData&) = delete;
169 CallInterfaceDescriptorData& operator=(const CallInterfaceDescriptorData&) =
170 delete;
171
172 // The passed registers are owned by the caller, and their lifetime is
173 // expected to exceed that of this data. In practice, they are expected to
174 // be in a static local.
175 void InitializeRegisters(Flags flags, int return_count, int parameter_count,
176 StackArgumentOrder stack_order,
177 int register_parameter_count,
178 const Register* registers);
179
180 // if machine_types is null, then an array of size
181 // (return_count + parameter_count) will be created with
182 // MachineType::AnyTagged() for each member.
183 //
184 // if machine_types is not null, then it should be of the size
185 // (return_count + parameter_count). Those members of the parameter array will
186 // be initialized from {machine_types}, and the rest initialized to
187 // MachineType::AnyTagged().
188 void InitializeTypes(const MachineType* machine_types,
189 int machine_types_length);
190
191 void Reset();
192
IsInitialized()193 bool IsInitialized() const {
194 return IsInitializedRegisters() && IsInitializedTypes();
195 }
196
flags()197 Flags flags() const { return flags_; }
return_count()198 int return_count() const { return return_count_; }
param_count()199 int param_count() const { return param_count_; }
register_param_count()200 int register_param_count() const { return register_param_count_; }
register_param(int index)201 Register register_param(int index) const { return register_params_[index]; }
return_type(int index)202 MachineType return_type(int index) const {
203 DCHECK_LT(index, return_count_);
204 return machine_types_[index];
205 }
param_type(int index)206 MachineType param_type(int index) const {
207 DCHECK_LT(index, param_count_);
208 return machine_types_[return_count_ + index];
209 }
stack_order()210 StackArgumentOrder stack_order() const { return stack_order_; }
211
RestrictAllocatableRegisters(const Register * registers,size_t num)212 void RestrictAllocatableRegisters(const Register* registers, size_t num) {
213 DCHECK(allocatable_registers_.is_empty());
214 for (size_t i = 0; i < num; ++i) {
215 allocatable_registers_.set(registers[i]);
216 }
217 DCHECK(!allocatable_registers_.is_empty());
218 }
219
allocatable_registers()220 RegList allocatable_registers() const { return allocatable_registers_; }
221
222 private:
IsInitializedRegisters()223 bool IsInitializedRegisters() const {
224 const bool initialized =
225 return_count_ != kUninitializedCount &&
226 param_count_ != kUninitializedCount &&
227 (register_param_count_ == 0 || register_params_ != nullptr);
228 // Register initialization happens before type initialization.
229 return initialized;
230 }
IsInitializedTypes()231 bool IsInitializedTypes() const {
232 const bool initialized = machine_types_ != nullptr;
233 // Register initialization happens before type initialization.
234 return initialized;
235 }
236
237 #ifdef DEBUG
238 bool AllStackParametersAreTagged() const;
239 #endif // DEBUG
240
241 int register_param_count_ = kUninitializedCount;
242 int return_count_ = kUninitializedCount;
243 int param_count_ = kUninitializedCount;
244 Flags flags_ = kNoFlags;
245 StackArgumentOrder stack_order_ = StackArgumentOrder::kDefault;
246
247 // Specifying the set of registers that could be used by the register
248 // allocator. Currently, it's only used by RecordWrite code stub.
249 RegList allocatable_registers_;
250
251 // |registers_params_| defines registers that are used for parameter passing.
252 // |machine_types_| defines machine types for resulting values and incomping
253 // parameters.
254 // The register params array is owned by the caller, and it's expected that it
255 // is a static local stored in the caller function. The machine types are
256 // allocated dynamically by the InterfaceDescriptor and freed on destruction.
257 const Register* register_params_ = nullptr;
258 MachineType* machine_types_ = nullptr;
259 };
260
261 class V8_EXPORT_PRIVATE CallDescriptors : public AllStatic {
262 public:
263 enum Key {
264 #define DEF_ENUM(name, ...) name,
265 INTERFACE_DESCRIPTOR_LIST(DEF_ENUM)
266 #undef DEF_ENUM
267 NUMBER_OF_DESCRIPTORS
268 };
269
270 static void InitializeOncePerProcess();
271 static void TearDown();
272
call_descriptor_data(CallDescriptors::Key key)273 static CallInterfaceDescriptorData* call_descriptor_data(
274 CallDescriptors::Key key) {
275 return &call_descriptor_data_[key];
276 }
277
GetKey(const CallInterfaceDescriptorData * data)278 static Key GetKey(const CallInterfaceDescriptorData* data) {
279 ptrdiff_t index = data - call_descriptor_data_;
280 DCHECK_LE(0, index);
281 DCHECK_LT(index, CallDescriptors::NUMBER_OF_DESCRIPTORS);
282 return static_cast<CallDescriptors::Key>(index);
283 }
284
285 private:
286 static CallInterfaceDescriptorData
287 call_descriptor_data_[NUMBER_OF_DESCRIPTORS];
288 };
289
290 #if defined(V8_TARGET_ARCH_IA32)
291 // To support all possible cases, we must limit the number of register args for
292 // TFS builtins on ia32 to 3. Out of the 6 allocatable registers, esi is taken
293 // as the context register and ebx is the root register. One register must
294 // remain available to store the jump/call target. Thus 3 registers remain for
295 // arguments. The reason this applies to TFS builtins specifically is because
296 // this becomes relevant for builtins used as targets of Torque function
297 // pointers (which must have a register available to store the target).
298 // TODO(jgruber): Ideally we should just decrement kMaxBuiltinRegisterParams but
299 // that comes with its own set of complications. It's possible, but requires
300 // refactoring the calling convention of other existing stubs.
301 constexpr int kMaxBuiltinRegisterParams = 4;
302 constexpr int kMaxTFSBuiltinRegisterParams = 3;
303 #else
304 constexpr int kMaxBuiltinRegisterParams = 5;
305 constexpr int kMaxTFSBuiltinRegisterParams = kMaxBuiltinRegisterParams;
306 #endif
307 STATIC_ASSERT(kMaxTFSBuiltinRegisterParams <= kMaxBuiltinRegisterParams);
308 constexpr int kJSBuiltinRegisterParams = 4;
309
310 // Polymorphic base class for call interface descriptors, which defines getters
311 // for the various descriptor properties via a runtime-loaded
312 // CallInterfaceDescriptorData field.
313 class V8_EXPORT_PRIVATE CallInterfaceDescriptor {
314 public:
315 using Flags = CallInterfaceDescriptorData::Flags;
316
CallInterfaceDescriptor()317 CallInterfaceDescriptor() : data_(nullptr) {}
318 ~CallInterfaceDescriptor() = default;
319
CallInterfaceDescriptor(CallDescriptors::Key key)320 explicit CallInterfaceDescriptor(CallDescriptors::Key key)
321 : data_(CallDescriptors::call_descriptor_data(key)) {}
322
flags()323 Flags flags() const { return data()->flags(); }
324
HasContextParameter()325 bool HasContextParameter() const {
326 return (flags() & CallInterfaceDescriptorData::kNoContext) == 0;
327 }
328
AllowVarArgs()329 bool AllowVarArgs() const {
330 return flags() & CallInterfaceDescriptorData::kAllowVarArgs;
331 }
332
CalleeSaveRegisters()333 bool CalleeSaveRegisters() const {
334 return flags() & CallInterfaceDescriptorData::kCalleeSaveRegisters;
335 }
336
GetReturnCount()337 int GetReturnCount() const { return data()->return_count(); }
338
GetReturnType(int index)339 MachineType GetReturnType(int index) const {
340 DCHECK_LT(index, data()->return_count());
341 return data()->return_type(index);
342 }
343
GetParameterCount()344 int GetParameterCount() const { return data()->param_count(); }
345
GetRegisterParameterCount()346 int GetRegisterParameterCount() const {
347 return data()->register_param_count();
348 }
349
GetStackParameterCount()350 int GetStackParameterCount() const {
351 return data()->param_count() - data()->register_param_count();
352 }
353
GetRegisterParameter(int index)354 Register GetRegisterParameter(int index) const {
355 DCHECK_LT(index, data()->register_param_count());
356 return data()->register_param(index);
357 }
358
GetParameterType(int index)359 MachineType GetParameterType(int index) const {
360 DCHECK_LT(index, data()->param_count());
361 return data()->param_type(index);
362 }
363
allocatable_registers()364 RegList allocatable_registers() const {
365 return data()->allocatable_registers();
366 }
367
GetStackArgumentOrder()368 StackArgumentOrder GetStackArgumentOrder() const {
369 return data()->stack_order();
370 }
371
ContextRegister()372 static constexpr inline Register ContextRegister() {
373 return kContextRegister;
374 }
375
376 const char* DebugName() const;
377
378 bool operator==(const CallInterfaceDescriptor& other) const {
379 return data() == other.data();
380 }
381
382 protected:
data()383 const CallInterfaceDescriptorData* data() const { return data_; }
384
385 // Helper for defining the default register set.
386 //
387 // Use auto for the return type to allow different architectures to have
388 // differently sized default register arrays.
389 static constexpr inline auto DefaultRegisterArray();
390 static constexpr inline std::array<Register, kJSBuiltinRegisterParams>
391 DefaultJSRegisterArray();
392
393 // Checks if float parameters are not assigned invalid registers.
CheckFloatingPointParameters(CallInterfaceDescriptorData * data)394 bool CheckFloatingPointParameters(CallInterfaceDescriptorData* data) {
395 for (int i = 0; i < data->register_param_count(); i++) {
396 if (IsFloatingPoint(data->param_type(i).representation())) {
397 if (!IsValidFloatParameterRegister(data->register_param(i))) {
398 return false;
399 }
400 }
401 }
402 return true;
403 }
404
405 bool IsValidFloatParameterRegister(Register reg);
406
407 private:
408 const CallInterfaceDescriptorData* data_;
409 };
410
411 // CRTP base class for call interface descriptors, which defines static getters
412 // for the various descriptor properties based on static values defined in the
413 // subclass.
414 template <typename DerivedDescriptor>
415 class StaticCallInterfaceDescriptor : public CallInterfaceDescriptor {
416 public:
417 // ===========================================================================
418 // The following are the descriptor's CRTP configuration points, overwritable
419 // by DerivedDescriptor.
420 static constexpr int kReturnCount =
421 CallInterfaceDescriptorData::kUninitializedCount;
422 static constexpr int kParameterCount =
423 CallInterfaceDescriptorData::kUninitializedCount;
424 static constexpr bool kNoContext = false;
425 static constexpr bool kAllowVarArgs = false;
426 static constexpr bool kNoStackScan = false;
427 static constexpr auto kStackArgumentOrder = StackArgumentOrder::kDefault;
428
429 // The set of registers available to the parameters, as a
430 // std::array<Register,N>. Can be larger or smaller than kParameterCount; if
431 // larger then any remaining registers are ignored; if smaller, any parameters
432 // after registers().size() will be stack registers.
433 //
434 // Defaults to CallInterfaceDescriptor::DefaultRegisterArray().
435 static constexpr inline auto registers();
436
437 // An additional limit on the number of register parameters allowed. This is
438 // here so that it can be overwritten to kMaxTFSBuiltinRegisterParams for TFS
439 // builtins, see comment on kMaxTFSBuiltinRegisterParams above.
440 static constexpr int kMaxRegisterParams = kMaxBuiltinRegisterParams;
441
442 // If set to true, the descriptor will restrict the set of allocatable
443 // registers to the set returned by registers(). Then, it is expected that
444 // the first kParameterCount registers() are the parameters of the builtin.
445 static constexpr bool kRestrictAllocatableRegisters = false;
446
447 // If set to true, builtins will callee save the set returned by registers().
448 static constexpr bool kCalleeSaveRegisters = false;
449
450 // End of customization points.
451 // ===========================================================================
452
flags()453 static constexpr inline Flags flags() {
454 return Flags((DerivedDescriptor::kNoContext
455 ? CallInterfaceDescriptorData::kNoContext
456 : 0) |
457 (DerivedDescriptor::kAllowVarArgs
458 ? CallInterfaceDescriptorData::kAllowVarArgs
459 : 0) |
460 (DerivedDescriptor::kNoStackScan
461 ? CallInterfaceDescriptorData::kNoStackScan
462 : 0) |
463 (DerivedDescriptor::kCalleeSaveRegisters
464 ? CallInterfaceDescriptorData::kCalleeSaveRegisters
465 : 0));
466 }
AllowVarArgs()467 static constexpr inline bool AllowVarArgs() {
468 return DerivedDescriptor::kAllowVarArgs;
469 }
HasContextParameter()470 static constexpr inline bool HasContextParameter() {
471 return !DerivedDescriptor::kNoContext;
472 }
473
474 static constexpr inline int GetReturnCount();
475 static constexpr inline int GetParameterCount();
476 static constexpr inline int GetRegisterParameterCount();
477 static constexpr inline int GetStackParameterCount();
478 static constexpr inline Register* GetRegisterData();
479 static constexpr inline Register GetRegisterParameter(int i);
480
StaticCallInterfaceDescriptor(CallDescriptors::Key key)481 explicit StaticCallInterfaceDescriptor(CallDescriptors::Key key)
482 : CallInterfaceDescriptor(key) {}
483
484 #if DEBUG
485 // Overwritten in DerivedDescriptor.
486 static void Verify(CallInterfaceDescriptorData* data);
487 // Verify that the CallInterfaceDescriptorData contains the default
488 // argument registers for {argc} arguments.
489 static inline void VerifyArgumentRegisterCount(
490 CallInterfaceDescriptorData* data, int nof_expected_args);
491 #endif
492
493 private:
494 // {CallDescriptors} is allowed to call the private {Initialize} method.
495 friend class CallDescriptors;
496
497 inline void Initialize(CallInterfaceDescriptorData* data);
498
499 // Set up the types of the descriptor. This is a static function, so that it
500 // is overwritable by subclasses. By default, all parameters have
501 // MachineType::AnyTagged() type.
InitializeTypes(CallInterfaceDescriptorData * data)502 static void InitializeTypes(CallInterfaceDescriptorData* data) {
503 data->InitializeTypes(nullptr, 0);
504 }
505 };
506
507 template <typename Descriptor>
508 class StaticJSCallInterfaceDescriptor
509 : public StaticCallInterfaceDescriptor<Descriptor> {
510 public:
511 static constexpr auto kStackArgumentOrder = StackArgumentOrder::kJS;
512 static constexpr inline auto registers();
513
514 using StaticCallInterfaceDescriptor<
515 Descriptor>::StaticCallInterfaceDescriptor;
516 };
517
518 template <Builtin kBuiltin>
519 struct CallInterfaceDescriptorFor;
520
521 // Stub class replacing std::array<Register, 0>, as a workaround for MSVC's
522 // https://github.com/microsoft/STL/issues/942
523 struct EmptyRegisterArray {
dataEmptyRegisterArray524 Register* data() { return nullptr; }
sizeEmptyRegisterArray525 size_t size() const { return 0; }
526 Register operator[](size_t i) const { UNREACHABLE(); }
527 };
528
529 // Helper method for defining an array of unique registers for the various
530 // Descriptor::registers() methods.
531 template <typename... Registers>
RegisterArray(Register first_reg,Registers...regs)532 constexpr std::array<Register, 1 + sizeof...(Registers)> RegisterArray(
533 Register first_reg, Registers... regs) {
534 DCHECK(!AreAliased(first_reg, regs...));
535 return {first_reg, regs...};
536 }
RegisterArray()537 constexpr EmptyRegisterArray RegisterArray() { return {}; }
538
539 #define DECLARE_DESCRIPTOR_WITH_BASE(name, base) \
540 public: \
541 /* StaticCallInterfaceDescriptor can call Initialize methods */ \
542 friend class StaticCallInterfaceDescriptor<name>; \
543 explicit name() : base(key()) {} \
544 static inline CallDescriptors::Key key();
545
546 #define DECLARE_DEFAULT_DESCRIPTOR(name) \
547 DECLARE_DESCRIPTOR_WITH_BASE(name, StaticCallInterfaceDescriptor) \
548 static constexpr int kMaxRegisterParams = kMaxTFSBuiltinRegisterParams; \
549 \
550 protected: \
551 explicit name(CallDescriptors::Key key) \
552 : StaticCallInterfaceDescriptor(key) {} \
553 \
554 public:
555
556 #define DECLARE_JS_COMPATIBLE_DESCRIPTOR(name) \
557 DECLARE_DESCRIPTOR_WITH_BASE(name, StaticJSCallInterfaceDescriptor) \
558 protected: \
559 explicit name(CallDescriptors::Key key) \
560 : StaticJSCallInterfaceDescriptor(key) {} \
561 \
562 public:
563
564 #define DEFINE_RESULT_AND_PARAMETERS(return_count, ...) \
565 static constexpr int kReturnCount = return_count; \
566 enum ParameterIndices { \
567 __dummy = -1, /* to be able to pass zero arguments */ \
568 ##__VA_ARGS__, \
569 \
570 kParameterCount, \
571 kContext = kParameterCount /* implicit parameter */ \
572 };
573
574 // This is valid only for builtins that use EntryFrame, which does not scan
575 // stack arguments on GC.
576 #define DEFINE_PARAMETERS_ENTRY(...) \
577 static constexpr bool kNoContext = true; \
578 static constexpr bool kNoStackScan = true; \
579 static constexpr StackArgumentOrder kStackArgumentOrder = \
580 StackArgumentOrder::kDefault; \
581 static constexpr int kReturnCount = 1; \
582 enum ParameterIndices { \
583 __dummy = -1, /* to be able to pass zero arguments */ \
584 ##__VA_ARGS__, \
585 \
586 kParameterCount \
587 };
588
589 #define DEFINE_PARAMETERS(...) DEFINE_RESULT_AND_PARAMETERS(1, ##__VA_ARGS__)
590
591 #define DEFINE_PARAMETERS_NO_CONTEXT(...) \
592 DEFINE_PARAMETERS(__VA_ARGS__) \
593 static constexpr bool kNoContext = true;
594
595 #define DEFINE_PARAMETERS_VARARGS(...) \
596 DEFINE_PARAMETERS(__VA_ARGS__) \
597 static constexpr bool kAllowVarArgs = true; \
598 static constexpr StackArgumentOrder kStackArgumentOrder = \
599 StackArgumentOrder::kJS;
600
601 #define DEFINE_PARAMETERS_NO_CONTEXT_VARARGS(...) \
602 DEFINE_PARAMETERS_NO_CONTEXT(__VA_ARGS__) \
603 static constexpr bool kAllowVarArgs = true; \
604 static constexpr StackArgumentOrder kStackArgumentOrder = \
605 StackArgumentOrder::kJS;
606
607 #define DEFINE_RESULT_AND_PARAMETERS_NO_CONTEXT(return_count, ...) \
608 DEFINE_RESULT_AND_PARAMETERS(return_count, ##__VA_ARGS__) \
609 static constexpr bool kNoContext = true;
610
611 #define DEFINE_RESULT_AND_PARAMETER_TYPES(...) \
612 static void InitializeTypes(CallInterfaceDescriptorData* data) { \
613 MachineType machine_types[] = {__VA_ARGS__}; \
614 static_assert( \
615 kReturnCount + kParameterCount == arraysize(machine_types), \
616 "Parameter names definition is not consistent with parameter types"); \
617 data->InitializeTypes(machine_types, arraysize(machine_types)); \
618 }
619
620 #define DEFINE_PARAMETER_TYPES(...) \
621 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged() /* result */, \
622 ##__VA_ARGS__)
623
624 // When the extra arguments described here are located in the stack, they are
625 // just above the return address in the frame (first arguments).
626 #define DEFINE_JS_PARAMETERS(...) \
627 static constexpr bool kAllowVarArgs = true; \
628 static constexpr int kReturnCount = 1; \
629 static constexpr StackArgumentOrder kStackArgumentOrder = \
630 StackArgumentOrder::kJS; \
631 enum ParameterIndices { \
632 kTarget, \
633 kNewTarget, \
634 kActualArgumentsCount, \
635 ##__VA_ARGS__, \
636 kParameterCount, \
637 kContext = kParameterCount /* implicit parameter */ \
638 };
639
640 #define DEFINE_JS_PARAMETERS_NO_CONTEXT(...) \
641 static constexpr bool kAllowVarArgs = true; \
642 static constexpr bool kNoContext = true; \
643 static constexpr int kReturnCount = 1; \
644 static constexpr StackArgumentOrder kStackArgumentOrder = \
645 StackArgumentOrder::kJS; \
646 enum ParameterIndices { \
647 kTarget, \
648 kNewTarget, \
649 kActualArgumentsCount, \
650 ##__VA_ARGS__, \
651 kParameterCount, \
652 };
653
654 #define DEFINE_JS_PARAMETER_TYPES(...) \
655 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), /* kTarget */ \
656 MachineType::AnyTagged(), /* kNewTarget */ \
657 MachineType::Int32(), /* kActualArgumentsCount */ \
658 ##__VA_ARGS__)
659
660 #define DECLARE_DESCRIPTOR(name) \
661 DECLARE_DESCRIPTOR_WITH_BASE(name, StaticCallInterfaceDescriptor) \
662 protected: \
663 explicit name(CallDescriptors::Key key) \
664 : StaticCallInterfaceDescriptor(key) {} \
665 \
666 public:
667
668 class V8_EXPORT_PRIVATE VoidDescriptor
669 : public StaticCallInterfaceDescriptor<VoidDescriptor> {
670 public:
671 DEFINE_PARAMETERS()
672 DEFINE_PARAMETER_TYPES()
673 DECLARE_DESCRIPTOR(VoidDescriptor)
674
675 static constexpr auto registers();
676 };
677
678 // Dummy descriptor used to mark builtins that don't yet have their proper
679 // descriptor associated.
680 using DummyDescriptor = VoidDescriptor;
681
682 // Dummy descriptor that marks builtins with C calling convention.
683 using CCallDescriptor = VoidDescriptor;
684
685 // Marks deoptimization entry builtins. Precise calling conventions currently
686 // differ based on the platform.
687 // TODO(jgruber): Once this is unified, we could create a better description
688 // here.
689 using DeoptimizationEntryDescriptor = VoidDescriptor;
690
691 class AllocateDescriptor
692 : public StaticCallInterfaceDescriptor<AllocateDescriptor> {
693 public:
694 DEFINE_PARAMETERS_NO_CONTEXT(kRequestedSize)
695 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::TaggedPointer(), // result 1
696 MachineType::IntPtr()) // kRequestedSize
697 DECLARE_DESCRIPTOR(AllocateDescriptor)
698
699 static constexpr auto registers();
700 };
701
702 // This descriptor defines the JavaScript calling convention that can be used
703 // by stubs: target, new.target, argc and context are passed in registers while
704 // receiver and the rest of the JS arguments are passed on the stack.
705 class JSTrampolineDescriptor
706 : public StaticJSCallInterfaceDescriptor<JSTrampolineDescriptor> {
707 public:
708 DEFINE_JS_PARAMETERS()
709 DEFINE_JS_PARAMETER_TYPES()
710
711 DECLARE_JS_COMPATIBLE_DESCRIPTOR(JSTrampolineDescriptor)
712 };
713
714 class ContextOnlyDescriptor
715 : public StaticCallInterfaceDescriptor<ContextOnlyDescriptor> {
716 public:
717 DEFINE_PARAMETERS()
718 DEFINE_PARAMETER_TYPES()
719 DECLARE_DESCRIPTOR(ContextOnlyDescriptor)
720
721 static constexpr auto registers();
722 };
723
724 class NoContextDescriptor
725 : public StaticCallInterfaceDescriptor<NoContextDescriptor> {
726 public:
727 DEFINE_PARAMETERS_NO_CONTEXT()
728 DEFINE_PARAMETER_TYPES()
729 DECLARE_DESCRIPTOR(NoContextDescriptor)
730
731 static constexpr auto registers();
732 };
733
734 // LoadDescriptor is used by all stubs that implement Load ICs.
735 class LoadDescriptor : public StaticCallInterfaceDescriptor<LoadDescriptor> {
736 public:
737 DEFINE_PARAMETERS(kReceiver, kName, kSlot)
738 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
739 MachineType::AnyTagged(), // kName
740 MachineType::TaggedSigned()) // kSlot
741 DECLARE_DESCRIPTOR(LoadDescriptor)
742
743 static constexpr inline Register ReceiverRegister();
744 static constexpr inline Register NameRegister();
745 static constexpr inline Register SlotRegister();
746
747 static constexpr auto registers();
748 };
749
750 // LoadBaselineDescriptor is a load descriptor that does not take a context as
751 // input.
752 class LoadBaselineDescriptor
753 : public StaticCallInterfaceDescriptor<LoadBaselineDescriptor> {
754 public:
755 DEFINE_PARAMETERS_NO_CONTEXT(kReceiver, kName, kSlot)
756 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
757 MachineType::AnyTagged(), // kName
758 MachineType::TaggedSigned()) // kSlot
759 DECLARE_DESCRIPTOR(LoadBaselineDescriptor)
760
761 static constexpr auto registers();
762 };
763
764 class LoadGlobalNoFeedbackDescriptor
765 : public StaticCallInterfaceDescriptor<LoadGlobalNoFeedbackDescriptor> {
766 public:
767 DEFINE_PARAMETERS(kName, kICKind)
768 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
769 MachineType::TaggedSigned()) // kICKind
770 DECLARE_DESCRIPTOR(LoadGlobalNoFeedbackDescriptor)
771
772 static constexpr inline Register ICKindRegister();
773
774 static constexpr auto registers();
775 };
776
777 class LoadNoFeedbackDescriptor
778 : public StaticCallInterfaceDescriptor<LoadNoFeedbackDescriptor> {
779 public:
780 DEFINE_PARAMETERS(kReceiver, kName, kICKind)
781 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
782 MachineType::AnyTagged(), // kName
783 MachineType::TaggedSigned()) // kICKind
784 DECLARE_DESCRIPTOR(LoadNoFeedbackDescriptor)
785
786 static constexpr inline Register ICKindRegister();
787
788 static constexpr auto registers();
789 };
790
791 class LoadGlobalDescriptor
792 : public StaticCallInterfaceDescriptor<LoadGlobalDescriptor> {
793 public:
794 DEFINE_PARAMETERS(kName, kSlot)
795 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
796 MachineType::TaggedSigned()) // kSlot
797 DECLARE_DESCRIPTOR(LoadGlobalDescriptor)
798
799 static constexpr auto registers();
800 };
801
802 class LoadGlobalBaselineDescriptor
803 : public StaticCallInterfaceDescriptor<LoadGlobalBaselineDescriptor> {
804 public:
805 DEFINE_PARAMETERS_NO_CONTEXT(kName, kSlot)
806 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
807 MachineType::TaggedSigned()) // kSlot
808 DECLARE_DESCRIPTOR(LoadGlobalBaselineDescriptor)
809
810 static constexpr auto registers();
811 };
812
813 class LookupBaselineDescriptor
814 : public StaticCallInterfaceDescriptor<LookupBaselineDescriptor> {
815 public:
816 DEFINE_PARAMETERS_NO_CONTEXT(kName, kDepth, kSlot)
817 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
818 MachineType::AnyTagged(), // kDepth
819 MachineType::AnyTagged()) // kSlot
820 DECLARE_DESCRIPTOR(LookupBaselineDescriptor)
821 };
822
823 class StoreDescriptor : public StaticCallInterfaceDescriptor<StoreDescriptor> {
824 public:
825 DEFINE_PARAMETERS(kReceiver, kName, kValue, kSlot)
826 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
827 MachineType::AnyTagged(), // kName
828 MachineType::AnyTagged(), // kValue
829 MachineType::TaggedSigned()) // kSlot
830 DECLARE_DESCRIPTOR(StoreDescriptor)
831
832 static constexpr inline Register ReceiverRegister();
833 static constexpr inline Register NameRegister();
834 static constexpr inline Register ValueRegister();
835 static constexpr inline Register SlotRegister();
836
837 static constexpr auto registers();
838 };
839
840 class StoreBaselineDescriptor
841 : public StaticCallInterfaceDescriptor<StoreBaselineDescriptor> {
842 public:
843 DEFINE_PARAMETERS_NO_CONTEXT(kReceiver, kName, kValue, kSlot)
844 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
845 MachineType::AnyTagged(), // kName
846 MachineType::AnyTagged(), // kValue
847 MachineType::TaggedSigned()) // kSlot
848 DECLARE_DESCRIPTOR(StoreBaselineDescriptor)
849
850 static constexpr auto registers();
851 };
852
853 class StoreTransitionDescriptor
854 : public StaticCallInterfaceDescriptor<StoreTransitionDescriptor> {
855 public:
856 DEFINE_PARAMETERS(kReceiver, kName, kMap, kValue, kSlot, kVector)
857 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
858 MachineType::AnyTagged(), // kName
859 MachineType::AnyTagged(), // kMap
860 MachineType::AnyTagged(), // kValue
861 MachineType::TaggedSigned(), // kSlot
862 MachineType::AnyTagged()) // kVector
863 DECLARE_DESCRIPTOR(StoreTransitionDescriptor)
864
865 static constexpr inline Register MapRegister();
866
867 static constexpr auto registers();
868 };
869
870 class StoreWithVectorDescriptor
871 : public StaticCallInterfaceDescriptor<StoreWithVectorDescriptor> {
872 public:
873 DEFINE_PARAMETERS(kReceiver, kName, kValue, kSlot, kVector)
874 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
875 MachineType::AnyTagged(), // kName
876 MachineType::AnyTagged(), // kValue
877 MachineType::TaggedSigned(), // kSlot
878 MachineType::AnyTagged()) // kVector
879 DECLARE_DESCRIPTOR(StoreWithVectorDescriptor)
880
881 static constexpr inline Register VectorRegister();
882
883 static constexpr auto registers();
884 };
885
886 class StoreGlobalDescriptor
887 : public StaticCallInterfaceDescriptor<StoreGlobalDescriptor> {
888 public:
889 DEFINE_PARAMETERS(kName, kValue, kSlot)
890 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
891 MachineType::AnyTagged(), // kValue
892 MachineType::TaggedSigned()) // kSlot
893 DECLARE_DESCRIPTOR(StoreGlobalDescriptor)
894
895 static constexpr auto registers();
896 };
897
898 class StoreGlobalBaselineDescriptor
899 : public StaticCallInterfaceDescriptor<StoreGlobalBaselineDescriptor> {
900 public:
901 DEFINE_PARAMETERS_NO_CONTEXT(kName, kValue, kSlot)
902 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
903 MachineType::AnyTagged(), // kValue
904 MachineType::TaggedSigned()) // kSlot
905 DECLARE_DESCRIPTOR(StoreGlobalBaselineDescriptor)
906
907 static constexpr auto registers();
908 };
909
910 class StoreGlobalWithVectorDescriptor
911 : public StaticCallInterfaceDescriptor<StoreGlobalWithVectorDescriptor> {
912 public:
913 DEFINE_PARAMETERS(kName, kValue, kSlot, kVector)
914 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
915 MachineType::AnyTagged(), // kValue
916 MachineType::TaggedSigned(), // kSlot
917 MachineType::AnyTagged()) // kVector
918 DECLARE_DESCRIPTOR(StoreGlobalWithVectorDescriptor)
919
920 static constexpr auto registers();
921 };
922
923 class LoadWithVectorDescriptor
924 : public StaticCallInterfaceDescriptor<LoadWithVectorDescriptor> {
925 public:
926 // TODO(v8:9497): Revert the Machine type for kSlot to the
927 // TaggedSigned once Torque can emit better call descriptors
928 DEFINE_PARAMETERS(kReceiver, kName, kSlot, kVector)
929 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
930 MachineType::AnyTagged(), // kName
931 MachineType::AnyTagged(), // kSlot
932 MachineType::AnyTagged()) // kVector
933 DECLARE_DESCRIPTOR(LoadWithVectorDescriptor)
934
935 static constexpr inline Register VectorRegister();
936
937 static constexpr auto registers();
938 };
939
940 class KeyedLoadBaselineDescriptor
941 : public StaticCallInterfaceDescriptor<KeyedLoadBaselineDescriptor> {
942 public:
943 DEFINE_PARAMETERS_NO_CONTEXT(kReceiver, kName, kSlot)
944 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
945 MachineType::AnyTagged(), // kName
946 MachineType::TaggedSigned()) // kSlot
947 DECLARE_DESCRIPTOR(KeyedLoadBaselineDescriptor)
948
949 static constexpr inline Register ReceiverRegister();
950 static constexpr inline Register NameRegister();
951 static constexpr inline Register SlotRegister();
952
953 static constexpr auto registers();
954 };
955
956 class KeyedLoadDescriptor
957 : public StaticCallInterfaceDescriptor<KeyedLoadDescriptor> {
958 public:
959 DEFINE_PARAMETERS(kReceiver, kName, kSlot)
960 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
961 MachineType::AnyTagged(), // kName
962 MachineType::TaggedSigned()) // kSlot
963 DECLARE_DESCRIPTOR(KeyedLoadDescriptor)
964
965 static constexpr auto registers();
966 };
967
968 class KeyedLoadWithVectorDescriptor
969 : public StaticCallInterfaceDescriptor<KeyedLoadWithVectorDescriptor> {
970 public:
971 DEFINE_PARAMETERS(kReceiver, kName, kSlot, kVector)
972 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
973 MachineType::AnyTagged(), // kName
974 MachineType::TaggedSigned(), // kSlot
975 MachineType::AnyTagged()) // kVector
976 DECLARE_DESCRIPTOR(KeyedLoadWithVectorDescriptor)
977
978 static constexpr inline Register VectorRegister();
979
980 static constexpr auto registers();
981 };
982
983 class KeyedHasICBaselineDescriptor
984 : public StaticCallInterfaceDescriptor<KeyedHasICBaselineDescriptor> {
985 public:
986 DEFINE_PARAMETERS_NO_CONTEXT(kReceiver, kName, kSlot)
987 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
988 MachineType::AnyTagged(), // kName
989 MachineType::TaggedSigned()) // kSlot
990 DECLARE_DESCRIPTOR(KeyedHasICBaselineDescriptor)
991
992 static constexpr inline Register ReceiverRegister();
993 static constexpr inline Register NameRegister();
994 static constexpr inline Register SlotRegister();
995
996 static constexpr auto registers();
997 };
998
999 class KeyedHasICWithVectorDescriptor
1000 : public StaticCallInterfaceDescriptor<KeyedHasICWithVectorDescriptor> {
1001 public:
1002 DEFINE_PARAMETERS(kReceiver, kName, kSlot, kVector)
1003 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
1004 MachineType::AnyTagged(), // kName
1005 MachineType::TaggedSigned(), // kSlot
1006 MachineType::AnyTagged()) // kVector
1007 DECLARE_DESCRIPTOR(KeyedHasICWithVectorDescriptor)
1008
1009 static constexpr inline Register VectorRegister();
1010
1011 static constexpr auto registers();
1012 };
1013
1014 // Like LoadWithVectorDescriptor, except we pass the receiver (the object which
1015 // should be used as the receiver for accessor function calls) and the lookup
1016 // start object separately.
1017 class LoadWithReceiverAndVectorDescriptor
1018 : public StaticCallInterfaceDescriptor<
1019 LoadWithReceiverAndVectorDescriptor> {
1020 public:
1021 // TODO(v8:9497): Revert the Machine type for kSlot to the
1022 // TaggedSigned once Torque can emit better call descriptors
1023 DEFINE_PARAMETERS(kReceiver, kLookupStartObject, kName, kSlot, kVector)
1024 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
1025 MachineType::AnyTagged(), // kLookupStartObject
1026 MachineType::AnyTagged(), // kName
1027 MachineType::AnyTagged(), // kSlot
1028 MachineType::AnyTagged()) // kVector
1029 DECLARE_DESCRIPTOR(LoadWithReceiverAndVectorDescriptor)
1030
1031 static constexpr inline Register LookupStartObjectRegister();
1032
1033 static constexpr auto registers();
1034 };
1035
1036 class LoadWithReceiverBaselineDescriptor
1037 : public StaticCallInterfaceDescriptor<LoadWithReceiverBaselineDescriptor> {
1038 public:
1039 // TODO(v8:9497): Revert the Machine type for kSlot to the
1040 // TaggedSigned once Torque can emit better call descriptors
1041 DEFINE_PARAMETERS_NO_CONTEXT(kReceiver, kLookupStartObject, kName, kSlot)
1042 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
1043 MachineType::AnyTagged(), // kLookupStartObject
1044 MachineType::AnyTagged(), // kName
1045 MachineType::AnyTagged()) // kSlot
1046 DECLARE_DESCRIPTOR(LoadWithReceiverBaselineDescriptor)
1047
1048 static constexpr auto registers();
1049 };
1050
1051 class LoadGlobalWithVectorDescriptor
1052 : public StaticCallInterfaceDescriptor<LoadGlobalWithVectorDescriptor> {
1053 public:
1054 DEFINE_PARAMETERS(kName, kSlot, kVector)
1055 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
1056 MachineType::TaggedSigned(), // kSlot
1057 MachineType::AnyTagged()) // kVector
1058 DECLARE_DESCRIPTOR(LoadGlobalWithVectorDescriptor)
1059
1060 static constexpr inline Register VectorRegister();
1061
1062 static constexpr auto registers();
1063 };
1064
1065 class FastNewObjectDescriptor
1066 : public StaticCallInterfaceDescriptor<FastNewObjectDescriptor> {
1067 public:
1068 DEFINE_PARAMETERS(kTarget, kNewTarget)
1069 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
1070 MachineType::AnyTagged()) // kNewTarget
1071 DECLARE_DESCRIPTOR(FastNewObjectDescriptor)
1072
1073 static constexpr inline Register TargetRegister();
1074 static constexpr inline Register NewTargetRegister();
1075
1076 static constexpr auto registers();
1077 };
1078
1079 class WriteBarrierDescriptor final
1080 : public StaticCallInterfaceDescriptor<WriteBarrierDescriptor> {
1081 public:
1082 DEFINE_PARAMETERS_NO_CONTEXT(kObject, kSlotAddress)
1083 DEFINE_PARAMETER_TYPES(MachineType::TaggedPointer(), // kObject
1084 MachineType::Pointer()) // kSlotAddress
1085
1086 DECLARE_DESCRIPTOR(WriteBarrierDescriptor)
1087 static constexpr auto registers();
1088 static constexpr bool kRestrictAllocatableRegisters = true;
1089 static constexpr bool kCalleeSaveRegisters = true;
1090 static constexpr inline Register ObjectRegister();
1091 static constexpr inline Register SlotAddressRegister();
1092 // A temporary register used in helpers.
1093 static constexpr inline Register ValueRegister();
1094 static constexpr inline RegList ComputeSavedRegisters(
1095 Register object, Register slot_address = no_reg);
1096 #if DEBUG
1097 static void Verify(CallInterfaceDescriptorData* data);
1098 #endif
1099 };
1100
1101 #ifdef V8_IS_TSAN
1102 class TSANStoreDescriptor final
1103 : public StaticCallInterfaceDescriptor<TSANStoreDescriptor> {
1104 public:
1105 DEFINE_PARAMETERS_NO_CONTEXT(kAddress, kValue)
1106 DEFINE_PARAMETER_TYPES(MachineType::Pointer(), // kAddress
1107 MachineType::AnyTagged()) // kValue
1108
1109 DECLARE_DESCRIPTOR(TSANStoreDescriptor)
1110
1111 static constexpr auto registers();
1112 static constexpr bool kRestrictAllocatableRegisters = true;
1113 };
1114
1115 class TSANLoadDescriptor final
1116 : public StaticCallInterfaceDescriptor<TSANLoadDescriptor> {
1117 public:
1118 DEFINE_PARAMETERS_NO_CONTEXT(kAddress)
1119 DEFINE_PARAMETER_TYPES(MachineType::Pointer()) // kAddress
1120
1121 DECLARE_DESCRIPTOR(TSANLoadDescriptor)
1122
1123 static constexpr auto registers();
1124 static constexpr bool kRestrictAllocatableRegisters = true;
1125 };
1126
1127 #endif // V8_IS_TSAN
1128
1129 class TypeConversionDescriptor final
1130 : public StaticCallInterfaceDescriptor<TypeConversionDescriptor> {
1131 public:
1132 DEFINE_PARAMETERS(kArgument)
1133 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged())
1134 DECLARE_DESCRIPTOR(TypeConversionDescriptor)
1135
1136 static constexpr inline Register ArgumentRegister();
1137
1138 static constexpr auto registers();
1139 };
1140
1141 class TypeConversionNoContextDescriptor final
1142 : public StaticCallInterfaceDescriptor<TypeConversionNoContextDescriptor> {
1143 public:
1144 DEFINE_PARAMETERS_NO_CONTEXT(kArgument)
1145 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged())
1146 DECLARE_DESCRIPTOR(TypeConversionNoContextDescriptor)
1147
1148 static constexpr auto registers();
1149 };
1150
1151 class TypeConversion_BaselineDescriptor final
1152 : public StaticCallInterfaceDescriptor<TypeConversion_BaselineDescriptor> {
1153 public:
1154 DEFINE_PARAMETERS_NO_CONTEXT(kArgument, kSlot)
1155 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), MachineType::UintPtr())
1156 DECLARE_DESCRIPTOR(TypeConversion_BaselineDescriptor)
1157 };
1158
1159 class SingleParameterOnStackDescriptor final
1160 : public StaticCallInterfaceDescriptor<SingleParameterOnStackDescriptor> {
1161 public:
1162 DEFINE_PARAMETERS(kArgument)
1163 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged())
1164 DECLARE_DESCRIPTOR(SingleParameterOnStackDescriptor)
1165
1166 static constexpr auto registers();
1167 };
1168
1169 class AsyncFunctionStackParameterDescriptor final
1170 : public StaticCallInterfaceDescriptor<
1171 AsyncFunctionStackParameterDescriptor> {
1172 public:
1173 DEFINE_PARAMETERS(kPromise, kResult)
1174 DEFINE_PARAMETER_TYPES(MachineType::TaggedPointer(), MachineType::AnyTagged())
1175 DECLARE_DESCRIPTOR(AsyncFunctionStackParameterDescriptor)
1176
1177 static constexpr auto registers();
1178 };
1179
1180 class GetIteratorStackParameterDescriptor final
1181 : public StaticCallInterfaceDescriptor<
1182 GetIteratorStackParameterDescriptor> {
1183 public:
1184 DEFINE_PARAMETERS(kReceiver, kCallSlot, kFeedback, kResult)
1185 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), MachineType::AnyTagged(),
1186 MachineType::AnyTagged(), MachineType::AnyTagged())
1187 DECLARE_DESCRIPTOR(GetIteratorStackParameterDescriptor)
1188
1189 static constexpr auto registers();
1190 };
1191
1192 class GetPropertyDescriptor final
1193 : public StaticCallInterfaceDescriptor<GetPropertyDescriptor> {
1194 public:
1195 DEFINE_PARAMETERS(kObject, kKey)
1196 DECLARE_DEFAULT_DESCRIPTOR(GetPropertyDescriptor)
1197 };
1198
1199 class TypeofDescriptor
1200 : public StaticCallInterfaceDescriptor<TypeofDescriptor> {
1201 public:
1202 DEFINE_PARAMETERS(kObject)
1203 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged())
1204 DECLARE_DESCRIPTOR(TypeofDescriptor)
1205
1206 static constexpr inline auto registers();
1207 };
1208
1209 class CallTrampolineDescriptor
1210 : public StaticCallInterfaceDescriptor<CallTrampolineDescriptor> {
1211 public:
1212 DEFINE_PARAMETERS_VARARGS(kFunction, kActualArgumentsCount)
1213 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction
1214 MachineType::Int32()) // kActualArgumentsCount
1215 DECLARE_DESCRIPTOR(CallTrampolineDescriptor)
1216
1217 static constexpr inline auto registers();
1218 };
1219
1220 class CopyDataPropertiesWithExcludedPropertiesDescriptor
1221 : public StaticCallInterfaceDescriptor<
1222 CopyDataPropertiesWithExcludedPropertiesDescriptor> {
1223 public:
1224 DEFINE_PARAMETERS_VARARGS(kSource, kExcludedPropertyCount)
1225 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kSource
1226 MachineType::AnyTagged()) // kExcludedPropertyCount
1227 DECLARE_DESCRIPTOR(CopyDataPropertiesWithExcludedPropertiesDescriptor)
1228
1229 static constexpr inline auto registers();
1230 };
1231
1232 class CopyDataPropertiesWithExcludedPropertiesOnStackDescriptor
1233 : public StaticCallInterfaceDescriptor<
1234 CopyDataPropertiesWithExcludedPropertiesOnStackDescriptor> {
1235 public:
1236 DEFINE_PARAMETERS(kSource, kExcludedPropertyCount, kExcludedPropertyBase)
1237 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kSource
1238 MachineType::IntPtr(),
1239 MachineType::IntPtr()) // kExcludedPropertyCount
1240 DECLARE_DESCRIPTOR(CopyDataPropertiesWithExcludedPropertiesOnStackDescriptor)
1241
1242 static constexpr inline auto registers();
1243 };
1244
1245 class CallVarargsDescriptor
1246 : public StaticCallInterfaceDescriptor<CallVarargsDescriptor> {
1247 public:
1248 DEFINE_PARAMETERS_VARARGS(kTarget, kActualArgumentsCount, kArgumentsLength,
1249 kArgumentsList)
1250 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
1251 MachineType::Int32(), // kActualArgumentsCount
1252 MachineType::Int32(), // kArgumentsLength
1253 MachineType::AnyTagged()) // kArgumentsList
1254 DECLARE_DESCRIPTOR(CallVarargsDescriptor)
1255
1256 static constexpr inline auto registers();
1257 };
1258
1259 class CallForwardVarargsDescriptor
1260 : public StaticCallInterfaceDescriptor<CallForwardVarargsDescriptor> {
1261 public:
1262 DEFINE_PARAMETERS_VARARGS(kTarget, kActualArgumentsCount, kStartIndex)
1263 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
1264 MachineType::Int32(), // kActualArgumentsCount
1265 MachineType::Int32()) // kStartIndex
1266 DECLARE_DESCRIPTOR(CallForwardVarargsDescriptor)
1267
1268 static constexpr inline auto registers();
1269 };
1270
1271 class CallFunctionTemplateDescriptor
1272 : public StaticCallInterfaceDescriptor<CallFunctionTemplateDescriptor> {
1273 public:
1274 DEFINE_PARAMETERS_VARARGS(kFunctionTemplateInfo, kArgumentsCount)
1275 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunctionTemplateInfo
1276 MachineType::IntPtr()) // kArgumentsCount
1277 DECLARE_DESCRIPTOR(CallFunctionTemplateDescriptor)
1278
1279 static constexpr inline auto registers();
1280 };
1281
1282 class CallWithSpreadDescriptor
1283 : public StaticCallInterfaceDescriptor<CallWithSpreadDescriptor> {
1284 public:
1285 DEFINE_PARAMETERS_VARARGS(kTarget, kArgumentsCount, kSpread)
1286 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
1287 MachineType::Int32(), // kArgumentsCount
1288 MachineType::AnyTagged()) // kSpread
1289 DECLARE_DESCRIPTOR(CallWithSpreadDescriptor)
1290
1291 static constexpr inline auto registers();
1292 };
1293
1294 class CallWithSpread_BaselineDescriptor
1295 : public StaticCallInterfaceDescriptor<CallWithSpread_BaselineDescriptor> {
1296 public:
1297 DEFINE_PARAMETERS_NO_CONTEXT_VARARGS(kTarget, kArgumentsCount, kSpread, kSlot)
1298 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
1299 MachineType::Int32(), // kArgumentsCount
1300 MachineType::AnyTagged(), // kSpread
1301 MachineType::UintPtr()) // kSlot
1302 DECLARE_DESCRIPTOR(CallWithSpread_BaselineDescriptor)
1303 };
1304
1305 class CallWithSpread_WithFeedbackDescriptor
1306 : public StaticCallInterfaceDescriptor<
1307 CallWithSpread_WithFeedbackDescriptor> {
1308 public:
1309 DEFINE_PARAMETERS_VARARGS(kTarget, kArgumentsCount, kSpread, kSlot,
1310 kFeedbackVector, kReceiver)
1311 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
1312 MachineType::Int32(), // kArgumentsCount
1313 MachineType::AnyTagged(), // kSpread
1314 MachineType::UintPtr(), // kSlot
1315 MachineType::AnyTagged(), // kFeedbackVector
1316 MachineType::AnyTagged()) // kReceiver
1317 DECLARE_DESCRIPTOR(CallWithSpread_WithFeedbackDescriptor)
1318 };
1319
1320 class CallWithArrayLikeDescriptor
1321 : public StaticCallInterfaceDescriptor<CallWithArrayLikeDescriptor> {
1322 public:
1323 DEFINE_PARAMETERS(kTarget, kArgumentsList)
1324 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
1325 MachineType::AnyTagged()) // kArgumentsList
1326 DECLARE_DESCRIPTOR(CallWithArrayLikeDescriptor)
1327
1328 static constexpr inline auto registers();
1329 };
1330
1331 class CallWithArrayLike_WithFeedbackDescriptor
1332 : public StaticCallInterfaceDescriptor<
1333 CallWithArrayLike_WithFeedbackDescriptor> {
1334 public:
1335 DEFINE_PARAMETERS(kTarget, kArgumentsList, kSlot, kFeedbackVector, kReceiver)
1336 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
1337 MachineType::AnyTagged(), // kArgumentsList
1338 MachineType::UintPtr(), // kSlot
1339 MachineType::AnyTagged(), // kFeedbackVector
1340 MachineType::AnyTagged()) // kReceiver
1341 DECLARE_DESCRIPTOR(CallWithArrayLike_WithFeedbackDescriptor)
1342 };
1343
1344 class ConstructVarargsDescriptor
1345 : public StaticCallInterfaceDescriptor<ConstructVarargsDescriptor> {
1346 public:
1347 DEFINE_JS_PARAMETERS(kArgumentsLength, kArgumentsList)
1348 DEFINE_JS_PARAMETER_TYPES(MachineType::Int32(), // kArgumentsLength
1349 MachineType::AnyTagged()) // kArgumentsList
1350
1351 DECLARE_DESCRIPTOR(ConstructVarargsDescriptor)
1352
1353 static constexpr inline auto registers();
1354 };
1355
1356 class ConstructForwardVarargsDescriptor
1357 : public StaticCallInterfaceDescriptor<ConstructForwardVarargsDescriptor> {
1358 public:
1359 DEFINE_JS_PARAMETERS(kStartIndex)
1360 DEFINE_JS_PARAMETER_TYPES(MachineType::Int32())
1361 DECLARE_DESCRIPTOR(ConstructForwardVarargsDescriptor)
1362
1363 static constexpr inline auto registers();
1364 };
1365
1366 class ConstructWithSpreadDescriptor
1367 : public StaticCallInterfaceDescriptor<ConstructWithSpreadDescriptor> {
1368 public:
1369 DEFINE_JS_PARAMETERS(kSpread)
1370 DEFINE_JS_PARAMETER_TYPES(MachineType::AnyTagged())
1371 DECLARE_DESCRIPTOR(ConstructWithSpreadDescriptor)
1372
1373 static constexpr inline auto registers();
1374 };
1375
1376 class ConstructWithSpread_BaselineDescriptor
1377 : public StaticCallInterfaceDescriptor<
1378 ConstructWithSpread_BaselineDescriptor> {
1379 public:
1380 // Note: kSlot comes before kSpread since as an untagged value it must be
1381 // passed in a register.
1382 DEFINE_JS_PARAMETERS_NO_CONTEXT(kSlot, kSpread)
1383 DEFINE_JS_PARAMETER_TYPES(MachineType::UintPtr(), // kSlot
1384 MachineType::AnyTagged()) // kSpread
1385 DECLARE_DESCRIPTOR(ConstructWithSpread_BaselineDescriptor)
1386 };
1387
1388 class ConstructWithSpread_WithFeedbackDescriptor
1389 : public StaticCallInterfaceDescriptor<
1390 ConstructWithSpread_WithFeedbackDescriptor> {
1391 public:
1392 // Note: kSlot comes before kSpread since as an untagged value it must be
1393 // passed in a register.
1394 DEFINE_JS_PARAMETERS(kSlot, kSpread, kFeedbackVector)
1395 DEFINE_JS_PARAMETER_TYPES(MachineType::UintPtr(), // kSlot
1396 MachineType::AnyTagged(), // kSpread
1397 MachineType::AnyTagged()) // kFeedbackVector
1398 DECLARE_DESCRIPTOR(ConstructWithSpread_WithFeedbackDescriptor)
1399 };
1400
1401 class ConstructWithArrayLikeDescriptor
1402 : public StaticCallInterfaceDescriptor<ConstructWithArrayLikeDescriptor> {
1403 public:
1404 DEFINE_PARAMETERS(kTarget, kNewTarget, kArgumentsList)
1405 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
1406 MachineType::AnyTagged(), // kNewTarget
1407 MachineType::AnyTagged()) // kArgumentsList
1408 DECLARE_DESCRIPTOR(ConstructWithArrayLikeDescriptor)
1409
1410 static constexpr inline auto registers();
1411 };
1412
1413 class ConstructWithArrayLike_WithFeedbackDescriptor
1414 : public StaticCallInterfaceDescriptor<
1415 ConstructWithArrayLike_WithFeedbackDescriptor> {
1416 public:
1417 DEFINE_PARAMETERS(kTarget, kNewTarget, kArgumentsList, kSlot, kFeedbackVector)
1418 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
1419 MachineType::AnyTagged(), // kNewTarget
1420 MachineType::AnyTagged(), // kArgumentsList
1421 MachineType::UintPtr(), // kSlot
1422 MachineType::AnyTagged()) // kFeedbackVector
1423 DECLARE_DESCRIPTOR(ConstructWithArrayLike_WithFeedbackDescriptor)
1424 };
1425
1426 // TODO(ishell): consider merging this with ArrayConstructorDescriptor
1427 class ConstructStubDescriptor
1428 : public StaticCallInterfaceDescriptor<ConstructStubDescriptor> {
1429 public:
1430 // TODO(jgruber): Remove the unused allocation site parameter.
1431 DEFINE_JS_PARAMETERS(kAllocationSite)
1432 DEFINE_JS_PARAMETER_TYPES(MachineType::AnyTagged())
1433
1434 // TODO(ishell): Use DECLARE_JS_COMPATIBLE_DESCRIPTOR if registers match
1435 DECLARE_DESCRIPTOR(ConstructStubDescriptor)
1436
1437 static constexpr inline auto registers();
1438 };
1439
1440 class AbortDescriptor : public StaticCallInterfaceDescriptor<AbortDescriptor> {
1441 public:
1442 DEFINE_PARAMETERS_NO_CONTEXT(kMessageOrMessageId)
1443 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged())
1444 DECLARE_DESCRIPTOR(AbortDescriptor)
1445
1446 static constexpr inline auto registers();
1447 };
1448
1449 class ArrayConstructorDescriptor
1450 : public StaticJSCallInterfaceDescriptor<ArrayConstructorDescriptor> {
1451 public:
1452 DEFINE_JS_PARAMETERS(kAllocationSite)
1453 DEFINE_JS_PARAMETER_TYPES(MachineType::AnyTagged())
1454
1455 DECLARE_JS_COMPATIBLE_DESCRIPTOR(ArrayConstructorDescriptor)
1456 };
1457
1458 class ArrayNArgumentsConstructorDescriptor
1459 : public StaticCallInterfaceDescriptor<
1460 ArrayNArgumentsConstructorDescriptor> {
1461 public:
1462 // This descriptor declares only register arguments while respective number
1463 // of JS arguments stay on the expression stack.
1464 // The ArrayNArgumentsConstructor builtin does not access stack arguments
1465 // directly it just forwards them to the runtime function.
1466 DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount)
1467 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction,
1468 MachineType::AnyTagged(), // kAllocationSite
1469 MachineType::Int32()) // kActualArgumentsCount
1470 DECLARE_DESCRIPTOR(ArrayNArgumentsConstructorDescriptor)
1471
1472 static constexpr auto registers();
1473 };
1474
1475 class ArrayNoArgumentConstructorDescriptor
1476 : public StaticCallInterfaceDescriptor<
1477 ArrayNoArgumentConstructorDescriptor> {
1478 public:
1479 // This descriptor declares same register arguments as the parent
1480 // ArrayNArgumentsConstructorDescriptor and it declares indices for
1481 // JS arguments passed on the expression stack.
1482 DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount,
1483 kFunctionParameter)
1484 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction
1485 MachineType::AnyTagged(), // kAllocationSite
1486 MachineType::Int32(), // kActualArgumentsCount
1487 MachineType::AnyTagged()) // kFunctionParameter
1488 DECLARE_DESCRIPTOR(ArrayNoArgumentConstructorDescriptor)
1489
1490 static constexpr auto registers();
1491 };
1492
1493 class ArraySingleArgumentConstructorDescriptor
1494 : public StaticCallInterfaceDescriptor<
1495 ArraySingleArgumentConstructorDescriptor> {
1496 public:
1497 // This descriptor declares same register arguments as the parent
1498 // ArrayNArgumentsConstructorDescriptor and it declares indices for
1499 // JS arguments passed on the expression stack.
1500 DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount,
1501 kArraySizeSmiParameter, kReceiverParameter)
1502 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction
1503 MachineType::AnyTagged(), // kAllocationSite
1504 MachineType::Int32(), // kActualArgumentsCount
1505 // JS arguments on the stack
1506 MachineType::AnyTagged(), // kArraySizeSmiParameter
1507 MachineType::AnyTagged()) // kReceiverParameter
1508 DECLARE_DESCRIPTOR(ArraySingleArgumentConstructorDescriptor)
1509
1510 static constexpr auto registers();
1511 };
1512
1513 class CompareDescriptor
1514 : public StaticCallInterfaceDescriptor<CompareDescriptor> {
1515 public:
1516 DEFINE_PARAMETERS(kLeft, kRight)
1517 DECLARE_DESCRIPTOR(CompareDescriptor)
1518
1519 static constexpr inline auto registers();
1520 };
1521
1522 class BinaryOpDescriptor
1523 : public StaticCallInterfaceDescriptor<BinaryOpDescriptor> {
1524 public:
1525 DEFINE_PARAMETERS(kLeft, kRight)
1526 DECLARE_DESCRIPTOR(BinaryOpDescriptor)
1527
1528 static constexpr inline auto registers();
1529 };
1530
1531 class BinaryOp_BaselineDescriptor
1532 : public StaticCallInterfaceDescriptor<BinaryOp_BaselineDescriptor> {
1533 public:
1534 DEFINE_PARAMETERS_NO_CONTEXT(kLeft, kRight, kSlot)
1535 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kLeft
1536 MachineType::AnyTagged(), // kRight
1537 MachineType::UintPtr()) // kSlot
1538 DECLARE_DESCRIPTOR(BinaryOp_BaselineDescriptor)
1539
1540 static constexpr inline auto registers();
1541 };
1542
1543 class BinarySmiOp_BaselineDescriptor
1544 : public StaticCallInterfaceDescriptor<BinarySmiOp_BaselineDescriptor> {
1545 public:
1546 DEFINE_PARAMETERS_NO_CONTEXT(kLeft, kRight, kSlot)
1547 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kLeft
1548 MachineType::TaggedSigned(), // kRight
1549 MachineType::UintPtr()) // kSlot
1550 DECLARE_DESCRIPTOR(BinarySmiOp_BaselineDescriptor)
1551
1552 static constexpr inline auto registers();
1553 };
1554
1555 class StringAtAsStringDescriptor final
1556 : public StaticCallInterfaceDescriptor<StringAtAsStringDescriptor> {
1557 public:
1558 DEFINE_PARAMETERS(kReceiver, kPosition)
1559 // TODO(turbofan): Return untagged value here.
1560 DEFINE_RESULT_AND_PARAMETER_TYPES(
1561 MachineType::TaggedPointer(), // result string
1562 MachineType::AnyTagged(), // kReceiver
1563 MachineType::IntPtr()) // kPosition
1564 DECLARE_DESCRIPTOR(StringAtAsStringDescriptor)
1565 };
1566
1567 class StringSubstringDescriptor final
1568 : public StaticCallInterfaceDescriptor<StringSubstringDescriptor> {
1569 public:
1570 DEFINE_PARAMETERS(kString, kFrom, kTo)
1571 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kString
1572 MachineType::IntPtr(), // kFrom
1573 MachineType::IntPtr()) // kTo
1574
1575 // TODO(turbofan): Allow builtins to return untagged values.
1576 DECLARE_DESCRIPTOR(StringSubstringDescriptor)
1577 };
1578
1579 class CppBuiltinAdaptorDescriptor
1580 : public StaticJSCallInterfaceDescriptor<CppBuiltinAdaptorDescriptor> {
1581 public:
1582 DEFINE_JS_PARAMETERS(kCFunction)
1583 DEFINE_JS_PARAMETER_TYPES(MachineType::Pointer())
1584 DECLARE_JS_COMPATIBLE_DESCRIPTOR(CppBuiltinAdaptorDescriptor)
1585 };
1586
1587 class CEntry1ArgvOnStackDescriptor
1588 : public StaticCallInterfaceDescriptor<CEntry1ArgvOnStackDescriptor> {
1589 public:
1590 DEFINE_PARAMETERS(kArity, // register argument
1591 kCFunction, // register argument
1592 kPadding, // stack argument 1 (just padding)
1593 kArgcSmi, // stack argument 2
1594 kTargetCopy, // stack argument 3
1595 kNewTargetCopy) // stack argument 4
1596 DEFINE_PARAMETER_TYPES(MachineType::Int32(), // kArity
1597 MachineType::Pointer(), // kCFunction
1598 MachineType::AnyTagged(), // kPadding
1599 MachineType::AnyTagged(), // kArgcSmi
1600 MachineType::AnyTagged(), // kTargetCopy
1601 MachineType::AnyTagged()) // kNewTargetCopy
1602 DECLARE_DESCRIPTOR(CEntry1ArgvOnStackDescriptor)
1603
1604 static constexpr auto registers();
1605 };
1606
1607 class ApiCallbackDescriptor
1608 : public StaticCallInterfaceDescriptor<ApiCallbackDescriptor> {
1609 public:
1610 DEFINE_PARAMETERS_VARARGS(kApiFunctionAddress, kActualArgumentsCount,
1611 kCallData, kHolder)
1612 // receiver is implicit stack argument 1
1613 // argv are implicit stack arguments [2, 2 + kArgc[
1614 DEFINE_PARAMETER_TYPES(MachineType::Pointer(), // kApiFunctionAddress
1615 MachineType::IntPtr(), // kActualArgumentsCount
1616 MachineType::AnyTagged(), // kCallData
1617 MachineType::AnyTagged()) // kHolder
1618 DECLARE_DESCRIPTOR(ApiCallbackDescriptor)
1619
1620 static constexpr inline auto registers();
1621 };
1622
1623 class ApiGetterDescriptor
1624 : public StaticCallInterfaceDescriptor<ApiGetterDescriptor> {
1625 public:
1626 DEFINE_PARAMETERS(kReceiver, kHolder, kCallback)
1627 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
1628 MachineType::AnyTagged(), // kHolder
1629 MachineType::AnyTagged()) // kCallback
1630 DECLARE_DESCRIPTOR(ApiGetterDescriptor)
1631
1632 static constexpr inline Register ReceiverRegister();
1633 static constexpr inline Register HolderRegister();
1634 static constexpr inline Register CallbackRegister();
1635
1636 static constexpr auto registers();
1637 };
1638
1639 // TODO(turbofan): We should probably rename this to GrowFastElementsDescriptor.
1640 class GrowArrayElementsDescriptor
1641 : public StaticCallInterfaceDescriptor<GrowArrayElementsDescriptor> {
1642 public:
1643 DEFINE_PARAMETERS(kObject, kKey)
1644 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kObject
1645 MachineType::AnyTagged()) // kKey
1646 DECLARE_DESCRIPTOR(GrowArrayElementsDescriptor)
1647
1648 static constexpr inline Register ObjectRegister();
1649 static constexpr inline Register KeyRegister();
1650
1651 static constexpr auto registers();
1652 };
1653
1654 class BaselineOutOfLinePrologueDescriptor
1655 : public StaticCallInterfaceDescriptor<
1656 BaselineOutOfLinePrologueDescriptor> {
1657 public:
1658 DEFINE_PARAMETERS_NO_CONTEXT(kCalleeContext, kClosure,
1659 kJavaScriptCallArgCount, kStackFrameSize,
1660 kJavaScriptCallNewTarget,
1661 kInterpreterBytecodeArray)
1662 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kCalleeContext
1663 MachineType::AnyTagged(), // kClosure
1664 MachineType::Int32(), // kJavaScriptCallArgCount
1665 MachineType::Int32(), // kStackFrameSize
1666 MachineType::AnyTagged(), // kJavaScriptCallNewTarget
1667 MachineType::AnyTagged()) // kInterpreterBytecodeArray
1668 DECLARE_DESCRIPTOR(BaselineOutOfLinePrologueDescriptor)
1669
1670 static constexpr inline auto registers();
1671
1672 // We pass the context manually, so we have one extra register.
1673 static constexpr int kMaxRegisterParams =
1674 StaticCallInterfaceDescriptor::kMaxRegisterParams + 1;
1675 };
1676
1677 class BaselineLeaveFrameDescriptor
1678 : public StaticCallInterfaceDescriptor<BaselineLeaveFrameDescriptor> {
1679 public:
1680 DEFINE_PARAMETERS_NO_CONTEXT(kParamsSize, kWeight)
1681 DEFINE_PARAMETER_TYPES(MachineType::Int32(), // kParamsSize
1682 MachineType::Int32()) // kWeight
1683 DECLARE_DESCRIPTOR(BaselineLeaveFrameDescriptor)
1684
1685 static constexpr inline Register ParamsSizeRegister();
1686 static constexpr inline Register WeightRegister();
1687
1688 static constexpr inline auto registers();
1689 };
1690
1691 class V8_EXPORT_PRIVATE InterpreterDispatchDescriptor
1692 : public StaticCallInterfaceDescriptor<InterpreterDispatchDescriptor> {
1693 public:
1694 DEFINE_PARAMETERS(kAccumulator, kBytecodeOffset, kBytecodeArray,
1695 kDispatchTable)
1696 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kAccumulator
1697 MachineType::IntPtr(), // kBytecodeOffset
1698 MachineType::AnyTagged(), // kBytecodeArray
1699 MachineType::IntPtr()) // kDispatchTable
1700 DECLARE_DESCRIPTOR(InterpreterDispatchDescriptor)
1701
1702 static constexpr inline auto registers();
1703 };
1704
1705 class InterpreterPushArgsThenCallDescriptor
1706 : public StaticCallInterfaceDescriptor<
1707 InterpreterPushArgsThenCallDescriptor> {
1708 public:
1709 DEFINE_PARAMETERS(kNumberOfArguments, kFirstArgument, kFunction)
1710 DEFINE_PARAMETER_TYPES(MachineType::Int32(), // kNumberOfArguments
1711 MachineType::Pointer(), // kFirstArgument
1712 MachineType::AnyTagged()) // kFunction
1713 DECLARE_DESCRIPTOR(InterpreterPushArgsThenCallDescriptor)
1714
1715 static constexpr inline auto registers();
1716 };
1717
1718 class InterpreterPushArgsThenConstructDescriptor
1719 : public StaticCallInterfaceDescriptor<
1720 InterpreterPushArgsThenConstructDescriptor> {
1721 public:
1722 DEFINE_PARAMETERS(kNumberOfArguments, kFirstArgument, kConstructor,
1723 kNewTarget, kFeedbackElement)
1724 DEFINE_PARAMETER_TYPES(MachineType::Int32(), // kNumberOfArguments
1725 MachineType::Pointer(), // kFirstArgument
1726 MachineType::AnyTagged(), // kConstructor
1727 MachineType::AnyTagged(), // kNewTarget
1728 MachineType::AnyTagged()) // kFeedbackElement
1729 DECLARE_DESCRIPTOR(InterpreterPushArgsThenConstructDescriptor)
1730
1731 static constexpr inline auto registers();
1732 };
1733
1734 class InterpreterCEntry1Descriptor
1735 : public StaticCallInterfaceDescriptor<InterpreterCEntry1Descriptor> {
1736 public:
1737 DEFINE_RESULT_AND_PARAMETERS(1, kNumberOfArguments, kFirstArgument,
1738 kFunctionEntry)
1739 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result 1
1740 MachineType::Int32(), // kNumberOfArguments
1741 MachineType::Pointer(), // kFirstArgument
1742 MachineType::Pointer()) // kFunctionEntry
1743 DECLARE_DESCRIPTOR(InterpreterCEntry1Descriptor)
1744
1745 static constexpr auto registers();
1746 };
1747
1748 class InterpreterCEntry2Descriptor
1749 : public StaticCallInterfaceDescriptor<InterpreterCEntry2Descriptor> {
1750 public:
1751 DEFINE_RESULT_AND_PARAMETERS(2, kNumberOfArguments, kFirstArgument,
1752 kFunctionEntry)
1753 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result 1
1754 MachineType::AnyTagged(), // result 2
1755 MachineType::Int32(), // kNumberOfArguments
1756 MachineType::Pointer(), // kFirstArgument
1757 MachineType::Pointer()) // kFunctionEntry
1758 DECLARE_DESCRIPTOR(InterpreterCEntry2Descriptor)
1759
1760 static constexpr auto registers();
1761 };
1762
1763 class ForInPrepareDescriptor
1764 : public StaticCallInterfaceDescriptor<ForInPrepareDescriptor> {
1765 public:
1766 DEFINE_RESULT_AND_PARAMETERS(2, kEnumerator, kVectorIndex, kFeedbackVector)
1767 DEFINE_RESULT_AND_PARAMETER_TYPES(
1768 MachineType::AnyTagged(), // result 1 (cache array)
1769 MachineType::AnyTagged(), // result 2 (cache length)
1770 MachineType::AnyTagged(), // kEnumerator
1771 MachineType::TaggedSigned(), // kVectorIndex
1772 MachineType::AnyTagged()) // kFeedbackVector
1773 DECLARE_DESCRIPTOR(ForInPrepareDescriptor)
1774 };
1775
1776 class ResumeGeneratorDescriptor final
1777 : public StaticCallInterfaceDescriptor<ResumeGeneratorDescriptor> {
1778 public:
1779 DEFINE_PARAMETERS(kValue, kGenerator)
1780 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kValue
1781 MachineType::AnyTagged()) // kGenerator
1782 DECLARE_DESCRIPTOR(ResumeGeneratorDescriptor)
1783
1784 static constexpr inline auto registers();
1785 };
1786
1787 class ResumeGeneratorBaselineDescriptor final
1788 : public StaticCallInterfaceDescriptor<ResumeGeneratorBaselineDescriptor> {
1789 public:
1790 DEFINE_PARAMETERS_NO_CONTEXT(kGeneratorObject, kRegisterCount)
1791 DEFINE_RESULT_AND_PARAMETER_TYPES(
1792 MachineType::TaggedSigned(), // return type
1793 MachineType::AnyTagged(), // kGeneratorObject
1794 MachineType::IntPtr(), // kRegisterCount
1795 )
1796 DECLARE_DESCRIPTOR(ResumeGeneratorBaselineDescriptor)
1797 };
1798
1799 class SuspendGeneratorBaselineDescriptor final
1800 : public StaticCallInterfaceDescriptor<SuspendGeneratorBaselineDescriptor> {
1801 public:
1802 DEFINE_PARAMETERS_NO_CONTEXT(kGeneratorObject, kSuspendId, kBytecodeOffset,
1803 kRegisterCount)
1804 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kGeneratorObject
1805 MachineType::IntPtr(), // kSuspendId
1806 MachineType::IntPtr(), // kBytecodeOffset
1807 MachineType::IntPtr(), // kRegisterCount
1808 )
1809 DECLARE_DESCRIPTOR(SuspendGeneratorBaselineDescriptor)
1810 };
1811
1812 class RunMicrotasksEntryDescriptor final
1813 : public StaticCallInterfaceDescriptor<RunMicrotasksEntryDescriptor> {
1814 public:
1815 DEFINE_PARAMETERS_ENTRY(kRootRegisterValue, kMicrotaskQueue)
1816 DEFINE_PARAMETER_TYPES(MachineType::Pointer(), // kRootRegisterValue
1817 MachineType::Pointer()) // kMicrotaskQueue
1818 DECLARE_DESCRIPTOR(RunMicrotasksEntryDescriptor)
1819
1820 static constexpr inline auto registers();
1821 };
1822
1823 class RunMicrotasksDescriptor final
1824 : public StaticCallInterfaceDescriptor<RunMicrotasksDescriptor> {
1825 public:
1826 DEFINE_PARAMETERS(kMicrotaskQueue)
1827 DEFINE_PARAMETER_TYPES(MachineType::Pointer())
1828 DECLARE_DESCRIPTOR(RunMicrotasksDescriptor)
1829
1830 static constexpr inline Register MicrotaskQueueRegister();
1831 };
1832
1833 class WasmFloat32ToNumberDescriptor final
1834 : public StaticCallInterfaceDescriptor<WasmFloat32ToNumberDescriptor> {
1835 public:
1836 DEFINE_PARAMETERS_NO_CONTEXT(kValue)
1837 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result
1838 MachineType::Float32()) // value
1839 DECLARE_DESCRIPTOR(WasmFloat32ToNumberDescriptor)
1840
1841 #if V8_TARGET_ARCH_IA32
1842 // We need a custom descriptor on ia32 to avoid using xmm0.
1843 static constexpr inline auto registers();
1844 #endif
1845 };
1846
1847 class WasmFloat64ToNumberDescriptor final
1848 : public StaticCallInterfaceDescriptor<WasmFloat64ToNumberDescriptor> {
1849 public:
1850 DEFINE_PARAMETERS_NO_CONTEXT(kValue)
1851 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result
1852 MachineType::Float64()) // value
1853 DECLARE_DESCRIPTOR(WasmFloat64ToNumberDescriptor)
1854
1855 #if V8_TARGET_ARCH_IA32
1856 // We need a custom descriptor on ia32 to avoid using xmm0.
1857 static constexpr inline auto registers();
1858 #endif
1859 };
1860
1861 class WasmSuspendDescriptor final
1862 : public StaticCallInterfaceDescriptor<WasmSuspendDescriptor> {
1863 public:
1864 DEFINE_RESULT_AND_PARAMETERS_NO_CONTEXT(1, kArg0, kArg1)
1865 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result
1866 MachineType::AnyTagged(), // value
1867 MachineType::AnyTagged()) // value
1868 DECLARE_DESCRIPTOR(WasmSuspendDescriptor)
1869 };
1870
1871 class V8_EXPORT_PRIVATE I64ToBigIntDescriptor final
1872 : public StaticCallInterfaceDescriptor<I64ToBigIntDescriptor> {
1873 public:
1874 DEFINE_PARAMETERS_NO_CONTEXT(kArgument)
1875 DEFINE_PARAMETER_TYPES(MachineType::Int64()) // kArgument
1876 DECLARE_DESCRIPTOR(I64ToBigIntDescriptor)
1877 };
1878
1879 // 32 bits version of the I64ToBigIntDescriptor call interface descriptor
1880 class V8_EXPORT_PRIVATE I32PairToBigIntDescriptor final
1881 : public StaticCallInterfaceDescriptor<I32PairToBigIntDescriptor> {
1882 public:
1883 DEFINE_PARAMETERS_NO_CONTEXT(kLow, kHigh)
1884 DEFINE_PARAMETER_TYPES(MachineType::Uint32(), // kLow
1885 MachineType::Uint32()) // kHigh
1886 DECLARE_DESCRIPTOR(I32PairToBigIntDescriptor)
1887 };
1888
1889 class V8_EXPORT_PRIVATE BigIntToI64Descriptor final
1890 : public StaticCallInterfaceDescriptor<BigIntToI64Descriptor> {
1891 public:
1892 DEFINE_PARAMETERS(kArgument)
1893 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::Int64(), // result 1
1894 MachineType::AnyTagged()) // kArgument
1895 DECLARE_DESCRIPTOR(BigIntToI64Descriptor)
1896 };
1897
1898 class V8_EXPORT_PRIVATE BigIntToI32PairDescriptor final
1899 : public StaticCallInterfaceDescriptor<BigIntToI32PairDescriptor> {
1900 public:
1901 DEFINE_RESULT_AND_PARAMETERS(2, kArgument)
1902 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::Uint32(), // result 1
1903 MachineType::Uint32(), // result 2
1904 MachineType::AnyTagged()) // kArgument
1905 DECLARE_DESCRIPTOR(BigIntToI32PairDescriptor)
1906 };
1907
1908 class WasmI32AtomicWait32Descriptor final
1909 : public StaticCallInterfaceDescriptor<WasmI32AtomicWait32Descriptor> {
1910 public:
1911 DEFINE_PARAMETERS_NO_CONTEXT(kAddress, kExpectedValue, kTimeoutLow,
1912 kTimeoutHigh)
1913 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::Uint32(), // result 1
1914 MachineType::Uint32(), // kAddress
1915 MachineType::Int32(), // kExpectedValue
1916 MachineType::Uint32(), // kTimeoutLow
1917 MachineType::Uint32()) // kTimeoutHigh
1918 DECLARE_DESCRIPTOR(WasmI32AtomicWait32Descriptor)
1919 };
1920
1921 class WasmI64AtomicWait32Descriptor final
1922 : public StaticCallInterfaceDescriptor<WasmI64AtomicWait32Descriptor> {
1923 public:
1924 DEFINE_PARAMETERS_NO_CONTEXT(kAddress, kExpectedValueLow, kExpectedValueHigh,
1925 kTimeoutLow, kTimeoutHigh)
1926
1927 static constexpr bool kNoStackScan = true;
1928
1929 DEFINE_RESULT_AND_PARAMETER_TYPES(
1930 MachineType::Uint32(), // result 1
1931 MachineType::Uint32(), // kAddress
1932 MachineType::Uint32(), // kExpectedValueLow
1933 MachineType::Uint32(), // kExpectedValueHigh
1934 MachineType::Uint32(), // kTimeoutLow
1935 MachineType::Uint32()) // kTimeoutHigh
1936
1937 DECLARE_DESCRIPTOR(WasmI64AtomicWait32Descriptor)
1938 };
1939
1940 class CloneObjectWithVectorDescriptor final
1941 : public StaticCallInterfaceDescriptor<CloneObjectWithVectorDescriptor> {
1942 public:
1943 DEFINE_PARAMETERS(kSource, kFlags, kSlot, kVector)
1944 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::TaggedPointer(), // result 1
1945 MachineType::AnyTagged(), // kSource
1946 MachineType::TaggedSigned(), // kFlags
1947 MachineType::TaggedSigned(), // kSlot
1948 MachineType::AnyTagged()) // kVector
1949 DECLARE_DESCRIPTOR(CloneObjectWithVectorDescriptor)
1950 };
1951
1952 class CloneObjectBaselineDescriptor final
1953 : public StaticCallInterfaceDescriptor<CloneObjectBaselineDescriptor> {
1954 public:
1955 DEFINE_PARAMETERS_NO_CONTEXT(kSource, kFlags, kSlot)
1956 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kSource
1957 MachineType::TaggedSigned(), // kFlags
1958 MachineType::TaggedSigned()) // kSlot
1959 DECLARE_DESCRIPTOR(CloneObjectBaselineDescriptor)
1960 };
1961
1962 class BinaryOp_WithFeedbackDescriptor
1963 : public StaticCallInterfaceDescriptor<BinaryOp_WithFeedbackDescriptor> {
1964 public:
1965 DEFINE_PARAMETERS(kLeft, kRight, kSlot, kFeedbackVector)
1966 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kLeft
1967 MachineType::AnyTagged(), // kRight
1968 MachineType::UintPtr(), // kSlot
1969 MachineType::AnyTagged()) // kFeedbackVector
1970 DECLARE_DESCRIPTOR(BinaryOp_WithFeedbackDescriptor)
1971 };
1972
1973 class CallTrampoline_Baseline_CompactDescriptor
1974 : public StaticCallInterfaceDescriptor<
1975 CallTrampoline_Baseline_CompactDescriptor> {
1976 public:
1977 using ArgumentCountField = base::BitField<uint32_t, 0, 8>;
1978 using SlotField = base::BitField<uintptr_t, 8, 24>;
1979
EncodeBitField(uint32_t argc,uintptr_t slot,uint32_t * out)1980 static bool EncodeBitField(uint32_t argc, uintptr_t slot, uint32_t* out) {
1981 if (ArgumentCountField::is_valid(argc) && SlotField::is_valid(slot)) {
1982 *out = ArgumentCountField::encode(argc) | SlotField::encode(slot);
1983 return true;
1984 }
1985 return false;
1986 }
1987
1988 DEFINE_PARAMETERS_NO_CONTEXT_VARARGS(kFunction, kBitField)
1989 DEFINE_PARAMETER_TYPES(
1990 MachineType::AnyTagged(), // kFunction
1991 MachineType::Uint32()) // kBitField = ArgumentCountField | SlotField
1992 DECLARE_DESCRIPTOR(CallTrampoline_Baseline_CompactDescriptor)
1993 };
1994
1995 class CallTrampoline_BaselineDescriptor
1996 : public StaticCallInterfaceDescriptor<CallTrampoline_BaselineDescriptor> {
1997 public:
1998 DEFINE_PARAMETERS_NO_CONTEXT_VARARGS(kFunction, kActualArgumentsCount, kSlot)
1999 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction
2000 MachineType::Int32(), // kActualArgumentsCount
2001 MachineType::UintPtr()) // kSlot
2002 DECLARE_DESCRIPTOR(CallTrampoline_BaselineDescriptor)
2003 };
2004
2005 class CallTrampoline_WithFeedbackDescriptor
2006 : public StaticCallInterfaceDescriptor<
2007 CallTrampoline_WithFeedbackDescriptor> {
2008 public:
2009 DEFINE_PARAMETERS_VARARGS(kFunction, kActualArgumentsCount, kSlot,
2010 kFeedbackVector, kReceiver)
2011 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction
2012 MachineType::Int32(), // kActualArgumentsCount
2013 MachineType::UintPtr(), // kSlot
2014 MachineType::AnyTagged(), // kFeedbackVector
2015 MachineType::AnyTagged()) // kReceiver
2016 DECLARE_DESCRIPTOR(CallTrampoline_WithFeedbackDescriptor)
2017 };
2018
2019 class Compare_WithFeedbackDescriptor
2020 : public StaticCallInterfaceDescriptor<Compare_WithFeedbackDescriptor> {
2021 public:
2022 DEFINE_PARAMETERS(kLeft, kRight, kSlot, kFeedbackVector)
2023 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kLeft
2024 MachineType::AnyTagged(), // kRight
2025 MachineType::UintPtr(), // kSlot
2026 MachineType::AnyTagged()) // kFeedbackVector
2027 DECLARE_DESCRIPTOR(Compare_WithFeedbackDescriptor)
2028 };
2029
2030 class Compare_BaselineDescriptor
2031 : public StaticCallInterfaceDescriptor<Compare_BaselineDescriptor> {
2032 public:
2033 DEFINE_PARAMETERS_NO_CONTEXT(kLeft, kRight, kSlot)
2034 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kLeft
2035 MachineType::AnyTagged(), // kRight
2036 MachineType::UintPtr()) // kSlot
2037 DECLARE_DESCRIPTOR(Compare_BaselineDescriptor)
2038
2039 static constexpr inline auto registers();
2040 };
2041
2042 class Construct_BaselineDescriptor
2043 : public StaticJSCallInterfaceDescriptor<Construct_BaselineDescriptor> {
2044 public:
2045 DEFINE_JS_PARAMETERS_NO_CONTEXT(kSlot)
2046 DEFINE_JS_PARAMETER_TYPES(MachineType::UintPtr()) // kSlot
2047 DECLARE_JS_COMPATIBLE_DESCRIPTOR(Construct_BaselineDescriptor)
2048 };
2049
2050 class Construct_WithFeedbackDescriptor
2051 : public StaticJSCallInterfaceDescriptor<Construct_WithFeedbackDescriptor> {
2052 public:
2053 // kSlot is passed in a register, kFeedbackVector on the stack.
2054 DEFINE_JS_PARAMETERS(kSlot, kFeedbackVector)
2055 DEFINE_JS_PARAMETER_TYPES(MachineType::UintPtr(), // kSlot
2056 MachineType::AnyTagged()) // kFeedbackVector
2057 DECLARE_JS_COMPATIBLE_DESCRIPTOR(Construct_WithFeedbackDescriptor)
2058 };
2059
2060 class UnaryOp_WithFeedbackDescriptor
2061 : public StaticCallInterfaceDescriptor<UnaryOp_WithFeedbackDescriptor> {
2062 public:
2063 DEFINE_PARAMETERS(kValue, kSlot, kFeedbackVector)
2064 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kValue
2065 MachineType::UintPtr(), // kSlot
2066 MachineType::AnyTagged()) // kFeedbackVector
2067 DECLARE_DESCRIPTOR(UnaryOp_WithFeedbackDescriptor)
2068 };
2069
2070 class UnaryOp_BaselineDescriptor
2071 : public StaticCallInterfaceDescriptor<UnaryOp_BaselineDescriptor> {
2072 public:
2073 DEFINE_PARAMETERS_NO_CONTEXT(kValue, kSlot)
2074 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kValue
2075 MachineType::UintPtr()) // kSlot
2076 DECLARE_DESCRIPTOR(UnaryOp_BaselineDescriptor)
2077 };
2078
2079 #define DEFINE_TFS_BUILTIN_DESCRIPTOR(Name, ...) \
2080 class Name##Descriptor \
2081 : public StaticCallInterfaceDescriptor<Name##Descriptor> { \
2082 public: \
2083 DEFINE_PARAMETERS(__VA_ARGS__) \
2084 DECLARE_DEFAULT_DESCRIPTOR(Name##Descriptor) \
2085 };
2086 BUILTIN_LIST_TFS(DEFINE_TFS_BUILTIN_DESCRIPTOR)
2087 #undef DEFINE_TFS_BUILTIN_DESCRIPTOR
2088
2089 // This file contains interface descriptor class definitions for builtins
2090 // defined in Torque. It is included here because the class definitions need to
2091 // precede the definition of name##Descriptor::key() below.
2092 #include "torque-generated/interface-descriptors.inc"
2093
2094 #undef DECLARE_DEFAULT_DESCRIPTOR
2095 #undef DECLARE_DESCRIPTOR_WITH_BASE
2096 #undef DECLARE_DESCRIPTOR
2097 #undef DECLARE_JS_COMPATIBLE_DESCRIPTOR
2098 #undef DEFINE_RESULT_AND_PARAMETERS
2099 #undef DEFINE_PARAMETERS_ENTRY
2100 #undef DEFINE_PARAMETERS
2101 #undef DEFINE_PARAMETERS_VARARGS
2102 #undef DEFINE_PARAMETERS_NO_CONTEXT
2103 #undef DEFINE_RESULT_AND_PARAMETERS_NO_CONTEXT
2104 #undef DEFINE_RESULT_AND_PARAMETER_TYPES
2105 #undef DEFINE_PARAMETER_TYPES
2106 #undef DEFINE_JS_PARAMETERS
2107 #undef DEFINE_JS_PARAMETER_TYPES
2108
2109 // We define the association between CallDescriptors::Key and the specialized
2110 // descriptor here to reduce boilerplate and mistakes.
2111 #define DEF_KEY(name, ...) \
2112 CallDescriptors::Key name##Descriptor::key() { return CallDescriptors::name; }
2113 INTERFACE_DESCRIPTOR_LIST(DEF_KEY)
2114 #undef DEF_KEY
2115 } // namespace internal
2116 } // namespace v8
2117
2118 #endif // V8_CODEGEN_INTERFACE_DESCRIPTORS_H_
2119