Line data Source code
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_INTERFACE_DESCRIPTORS_H_
6 : #define V8_INTERFACE_DESCRIPTORS_H_
7 :
8 : #include <memory>
9 :
10 : #include "src/globals.h"
11 : #include "src/isolate.h"
12 : #include "src/machine-type.h"
13 : #include "src/register-arch.h"
14 :
15 : namespace v8 {
16 : namespace internal {
17 :
18 : #define INTERFACE_DESCRIPTOR_LIST(V) \
19 : V(Abort) \
20 : V(Allocate) \
21 : V(AllocateHeapNumber) \
22 : V(ApiCallback) \
23 : V(ApiGetter) \
24 : V(ArgumentsAdaptor) \
25 : V(ArrayConstructor) \
26 : V(ArrayNArgumentsConstructor) \
27 : V(ArrayNoArgumentConstructor) \
28 : V(ArraySingleArgumentConstructor) \
29 : V(AsyncFunctionStackParameter) \
30 : V(BigIntToI64) \
31 : V(BigIntToWasmI64) \
32 : V(BinaryOp) \
33 : V(CallForwardVarargs) \
34 : V(CallTrampoline) \
35 : V(CallVarargs) \
36 : V(CallWithArrayLike) \
37 : V(CallWithSpread) \
38 : V(CEntry1ArgvOnStack) \
39 : V(CloneObjectWithVector) \
40 : V(Compare) \
41 : V(ConstructForwardVarargs) \
42 : V(ConstructStub) \
43 : V(ConstructVarargs) \
44 : V(ConstructWithArrayLike) \
45 : V(ConstructWithSpread) \
46 : V(ContextOnly) \
47 : V(CppBuiltinAdaptor) \
48 : V(FastNewFunctionContext) \
49 : V(FastNewObject) \
50 : V(FrameDropperTrampoline) \
51 : V(GetProperty) \
52 : V(GrowArrayElements) \
53 : V(InterpreterCEntry1) \
54 : V(InterpreterCEntry2) \
55 : V(InterpreterDispatch) \
56 : V(InterpreterPushArgsThenCall) \
57 : V(InterpreterPushArgsThenConstruct) \
58 : V(JSTrampoline) \
59 : V(Load) \
60 : V(LoadGlobal) \
61 : V(LoadGlobalWithVector) \
62 : V(LoadWithVector) \
63 : V(NewArgumentsElements) \
64 : V(NoContext) \
65 : V(RecordWrite) \
66 : V(ResumeGenerator) \
67 : V(RunMicrotasksEntry) \
68 : V(RunMicrotasks) \
69 : V(Store) \
70 : V(StoreGlobal) \
71 : V(StoreGlobalWithVector) \
72 : V(StoreTransition) \
73 : V(StoreWithVector) \
74 : V(StringAt) \
75 : V(StringSubstring) \
76 : V(TypeConversion) \
77 : V(TypeConversionStackParameter) \
78 : V(Typeof) \
79 : V(Void) \
80 : V(WasmAtomicWake) \
81 : V(WasmI32AtomicWait) \
82 : V(WasmI64AtomicWait) \
83 : V(WasmMemoryGrow) \
84 : V(WasmThrow) \
85 : BUILTIN_LIST_TFS(V)
86 :
87 : class V8_EXPORT_PRIVATE CallInterfaceDescriptorData {
88 : public:
89 : enum Flag {
90 : kNoFlags = 0u,
91 : kNoContext = 1u << 0,
92 :
93 : // This indicates that the code uses a special frame that does not scan the
94 : // stack arguments, e.g. EntryFrame. And this allows the code to use
95 : // untagged stack arguments.
96 : kNoStackScan = 1u << 1,
97 : };
98 : typedef base::Flags<Flag> Flags;
99 :
100 29909032 : CallInterfaceDescriptorData() = default;
101 :
102 : // A copy of the passed in registers and param_representations is made
103 : // and owned by the CallInterfaceDescriptorData.
104 :
105 : void InitializePlatformSpecific(int register_parameter_count,
106 : const Register* registers);
107 :
108 : // if machine_types is null, then an array of size
109 : // (return_count + parameter_count) will be created with
110 : // MachineType::AnyTagged() for each member.
111 : //
112 : // if machine_types is not null, then it should be of the size
113 : // (return_count + parameter_count). Those members of the parameter array will
114 : // be initialized from {machine_types}, and the rest initialized to
115 : // MachineType::AnyTagged().
116 : void InitializePlatformIndependent(Flags flags, int return_count,
117 : int parameter_count,
118 : const MachineType* machine_types,
119 : int machine_types_length);
120 :
121 : void Reset();
122 :
123 : bool IsInitialized() const {
124 : return IsInitializedPlatformSpecific() &&
125 : IsInitializedPlatformIndependent();
126 : }
127 :
128 : Flags flags() const { return flags_; }
129 : int return_count() const { return return_count_; }
130 : int param_count() const { return param_count_; }
131 : int register_param_count() const { return register_param_count_; }
132 6880993 : Register register_param(int index) const { return register_params_[index]; }
133 : Register* register_params() const { return register_params_; }
134 : MachineType return_type(int index) const {
135 : DCHECK_LT(index, return_count_);
136 2757558 : return machine_types_[index];
137 : }
138 : MachineType param_type(int index) const {
139 : DCHECK_LT(index, param_count_);
140 6408559 : return machine_types_[return_count_ + index];
141 : }
142 :
143 : void RestrictAllocatableRegisters(const Register* registers, int num) {
144 : DCHECK_EQ(allocatable_registers_, 0);
145 306405 : for (int i = 0; i < num; ++i) {
146 612810 : allocatable_registers_ |= registers[i].bit();
147 : }
148 : DCHECK_GT(NumRegs(allocatable_registers_), 0);
149 : }
150 :
151 : RegList allocatable_registers() const { return allocatable_registers_; }
152 :
153 : private:
154 : bool IsInitializedPlatformSpecific() const {
155 : const bool initialized =
156 : (register_param_count_ == 0 && register_params_ == nullptr) ||
157 : (register_param_count_ > 0 && register_params_ != nullptr);
158 : // Platform-specific initialization happens before platform-independent.
159 : return initialized;
160 : }
161 : bool IsInitializedPlatformIndependent() const {
162 : const bool initialized =
163 : return_count_ >= 0 && param_count_ >= 0 && machine_types_ != nullptr;
164 : // Platform-specific initialization happens before platform-independent.
165 : return initialized;
166 : }
167 :
168 : #ifdef DEBUG
169 : bool AllStackParametersAreTagged() const;
170 : #endif // DEBUG
171 :
172 : int register_param_count_ = -1;
173 : int return_count_ = -1;
174 : int param_count_ = -1;
175 : Flags flags_ = kNoFlags;
176 :
177 : // Specifying the set of registers that could be used by the register
178 : // allocator. Currently, it's only used by RecordWrite code stub.
179 : RegList allocatable_registers_ = 0;
180 :
181 : // |registers_params_| defines registers that are used for parameter passing.
182 : // |machine_types_| defines machine types for resulting values and incomping
183 : // parameters.
184 : // Both arrays are allocated dynamically by the InterfaceDescriptor and
185 : // freed on destruction. This is because static arrays cause creation of
186 : // runtime static initializers which we don't want.
187 : Register* register_params_ = nullptr;
188 : MachineType* machine_types_ = nullptr;
189 :
190 : DISALLOW_COPY_AND_ASSIGN(CallInterfaceDescriptorData);
191 : };
192 :
193 : class V8_EXPORT_PRIVATE CallDescriptors : public AllStatic {
194 : public:
195 : enum Key {
196 : #define DEF_ENUM(name, ...) name,
197 : INTERFACE_DESCRIPTOR_LIST(DEF_ENUM)
198 : #undef DEF_ENUM
199 : NUMBER_OF_DESCRIPTORS
200 : };
201 :
202 : static void InitializeOncePerProcess();
203 : static void TearDown();
204 :
205 : static CallInterfaceDescriptorData* call_descriptor_data(
206 : CallDescriptors::Key key) {
207 2336745 : return &call_descriptor_data_[key];
208 : }
209 :
210 : static Key GetKey(const CallInterfaceDescriptorData* data) {
211 2757382 : ptrdiff_t index = data - call_descriptor_data_;
212 : DCHECK_LE(0, index);
213 : DCHECK_LT(index, CallDescriptors::NUMBER_OF_DESCRIPTORS);
214 2757382 : return static_cast<CallDescriptors::Key>(index);
215 : }
216 :
217 : private:
218 : static CallInterfaceDescriptorData
219 : call_descriptor_data_[NUMBER_OF_DESCRIPTORS];
220 : };
221 :
222 8949124 : class V8_EXPORT_PRIVATE CallInterfaceDescriptor {
223 : public:
224 : typedef CallInterfaceDescriptorData::Flags Flags;
225 :
226 : CallInterfaceDescriptor() : data_(nullptr) {}
227 15840285 : virtual ~CallInterfaceDescriptor() = default;
228 :
229 : explicit CallInterfaceDescriptor(CallDescriptors::Key key)
230 17647432 : : data_(CallDescriptors::call_descriptor_data(key)) {}
231 :
232 247940 : Flags flags() const { return data()->flags(); }
233 :
234 : bool HasContextParameter() const {
235 : return (flags() & CallInterfaceDescriptorData::kNoContext) == 0;
236 : }
237 :
238 2713027 : int GetReturnCount() const { return data()->return_count(); }
239 :
240 2757558 : MachineType GetReturnType(int index) const {
241 : DCHECK_LT(index, data()->return_count());
242 2757558 : return data()->return_type(index);
243 : }
244 :
245 51125 : int GetParameterCount() const { return data()->param_count(); }
246 :
247 2759563 : int GetRegisterParameterCount() const {
248 3100332 : return data()->register_param_count();
249 : }
250 :
251 98907 : int GetStackParameterCount() const {
252 2102454 : return data()->param_count() - data()->register_param_count();
253 : }
254 :
255 6406531 : Register GetRegisterParameter(int index) const {
256 6880937 : return data()->register_param(index);
257 : }
258 :
259 : MachineType GetParameterType(int index) const {
260 : DCHECK_LT(index, data()->param_count());
261 6408559 : return data()->param_type(index);
262 : }
263 :
264 2713004 : RegList allocatable_registers() const {
265 3026666 : return data()->allocatable_registers();
266 : }
267 :
268 : static const Register ContextRegister();
269 :
270 : const char* DebugName() const;
271 :
272 : protected:
273 : const CallInterfaceDescriptorData* data() const { return data_; }
274 :
275 0 : virtual void InitializePlatformSpecific(CallInterfaceDescriptorData* data) {
276 0 : UNREACHABLE();
277 : }
278 :
279 122562 : virtual void InitializePlatformIndependent(
280 122562 : CallInterfaceDescriptorData* data) {
281 : // Default descriptor configuration: one result, all parameters are passed
282 : // in registers and all parameters have MachineType::AnyTagged() type.
283 : data->InitializePlatformIndependent(CallInterfaceDescriptorData::kNoFlags,
284 : 1, data->register_param_count(),
285 122562 : nullptr, 0);
286 122562 : }
287 :
288 : // Initializes |data| using the platform dependent default set of registers.
289 : // It is intended to be used for TurboFan stubs when particular set of
290 : // registers does not matter.
291 : static void DefaultInitializePlatformSpecific(
292 : CallInterfaceDescriptorData* data, int register_parameter_count);
293 :
294 : // Initializes |data| using the platform dependent default set of registers
295 : // for JavaScript-compatible calling convention.
296 : // It is intended to be used for TurboFan stubs being called with JavaScript
297 : // linkage + additional parameters on registers and stack.
298 : static void JSDefaultInitializePlatformSpecific(
299 : CallInterfaceDescriptorData* data, int non_js_register_parameter_count);
300 :
301 : // Checks if float parameters are not assigned invalid registers.
302 : bool CheckFloatingPointParameters(CallInterfaceDescriptorData* data) {
303 : for (int i = 0; i < data->register_param_count(); i++) {
304 : if (IsFloatingPoint(data->param_type(i).representation())) {
305 : if (!IsValidFloatParameterRegister(data->register_param(i))) {
306 : return false;
307 : }
308 : }
309 : }
310 : return true;
311 : }
312 :
313 : bool IsValidFloatParameterRegister(Register reg);
314 :
315 : private:
316 : // {CallDescriptors} is allowed to call the private {Initialize} method.
317 : friend class CallDescriptors;
318 :
319 : const CallInterfaceDescriptorData* data_;
320 :
321 2328678 : void Initialize(CallInterfaceDescriptorData* data) {
322 : // The passed pointer should be a modifiable pointer to our own data.
323 : DCHECK_EQ(data, data_);
324 : DCHECK(!data->IsInitialized());
325 14952564 : InitializePlatformSpecific(data);
326 14952564 : InitializePlatformIndependent(data);
327 : DCHECK(data->IsInitialized());
328 : DCHECK(CheckFloatingPointParameters(data));
329 2328678 : }
330 : };
331 :
332 : #define DECLARE_DESCRIPTOR_WITH_BASE(name, base) \
333 : public: \
334 : explicit name() : base(key()) {} \
335 : static inline CallDescriptors::Key key();
336 :
337 : #if defined(V8_TARGET_ARCH_IA32)
338 : // To support all possible cases, we must limit the number of register args for
339 : // TFS builtins on ia32 to 3. Out of the 6 allocatable registers, esi is taken
340 : // as the context register and ebx is the root register. One register must
341 : // remain available to store the jump/call target. Thus 3 registers remain for
342 : // arguments. The reason this applies to TFS builtins specifically is because
343 : // this becomes relevant for builtins used as targets of Torque function
344 : // pointers (which must have a register available to store the target).
345 : // TODO(jgruber): Ideally we should just decrement kMaxBuiltinRegisterParams but
346 : // that comes with its own set of complications. It's possible, but requires
347 : // refactoring the calling convention of other existing stubs.
348 : constexpr int kMaxBuiltinRegisterParams = 4;
349 : constexpr int kMaxTFSBuiltinRegisterParams = 3;
350 : #else
351 : constexpr int kMaxBuiltinRegisterParams = 5;
352 : constexpr int kMaxTFSBuiltinRegisterParams = kMaxBuiltinRegisterParams;
353 : #endif
354 : STATIC_ASSERT(kMaxTFSBuiltinRegisterParams <= kMaxBuiltinRegisterParams);
355 :
356 : #define DECLARE_DEFAULT_DESCRIPTOR(name, base) \
357 : DECLARE_DESCRIPTOR_WITH_BASE(name, base) \
358 : protected: \
359 : static const int kRegisterParams = \
360 : kParameterCount > kMaxTFSBuiltinRegisterParams \
361 : ? kMaxTFSBuiltinRegisterParams \
362 : : kParameterCount; \
363 : static const int kStackParams = kParameterCount - kRegisterParams; \
364 : void InitializePlatformSpecific(CallInterfaceDescriptorData* data) \
365 : override { \
366 : DefaultInitializePlatformSpecific(data, kRegisterParams); \
367 : } \
368 : void InitializePlatformIndependent(CallInterfaceDescriptorData* data) \
369 : override { \
370 : data->InitializePlatformIndependent(Flags(kDescriptorFlags), kReturnCount, \
371 : kParameterCount, nullptr, 0); \
372 : } \
373 : name(CallDescriptors::Key key) : base(key) {} \
374 : \
375 : public:
376 :
377 : #define DECLARE_JS_COMPATIBLE_DESCRIPTOR(name, base, \
378 : non_js_reg_parameters_count) \
379 : DECLARE_DESCRIPTOR_WITH_BASE(name, base) \
380 : protected: \
381 : void InitializePlatformSpecific(CallInterfaceDescriptorData* data) \
382 : override { \
383 : JSDefaultInitializePlatformSpecific(data, non_js_reg_parameters_count); \
384 : } \
385 : name(CallDescriptors::Key key) : base(key) {} \
386 : \
387 : public:
388 :
389 : #define DEFINE_RESULT_AND_PARAMETERS(return_count, ...) \
390 : static constexpr int kDescriptorFlags = \
391 : CallInterfaceDescriptorData::kNoFlags; \
392 : static constexpr int kReturnCount = return_count; \
393 : enum ParameterIndices { \
394 : __dummy = -1, /* to be able to pass zero arguments */ \
395 : ##__VA_ARGS__, \
396 : \
397 : kParameterCount, \
398 : kContext = kParameterCount /* implicit parameter */ \
399 : };
400 :
401 : #define DEFINE_RESULT_AND_PARAMETERS_NO_CONTEXT(return_count, ...) \
402 : static constexpr int kDescriptorFlags = \
403 : CallInterfaceDescriptorData::kNoContext; \
404 : static constexpr int kReturnCount = return_count; \
405 : enum ParameterIndices { \
406 : __dummy = -1, /* to be able to pass zero arguments */ \
407 : ##__VA_ARGS__, \
408 : \
409 : kParameterCount \
410 : };
411 :
412 : // This is valid only for builtins that use EntryFrame, which does not scan
413 : // stack arguments on GC.
414 : #define DEFINE_PARAMETERS_ENTRY(...) \
415 : static constexpr int kDescriptorFlags = \
416 : CallInterfaceDescriptorData::kNoContext | \
417 : CallInterfaceDescriptorData::kNoStackScan; \
418 : static constexpr int kReturnCount = 1; \
419 : enum ParameterIndices { \
420 : __dummy = -1, /* to be able to pass zero arguments */ \
421 : ##__VA_ARGS__, \
422 : \
423 : kParameterCount \
424 : };
425 :
426 : #define DEFINE_PARAMETERS(...) DEFINE_RESULT_AND_PARAMETERS(1, ##__VA_ARGS__)
427 :
428 : #define DEFINE_PARAMETERS_NO_CONTEXT(...) \
429 : DEFINE_RESULT_AND_PARAMETERS_NO_CONTEXT(1, ##__VA_ARGS__)
430 :
431 : #define DEFINE_RESULT_AND_PARAMETER_TYPES(...) \
432 : void InitializePlatformIndependent(CallInterfaceDescriptorData* data) \
433 : override { \
434 : MachineType machine_types[] = {__VA_ARGS__}; \
435 : static_assert( \
436 : kReturnCount + kParameterCount == arraysize(machine_types), \
437 : "Parameter names definition is not consistent with parameter types"); \
438 : data->InitializePlatformIndependent(Flags(kDescriptorFlags), kReturnCount, \
439 : kParameterCount, machine_types, \
440 : arraysize(machine_types)); \
441 : }
442 :
443 : #define DEFINE_PARAMETER_TYPES(...) \
444 : DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged() /* result */, \
445 : ##__VA_ARGS__)
446 :
447 : #define DEFINE_JS_PARAMETERS(...) \
448 : static constexpr int kDescriptorFlags = \
449 : CallInterfaceDescriptorData::kNoFlags; \
450 : static constexpr int kReturnCount = 1; \
451 : enum ParameterIndices { \
452 : kTarget, \
453 : kNewTarget, \
454 : kActualArgumentsCount, \
455 : ##__VA_ARGS__, \
456 : \
457 : kParameterCount, \
458 : kContext = kParameterCount /* implicit parameter */ \
459 : };
460 :
461 : #define DEFINE_JS_PARAMETER_TYPES(...) \
462 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), /* kTarget */ \
463 : MachineType::AnyTagged(), /* kNewTarget */ \
464 : MachineType::Int32(), /* kActualArgumentsCount */ \
465 : ##__VA_ARGS__)
466 :
467 : #define DECLARE_DESCRIPTOR(name, base) \
468 : DECLARE_DESCRIPTOR_WITH_BASE(name, base) \
469 : protected: \
470 : void InitializePlatformSpecific(CallInterfaceDescriptorData* data) override; \
471 : name(CallDescriptors::Key key) : base(key) {} \
472 : \
473 : public:
474 :
475 61281 : class V8_EXPORT_PRIVATE VoidDescriptor : public CallInterfaceDescriptor {
476 : public:
477 : DEFINE_PARAMETERS()
478 122562 : DEFINE_PARAMETER_TYPES()
479 61414 : DECLARE_DESCRIPTOR(VoidDescriptor, CallInterfaceDescriptor)
480 : };
481 :
482 : // Dummy descriptor used to mark builtins that don't yet have their proper
483 : // descriptor associated.
484 : typedef VoidDescriptor DummyDescriptor;
485 :
486 : // Dummy descriptor that marks builtins with C calling convention.
487 : typedef VoidDescriptor CCallDescriptor;
488 :
489 173300 : class AllocateDescriptor : public CallInterfaceDescriptor {
490 : public:
491 : DEFINE_PARAMETERS_NO_CONTEXT(kRequestedSize)
492 122562 : DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::TaggedPointer(), // result 1
493 : MachineType::IntPtr()) // kRequestedSize
494 173298 : DECLARE_DESCRIPTOR(AllocateDescriptor, CallInterfaceDescriptor)
495 : };
496 :
497 : // This descriptor defines the JavaScript calling convention that can be used
498 : // by stubs: target, new.target, argc (not including the receiver) and context
499 : // are passed in registers while receiver and the rest of the JS arguments are
500 : // passed on the stack.
501 61281 : class JSTrampolineDescriptor : public CallInterfaceDescriptor {
502 : public:
503 : DEFINE_JS_PARAMETERS()
504 122562 : DEFINE_JS_PARAMETER_TYPES()
505 :
506 123066 : DECLARE_JS_COMPATIBLE_DESCRIPTOR(JSTrampolineDescriptor,
507 : CallInterfaceDescriptor, 0)
508 : };
509 :
510 61281 : class ContextOnlyDescriptor : public CallInterfaceDescriptor {
511 : public:
512 : DEFINE_PARAMETERS()
513 122562 : DEFINE_PARAMETER_TYPES()
514 61281 : DECLARE_DESCRIPTOR(ContextOnlyDescriptor, CallInterfaceDescriptor)
515 : };
516 :
517 74710 : class NoContextDescriptor : public CallInterfaceDescriptor {
518 : public:
519 : DEFINE_PARAMETERS_NO_CONTEXT()
520 122562 : DEFINE_PARAMETER_TYPES()
521 74723 : DECLARE_DESCRIPTOR(NoContextDescriptor, CallInterfaceDescriptor)
522 : };
523 :
524 : // LoadDescriptor is used by all stubs that implement Load/KeyedLoad ICs.
525 123850 : class LoadDescriptor : public CallInterfaceDescriptor {
526 : public:
527 : DEFINE_PARAMETERS(kReceiver, kName, kSlot)
528 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
529 : MachineType::AnyTagged(), // kName
530 : MachineType::TaggedSigned()) // kSlot
531 123850 : DECLARE_DESCRIPTOR(LoadDescriptor, CallInterfaceDescriptor)
532 :
533 : static const Register ReceiverRegister();
534 : static const Register NameRegister();
535 : static const Register SlotRegister();
536 : };
537 :
538 122562 : class LoadGlobalDescriptor : public CallInterfaceDescriptor {
539 : public:
540 : DEFINE_PARAMETERS(kName, kSlot)
541 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
542 : MachineType::TaggedSigned()) // kSlot
543 122562 : DECLARE_DESCRIPTOR(LoadGlobalDescriptor, CallInterfaceDescriptor)
544 :
545 : static const Register NameRegister() {
546 122562 : return LoadDescriptor::NameRegister();
547 : }
548 :
549 : static const Register SlotRegister() {
550 122562 : return LoadDescriptor::SlotRegister();
551 : }
552 : };
553 :
554 184235 : class StoreDescriptor : public CallInterfaceDescriptor {
555 : public:
556 : DEFINE_PARAMETERS(kReceiver, kName, kValue, kSlot)
557 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
558 : MachineType::AnyTagged(), // kName
559 : MachineType::AnyTagged(), // kValue
560 : MachineType::TaggedSigned()) // kSlot
561 184235 : DECLARE_DESCRIPTOR(StoreDescriptor, CallInterfaceDescriptor)
562 :
563 : static const Register ReceiverRegister();
564 : static const Register NameRegister();
565 : static const Register ValueRegister();
566 : static const Register SlotRegister();
567 :
568 : #if V8_TARGET_ARCH_IA32
569 : static const bool kPassLastArgsOnStack = true;
570 : #else
571 : static const bool kPassLastArgsOnStack = false;
572 : #endif
573 :
574 : // Pass value and slot through the stack.
575 : static const int kStackArgumentsCount = kPassLastArgsOnStack ? 2 : 0;
576 : };
577 :
578 61393 : class StoreTransitionDescriptor : public StoreDescriptor {
579 : public:
580 : DEFINE_PARAMETERS(kReceiver, kName, kMap, kValue, kSlot, kVector)
581 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
582 : MachineType::AnyTagged(), // kName
583 : MachineType::AnyTagged(), // kMap
584 : MachineType::AnyTagged(), // kValue
585 : MachineType::TaggedSigned(), // kSlot
586 : MachineType::AnyTagged()) // kVector
587 61393 : DECLARE_DESCRIPTOR(StoreTransitionDescriptor, StoreDescriptor)
588 :
589 : static const Register MapRegister();
590 : static const Register SlotRegister();
591 : static const Register VectorRegister();
592 :
593 : // Pass value, slot and vector through the stack.
594 : static const int kStackArgumentsCount = kPassLastArgsOnStack ? 3 : 0;
595 : };
596 :
597 61561 : class StoreWithVectorDescriptor : public StoreDescriptor {
598 : public:
599 : DEFINE_PARAMETERS(kReceiver, kName, kValue, kSlot, kVector)
600 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
601 : MachineType::AnyTagged(), // kName
602 : MachineType::AnyTagged(), // kValue
603 : MachineType::TaggedSigned(), // kSlot
604 : MachineType::AnyTagged()) // kVector
605 61561 : DECLARE_DESCRIPTOR(StoreWithVectorDescriptor, StoreDescriptor)
606 :
607 : static const Register VectorRegister();
608 :
609 : // Pass value, slot and vector through the stack.
610 : static const int kStackArgumentsCount = kPassLastArgsOnStack ? 3 : 0;
611 : };
612 :
613 122562 : class StoreGlobalDescriptor : public CallInterfaceDescriptor {
614 : public:
615 : DEFINE_PARAMETERS(kName, kValue, kSlot)
616 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
617 : MachineType::AnyTagged(), // kValue
618 : MachineType::TaggedSigned()) // kSlot
619 122562 : DECLARE_DESCRIPTOR(StoreGlobalDescriptor, CallInterfaceDescriptor)
620 :
621 : static const bool kPassLastArgsOnStack =
622 : StoreDescriptor::kPassLastArgsOnStack;
623 : // Pass value and slot through the stack.
624 : static const int kStackArgumentsCount = kPassLastArgsOnStack ? 2 : 0;
625 :
626 : static const Register NameRegister() {
627 122562 : return StoreDescriptor::NameRegister();
628 : }
629 :
630 : static const Register ValueRegister() {
631 122562 : return StoreDescriptor::ValueRegister();
632 : }
633 :
634 : static const Register SlotRegister() {
635 122562 : return StoreDescriptor::SlotRegister();
636 : }
637 : };
638 :
639 61281 : class StoreGlobalWithVectorDescriptor : public StoreGlobalDescriptor {
640 : public:
641 : DEFINE_PARAMETERS(kName, kValue, kSlot, kVector)
642 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
643 : MachineType::AnyTagged(), // kValue
644 : MachineType::TaggedSigned(), // kSlot
645 : MachineType::AnyTagged()) // kVector
646 61281 : DECLARE_DESCRIPTOR(StoreGlobalWithVectorDescriptor, StoreGlobalDescriptor)
647 :
648 : static const Register VectorRegister() {
649 61281 : return StoreWithVectorDescriptor::VectorRegister();
650 : }
651 :
652 : // Pass value, slot and vector through the stack.
653 : static const int kStackArgumentsCount = kPassLastArgsOnStack ? 3 : 0;
654 : };
655 :
656 62569 : class LoadWithVectorDescriptor : public LoadDescriptor {
657 : public:
658 : DEFINE_PARAMETERS(kReceiver, kName, kSlot, kVector)
659 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
660 : MachineType::AnyTagged(), // kName
661 : MachineType::TaggedSigned(), // kSlot
662 : MachineType::AnyTagged()) // kVector
663 62569 : DECLARE_DESCRIPTOR(LoadWithVectorDescriptor, LoadDescriptor)
664 :
665 : static const Register VectorRegister();
666 :
667 : #if V8_TARGET_ARCH_IA32
668 : static const bool kPassLastArgsOnStack = true;
669 : #else
670 : static const bool kPassLastArgsOnStack = false;
671 : #endif
672 :
673 : // Pass vector through the stack.
674 : static const int kStackArgumentsCount = kPassLastArgsOnStack ? 1 : 0;
675 : };
676 :
677 61281 : class LoadGlobalWithVectorDescriptor : public LoadGlobalDescriptor {
678 : public:
679 : DEFINE_PARAMETERS(kName, kSlot, kVector)
680 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName
681 : MachineType::TaggedSigned(), // kSlot
682 : MachineType::AnyTagged()) // kVector
683 61281 : DECLARE_DESCRIPTOR(LoadGlobalWithVectorDescriptor, LoadGlobalDescriptor)
684 :
685 : #if V8_TARGET_ARCH_IA32
686 : // On ia32, LoadWithVectorDescriptor passes vector on the stack and thus we
687 : // need to choose a new register here.
688 : static const Register VectorRegister() { return edx; }
689 : #else
690 : static const Register VectorRegister() {
691 61281 : return LoadWithVectorDescriptor::VectorRegister();
692 : }
693 : #endif
694 : };
695 :
696 61281 : class FastNewFunctionContextDescriptor : public CallInterfaceDescriptor {
697 : public:
698 : DEFINE_PARAMETERS(kScopeInfo, kSlots)
699 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kScopeInfo
700 : MachineType::Int32()) // kSlots
701 61281 : DECLARE_DESCRIPTOR(FastNewFunctionContextDescriptor, CallInterfaceDescriptor)
702 :
703 : static const Register ScopeInfoRegister();
704 : static const Register SlotsRegister();
705 : };
706 :
707 61281 : class FastNewObjectDescriptor : public CallInterfaceDescriptor {
708 : public:
709 : DEFINE_PARAMETERS(kTarget, kNewTarget)
710 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
711 : MachineType::AnyTagged()) // kNewTarget
712 61281 : DECLARE_DESCRIPTOR(FastNewObjectDescriptor, CallInterfaceDescriptor)
713 : static const Register TargetRegister();
714 : static const Register NewTargetRegister();
715 : };
716 :
717 61281 : class RecordWriteDescriptor final : public CallInterfaceDescriptor {
718 : public:
719 : DEFINE_PARAMETERS_NO_CONTEXT(kObject, kSlot, kRememberedSet, kFPMode)
720 122562 : DEFINE_PARAMETER_TYPES(MachineType::TaggedPointer(), // kObject
721 : MachineType::Pointer(), // kSlot
722 : MachineType::TaggedSigned(), // kRememberedSet
723 : MachineType::TaggedSigned()) // kFPMode
724 :
725 61337 : DECLARE_DESCRIPTOR(RecordWriteDescriptor, CallInterfaceDescriptor)
726 : };
727 :
728 156228 : class TypeConversionDescriptor final : public CallInterfaceDescriptor {
729 : public:
730 : DEFINE_PARAMETERS(kArgument)
731 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged())
732 156282 : DECLARE_DESCRIPTOR(TypeConversionDescriptor, CallInterfaceDescriptor)
733 :
734 : static const Register ArgumentRegister();
735 : };
736 :
737 61281 : class TypeConversionStackParameterDescriptor final
738 : : public CallInterfaceDescriptor {
739 : public:
740 : DEFINE_PARAMETERS(kArgument)
741 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged())
742 61281 : DECLARE_DESCRIPTOR(TypeConversionStackParameterDescriptor,
743 : CallInterfaceDescriptor)
744 : };
745 :
746 61281 : class AsyncFunctionStackParameterDescriptor final
747 : : public CallInterfaceDescriptor {
748 : public:
749 : DEFINE_PARAMETERS(kPromise, kResult)
750 122562 : DEFINE_PARAMETER_TYPES(MachineType::TaggedPointer(), MachineType::AnyTagged())
751 61281 : DECLARE_DESCRIPTOR(AsyncFunctionStackParameterDescriptor,
752 : CallInterfaceDescriptor)
753 : };
754 :
755 61281 : class GetPropertyDescriptor final : public CallInterfaceDescriptor {
756 : public:
757 : DEFINE_PARAMETERS(kObject, kKey)
758 245124 : DECLARE_DEFAULT_DESCRIPTOR(GetPropertyDescriptor, CallInterfaceDescriptor)
759 : };
760 :
761 61281 : class TypeofDescriptor : public CallInterfaceDescriptor {
762 : public:
763 : DEFINE_PARAMETERS(kObject)
764 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged())
765 61281 : DECLARE_DESCRIPTOR(TypeofDescriptor, CallInterfaceDescriptor)
766 : };
767 :
768 63162 : class CallTrampolineDescriptor : public CallInterfaceDescriptor {
769 : public:
770 : DEFINE_PARAMETERS(kFunction, kActualArgumentsCount)
771 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction
772 : MachineType::Int32()) // kActualArgumentsCount
773 63218 : DECLARE_DESCRIPTOR(CallTrampolineDescriptor, CallInterfaceDescriptor)
774 : };
775 :
776 61281 : class CallVarargsDescriptor : public CallInterfaceDescriptor {
777 : public:
778 : DEFINE_PARAMETERS(kTarget, kActualArgumentsCount, kArgumentsLength,
779 : kArgumentsList)
780 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
781 : MachineType::Int32(), // kActualArgumentsCount
782 : MachineType::Int32(), // kArgumentsLength
783 : MachineType::AnyTagged()) // kArgumentsList
784 61281 : DECLARE_DESCRIPTOR(CallVarargsDescriptor, CallInterfaceDescriptor)
785 : };
786 :
787 61281 : class CallForwardVarargsDescriptor : public CallInterfaceDescriptor {
788 : public:
789 : DEFINE_PARAMETERS(kTarget, kActualArgumentsCount, kStartIndex)
790 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
791 : MachineType::Int32(), // kActualArgumentsCount
792 : MachineType::Int32()) // kStartIndex
793 61281 : DECLARE_DESCRIPTOR(CallForwardVarargsDescriptor, CallInterfaceDescriptor)
794 : };
795 :
796 61281 : class CallWithSpreadDescriptor : public CallInterfaceDescriptor {
797 : public:
798 : DEFINE_PARAMETERS(kTarget, kArgumentsCount, kSpread)
799 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
800 : MachineType::Int32(), // kArgumentsCount
801 : MachineType::AnyTagged()) // kSpread
802 61281 : DECLARE_DESCRIPTOR(CallWithSpreadDescriptor, CallInterfaceDescriptor)
803 : };
804 :
805 61281 : class CallWithArrayLikeDescriptor : public CallInterfaceDescriptor {
806 : public:
807 : DEFINE_PARAMETERS(kTarget, kArgumentsList)
808 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
809 : MachineType::AnyTagged()) // kArgumentsList
810 61281 : DECLARE_DESCRIPTOR(CallWithArrayLikeDescriptor, CallInterfaceDescriptor)
811 : };
812 :
813 61281 : class ConstructVarargsDescriptor : public CallInterfaceDescriptor {
814 : public:
815 : DEFINE_JS_PARAMETERS(kArgumentsLength, kArgumentsList)
816 122562 : DEFINE_JS_PARAMETER_TYPES(MachineType::Int32(), // kArgumentsLength
817 : MachineType::AnyTagged()) // kArgumentsList
818 :
819 61281 : DECLARE_DESCRIPTOR(ConstructVarargsDescriptor, CallInterfaceDescriptor)
820 : };
821 :
822 61281 : class ConstructForwardVarargsDescriptor : public CallInterfaceDescriptor {
823 : public:
824 : DEFINE_JS_PARAMETERS(kStartIndex)
825 122562 : DEFINE_JS_PARAMETER_TYPES(MachineType::Int32())
826 61281 : DECLARE_DESCRIPTOR(ConstructForwardVarargsDescriptor, CallInterfaceDescriptor)
827 : };
828 :
829 61281 : class ConstructWithSpreadDescriptor : public CallInterfaceDescriptor {
830 : public:
831 : DEFINE_JS_PARAMETERS(kSpread)
832 122562 : DEFINE_JS_PARAMETER_TYPES(MachineType::AnyTagged())
833 61281 : DECLARE_DESCRIPTOR(ConstructWithSpreadDescriptor, CallInterfaceDescriptor)
834 : };
835 :
836 61281 : class ConstructWithArrayLikeDescriptor : public CallInterfaceDescriptor {
837 : public:
838 : DEFINE_PARAMETERS(kTarget, kNewTarget, kArgumentsList)
839 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget
840 : MachineType::AnyTagged(), // kNewTarget
841 : MachineType::AnyTagged()) // kArgumentsList
842 61281 : DECLARE_DESCRIPTOR(ConstructWithArrayLikeDescriptor, CallInterfaceDescriptor)
843 : };
844 :
845 : // TODO(ishell): consider merging this with ArrayConstructorDescriptor
846 61281 : class ConstructStubDescriptor : public CallInterfaceDescriptor {
847 : public:
848 : // TODO(jgruber): Remove the unused allocation site parameter.
849 : DEFINE_JS_PARAMETERS(kAllocationSite)
850 122562 : DEFINE_JS_PARAMETER_TYPES(MachineType::AnyTagged());
851 :
852 : // TODO(ishell): Use DECLARE_JS_COMPATIBLE_DESCRIPTOR if registers match
853 84300 : DECLARE_DESCRIPTOR(ConstructStubDescriptor, CallInterfaceDescriptor)
854 : };
855 :
856 61281 : class AbortDescriptor : public CallInterfaceDescriptor {
857 : public:
858 : DEFINE_PARAMETERS_NO_CONTEXT(kMessageOrMessageId)
859 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged())
860 61281 : DECLARE_DESCRIPTOR(AbortDescriptor, CallInterfaceDescriptor)
861 : };
862 :
863 74993 : class AllocateHeapNumberDescriptor : public CallInterfaceDescriptor {
864 : public:
865 : DEFINE_PARAMETERS_NO_CONTEXT()
866 122562 : DEFINE_PARAMETER_TYPES()
867 75049 : DECLARE_DESCRIPTOR(AllocateHeapNumberDescriptor, CallInterfaceDescriptor)
868 : };
869 :
870 61418 : class ArrayConstructorDescriptor : public CallInterfaceDescriptor {
871 : public:
872 : DEFINE_JS_PARAMETERS(kAllocationSite)
873 122562 : DEFINE_JS_PARAMETER_TYPES(MachineType::AnyTagged());
874 :
875 122699 : DECLARE_JS_COMPATIBLE_DESCRIPTOR(ArrayConstructorDescriptor,
876 : CallInterfaceDescriptor, 1)
877 : };
878 :
879 183843 : class ArrayNArgumentsConstructorDescriptor : public CallInterfaceDescriptor {
880 : public:
881 : // This descriptor declares only register arguments while respective number
882 : // of JS arguments stay on the expression stack.
883 : // The ArrayNArgumentsConstructor builtin does not access stack arguments
884 : // directly it just forwards them to the runtime function.
885 : DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount)
886 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction,
887 : MachineType::AnyTagged(), // kAllocationSite
888 : MachineType::Int32()) // kActualArgumentsCount
889 184627 : DECLARE_DESCRIPTOR(ArrayNArgumentsConstructorDescriptor,
890 : CallInterfaceDescriptor)
891 : };
892 :
893 61281 : class ArrayNoArgumentConstructorDescriptor
894 : : public ArrayNArgumentsConstructorDescriptor {
895 : public:
896 : // This descriptor declares same register arguments as the parent
897 : // ArrayNArgumentsConstructorDescriptor and it declares indices for
898 : // JS arguments passed on the expression stack.
899 : DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount,
900 : kFunctionParameter)
901 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction
902 : MachineType::AnyTagged(), // kAllocationSite
903 : MachineType::Int32(), // kActualArgumentsCount
904 : MachineType::AnyTagged()) // kFunctionParameter
905 61281 : DECLARE_DESCRIPTOR(ArrayNoArgumentConstructorDescriptor,
906 : ArrayNArgumentsConstructorDescriptor)
907 : };
908 :
909 61281 : class ArraySingleArgumentConstructorDescriptor
910 : : public ArrayNArgumentsConstructorDescriptor {
911 : public:
912 : // This descriptor declares same register arguments as the parent
913 : // ArrayNArgumentsConstructorDescriptor and it declares indices for
914 : // JS arguments passed on the expression stack.
915 : DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount,
916 : kFunctionParameter, kArraySizeSmiParameter)
917 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction
918 : MachineType::AnyTagged(), // kAllocationSite
919 : MachineType::Int32(), // kActualArgumentsCount
920 : MachineType::AnyTagged(), // kFunctionParameter
921 : MachineType::AnyTagged()) // kArraySizeSmiParameter
922 61281 : DECLARE_DESCRIPTOR(ArraySingleArgumentConstructorDescriptor,
923 : ArrayNArgumentsConstructorDescriptor)
924 : };
925 :
926 61281 : class CompareDescriptor : public CallInterfaceDescriptor {
927 : public:
928 : DEFINE_PARAMETERS(kLeft, kRight)
929 61281 : DECLARE_DESCRIPTOR(CompareDescriptor, CallInterfaceDescriptor)
930 : };
931 :
932 :
933 61281 : class BinaryOpDescriptor : public CallInterfaceDescriptor {
934 : public:
935 : DEFINE_PARAMETERS(kLeft, kRight)
936 61281 : DECLARE_DESCRIPTOR(BinaryOpDescriptor, CallInterfaceDescriptor)
937 : };
938 :
939 : // This desciptor is shared among String.p.charAt/charCodeAt/codePointAt
940 : // as they all have the same interface.
941 61281 : class StringAtDescriptor final : public CallInterfaceDescriptor {
942 : public:
943 : DEFINE_PARAMETERS(kReceiver, kPosition)
944 : // TODO(turbofan): Return untagged value here.
945 122562 : DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::TaggedSigned(), // result 1
946 : MachineType::AnyTagged(), // kReceiver
947 : MachineType::IntPtr()) // kPosition
948 61281 : DECLARE_DESCRIPTOR(StringAtDescriptor, CallInterfaceDescriptor)
949 : };
950 :
951 61281 : class StringSubstringDescriptor final : public CallInterfaceDescriptor {
952 : public:
953 : DEFINE_PARAMETERS(kString, kFrom, kTo)
954 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kString
955 : MachineType::IntPtr(), // kFrom
956 : MachineType::IntPtr()) // kTo
957 :
958 : // TODO(turbofan): Allow builtins to return untagged values.
959 61281 : DECLARE_DESCRIPTOR(StringSubstringDescriptor, CallInterfaceDescriptor)
960 : };
961 :
962 61822 : class ArgumentsAdaptorDescriptor : public CallInterfaceDescriptor {
963 : public:
964 : DEFINE_JS_PARAMETERS(kExpectedArgumentsCount)
965 122562 : DEFINE_JS_PARAMETER_TYPES(MachineType::Int32())
966 61822 : DECLARE_DESCRIPTOR(ArgumentsAdaptorDescriptor, CallInterfaceDescriptor)
967 : };
968 :
969 61281 : class CppBuiltinAdaptorDescriptor : public CallInterfaceDescriptor {
970 : public:
971 : DEFINE_JS_PARAMETERS(kCFunction)
972 122562 : DEFINE_JS_PARAMETER_TYPES(MachineType::Pointer())
973 122562 : DECLARE_JS_COMPATIBLE_DESCRIPTOR(CppBuiltinAdaptorDescriptor,
974 : CallInterfaceDescriptor, 1)
975 : };
976 :
977 61281 : class CEntry1ArgvOnStackDescriptor : public CallInterfaceDescriptor {
978 : public:
979 : DEFINE_PARAMETERS(kArity, // register argument
980 : kCFunction, // register argument
981 : kPadding, // stack argument 1 (just padding)
982 : kArgcSmi, // stack argument 2
983 : kTargetCopy, // stack argument 3
984 : kNewTargetCopy) // stack argument 4
985 122562 : DEFINE_PARAMETER_TYPES(MachineType::Int32(), // kArity
986 : MachineType::Pointer(), // kCFunction
987 : MachineType::AnyTagged(), // kPadding
988 : MachineType::AnyTagged(), // kArgcSmi
989 : MachineType::AnyTagged(), // kTargetCopy
990 : MachineType::AnyTagged()) // kNewTargetCopy
991 61393 : DECLARE_DESCRIPTOR(CEntry1ArgvOnStackDescriptor, CallInterfaceDescriptor)
992 : };
993 :
994 61281 : class ApiCallbackDescriptor : public CallInterfaceDescriptor {
995 : public:
996 : DEFINE_PARAMETERS_NO_CONTEXT(kTargetContext, // register argument
997 : kApiFunctionAddress, // register argument
998 : kArgc, // register argument
999 : kCallData, // stack argument 1
1000 : kHolder) // stack argument 2
1001 : // receiver is implicit stack argument 3
1002 : // argv are implicit stack arguments [4, 4 + kArgc[
1003 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTargetContext
1004 : MachineType::Pointer(), // kApiFunctionAddress
1005 : MachineType::IntPtr(), // kArgc
1006 : MachineType::AnyTagged(), // kCallData
1007 : MachineType::AnyTagged()) // kHolder
1008 61281 : DECLARE_DESCRIPTOR(ApiCallbackDescriptor, CallInterfaceDescriptor)
1009 : };
1010 :
1011 61281 : class ApiGetterDescriptor : public CallInterfaceDescriptor {
1012 : public:
1013 : DEFINE_PARAMETERS(kReceiver, kHolder, kCallback)
1014 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver
1015 : MachineType::AnyTagged(), // kHolder
1016 : MachineType::AnyTagged()) // kCallback
1017 61281 : DECLARE_DESCRIPTOR(ApiGetterDescriptor, CallInterfaceDescriptor)
1018 :
1019 : static const Register ReceiverRegister();
1020 : static const Register HolderRegister();
1021 : static const Register CallbackRegister();
1022 : };
1023 :
1024 : // TODO(turbofan): We should probably rename this to GrowFastElementsDescriptor.
1025 61281 : class GrowArrayElementsDescriptor : public CallInterfaceDescriptor {
1026 : public:
1027 : DEFINE_PARAMETERS(kObject, kKey)
1028 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kObject
1029 : MachineType::AnyTagged()) // kKey
1030 61281 : DECLARE_DESCRIPTOR(GrowArrayElementsDescriptor, CallInterfaceDescriptor)
1031 :
1032 : static const Register ObjectRegister();
1033 : static const Register KeyRegister();
1034 : };
1035 :
1036 61281 : class NewArgumentsElementsDescriptor final : public CallInterfaceDescriptor {
1037 : public:
1038 : DEFINE_PARAMETERS(kFrame, kLength, kMappedCount)
1039 122562 : DEFINE_PARAMETER_TYPES(MachineType::Pointer(), // kFrame
1040 : MachineType::TaggedSigned(), // kLength
1041 : MachineType::TaggedSigned()) // kMappedCount
1042 61281 : DECLARE_DESCRIPTOR(NewArgumentsElementsDescriptor, CallInterfaceDescriptor)
1043 : };
1044 :
1045 87825 : class V8_EXPORT_PRIVATE InterpreterDispatchDescriptor
1046 : : public CallInterfaceDescriptor {
1047 : public:
1048 : DEFINE_PARAMETERS(kAccumulator, kBytecodeOffset, kBytecodeArray,
1049 : kDispatchTable)
1050 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kAccumulator
1051 : MachineType::IntPtr(), // kBytecodeOffset
1052 : MachineType::AnyTagged(), // kBytecodeArray
1053 : MachineType::IntPtr()) // kDispatchTable
1054 133623 : DECLARE_DESCRIPTOR(InterpreterDispatchDescriptor, CallInterfaceDescriptor)
1055 : };
1056 :
1057 61281 : class InterpreterPushArgsThenCallDescriptor : public CallInterfaceDescriptor {
1058 : public:
1059 : DEFINE_PARAMETERS(kNumberOfArguments, kFirstArgument, kFunction)
1060 122562 : DEFINE_PARAMETER_TYPES(MachineType::Int32(), // kNumberOfArguments
1061 : MachineType::Pointer(), // kFirstArgument
1062 : MachineType::AnyTagged()) // kFunction
1063 61281 : DECLARE_DESCRIPTOR(InterpreterPushArgsThenCallDescriptor,
1064 : CallInterfaceDescriptor)
1065 : };
1066 :
1067 61281 : class InterpreterPushArgsThenConstructDescriptor
1068 : : public CallInterfaceDescriptor {
1069 : public:
1070 : DEFINE_PARAMETERS(kNumberOfArguments, kFirstArgument, kConstructor,
1071 : kNewTarget, kFeedbackElement)
1072 122562 : DEFINE_PARAMETER_TYPES(MachineType::Int32(), // kNumberOfArguments
1073 : MachineType::Pointer(), // kFirstArgument
1074 : MachineType::AnyTagged(), // kConstructor
1075 : MachineType::AnyTagged(), // kNewTarget
1076 : MachineType::AnyTagged()) // kFeedbackElement
1077 61281 : DECLARE_DESCRIPTOR(InterpreterPushArgsThenConstructDescriptor,
1078 : CallInterfaceDescriptor)
1079 :
1080 : #if V8_TARGET_ARCH_IA32
1081 : static const bool kPassLastArgsOnStack = true;
1082 : #else
1083 : static const bool kPassLastArgsOnStack = false;
1084 : #endif
1085 :
1086 : // Pass constructor, new target and feedback element through the stack.
1087 : static const int kStackArgumentsCount = kPassLastArgsOnStack ? 3 : 0;
1088 : };
1089 :
1090 61281 : class InterpreterCEntry1Descriptor : public CallInterfaceDescriptor {
1091 : public:
1092 : DEFINE_RESULT_AND_PARAMETERS(1, kNumberOfArguments, kFirstArgument,
1093 : kFunctionEntry)
1094 122562 : DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result 1
1095 : MachineType::Int32(), // kNumberOfArguments
1096 : MachineType::Pointer(), // kFirstArgument
1097 : MachineType::Pointer()) // kFunctionEntry
1098 61281 : DECLARE_DESCRIPTOR(InterpreterCEntry1Descriptor, CallInterfaceDescriptor)
1099 : };
1100 :
1101 61281 : class InterpreterCEntry2Descriptor : public CallInterfaceDescriptor {
1102 : public:
1103 : DEFINE_RESULT_AND_PARAMETERS(2, kNumberOfArguments, kFirstArgument,
1104 : kFunctionEntry)
1105 122562 : DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result 1
1106 : MachineType::AnyTagged(), // result 2
1107 : MachineType::Int32(), // kNumberOfArguments
1108 : MachineType::Pointer(), // kFirstArgument
1109 : MachineType::Pointer()) // kFunctionEntry
1110 61281 : DECLARE_DESCRIPTOR(InterpreterCEntry2Descriptor, CallInterfaceDescriptor)
1111 : };
1112 :
1113 61281 : class ResumeGeneratorDescriptor final : public CallInterfaceDescriptor {
1114 : public:
1115 : DEFINE_PARAMETERS(kValue, kGenerator)
1116 122562 : DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kValue
1117 : MachineType::AnyTagged()) // kGenerator
1118 61281 : DECLARE_DESCRIPTOR(ResumeGeneratorDescriptor, CallInterfaceDescriptor)
1119 : };
1120 :
1121 61281 : class FrameDropperTrampolineDescriptor final : public CallInterfaceDescriptor {
1122 : public:
1123 : DEFINE_PARAMETERS(kRestartFp)
1124 122562 : DEFINE_PARAMETER_TYPES(MachineType::Pointer())
1125 61281 : DECLARE_DESCRIPTOR(FrameDropperTrampolineDescriptor, CallInterfaceDescriptor)
1126 : };
1127 :
1128 61281 : class RunMicrotasksEntryDescriptor final : public CallInterfaceDescriptor {
1129 : public:
1130 : DEFINE_PARAMETERS_ENTRY(kRootRegisterValue, kMicrotaskQueue)
1131 122562 : DEFINE_PARAMETER_TYPES(MachineType::Pointer(), // kRootRegisterValue
1132 : MachineType::Pointer()) // kMicrotaskQueue
1133 61281 : DECLARE_DESCRIPTOR(RunMicrotasksEntryDescriptor, CallInterfaceDescriptor)
1134 : };
1135 :
1136 61281 : class RunMicrotasksDescriptor final : public CallInterfaceDescriptor {
1137 : public:
1138 : DEFINE_PARAMETERS(kMicrotaskQueue)
1139 122562 : DEFINE_PARAMETER_TYPES(MachineType::Pointer())
1140 61281 : DECLARE_DESCRIPTOR(RunMicrotasksDescriptor, CallInterfaceDescriptor)
1141 :
1142 : static Register MicrotaskQueueRegister();
1143 : };
1144 :
1145 61281 : class WasmMemoryGrowDescriptor final : public CallInterfaceDescriptor {
1146 : public:
1147 : DEFINE_PARAMETERS_NO_CONTEXT(kNumPages)
1148 122562 : DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::Int32(), // result 1
1149 : MachineType::Int32()) // kNumPages
1150 62561 : DECLARE_DESCRIPTOR(WasmMemoryGrowDescriptor, CallInterfaceDescriptor)
1151 : };
1152 :
1153 61281 : class WasmThrowDescriptor final : public CallInterfaceDescriptor {
1154 : public:
1155 : DEFINE_PARAMETERS_NO_CONTEXT(kException)
1156 122562 : DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result 1
1157 : MachineType::AnyTagged()) // kException
1158 62297 : DECLARE_DESCRIPTOR(WasmThrowDescriptor, CallInterfaceDescriptor)
1159 : };
1160 :
1161 61281 : class BigIntToWasmI64Descriptor final : public CallInterfaceDescriptor {
1162 : public:
1163 : DEFINE_PARAMETERS_NO_CONTEXT(kArgument)
1164 122562 : DEFINE_PARAMETER_TYPES(MachineType::Int64()) // kArgument
1165 61373 : DECLARE_DESCRIPTOR(BigIntToWasmI64Descriptor, CallInterfaceDescriptor)
1166 : };
1167 :
1168 61281 : class BigIntToI64Descriptor final : public CallInterfaceDescriptor {
1169 : public:
1170 : DEFINE_PARAMETERS(kArgument)
1171 122562 : DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::Int64(), // result 1
1172 : MachineType::AnyTagged()) // kArgument
1173 61355 : DECLARE_DESCRIPTOR(BigIntToI64Descriptor, CallInterfaceDescriptor)
1174 : };
1175 :
1176 61461 : class WasmAtomicWakeDescriptor final : public CallInterfaceDescriptor {
1177 : public:
1178 : DEFINE_PARAMETERS_NO_CONTEXT(kAddress, kCount)
1179 122562 : DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::Uint32(), // result 1
1180 : MachineType::Uint32(), // kAddress
1181 : MachineType::Uint32()) // kCount
1182 61461 : DECLARE_DESCRIPTOR(WasmAtomicWakeDescriptor, CallInterfaceDescriptor)
1183 : };
1184 :
1185 61569 : class WasmI32AtomicWaitDescriptor final : public CallInterfaceDescriptor {
1186 : public:
1187 : DEFINE_PARAMETERS_NO_CONTEXT(kAddress, kExpectedValue, kTimeout)
1188 122562 : DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::Uint32(), // result 1
1189 : MachineType::Uint32(), // kAddress
1190 : MachineType::Int32(), // kExpectedValue
1191 : MachineType::Float64()) // kTimeout
1192 61569 : DECLARE_DESCRIPTOR(WasmI32AtomicWaitDescriptor, CallInterfaceDescriptor)
1193 : };
1194 :
1195 61568 : class WasmI64AtomicWaitDescriptor final : public CallInterfaceDescriptor {
1196 : public:
1197 : DEFINE_PARAMETERS_NO_CONTEXT(kAddress, kExpectedValueHigh, kExpectedValueLow,
1198 : kTimeout)
1199 122562 : DEFINE_RESULT_AND_PARAMETER_TYPES(
1200 : MachineType::Uint32(), // result 1
1201 : MachineType::Uint32(), // kAddress
1202 : MachineType::Uint32(), // kExpectedValueHigh
1203 : MachineType::Uint32(), // kExpectedValueLow
1204 : MachineType::Float64()) // kTimeout
1205 61569 : DECLARE_DESCRIPTOR(WasmI64AtomicWaitDescriptor, CallInterfaceDescriptor)
1206 : };
1207 :
1208 61281 : class CloneObjectWithVectorDescriptor final : public CallInterfaceDescriptor {
1209 : public:
1210 : DEFINE_PARAMETERS(kSource, kFlags, kSlot, kVector)
1211 122562 : DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::TaggedPointer(), // result 1
1212 : MachineType::AnyTagged(), // kSource
1213 : MachineType::TaggedSigned(), // kFlags
1214 : MachineType::TaggedSigned(), // kSlot
1215 : MachineType::AnyTagged()) // kVector
1216 61281 : DECLARE_DESCRIPTOR(CloneObjectWithVectorDescriptor, CallInterfaceDescriptor)
1217 : };
1218 :
1219 : #define DEFINE_TFS_BUILTIN_DESCRIPTOR(Name, ...) \
1220 : class Name##Descriptor : public CallInterfaceDescriptor { \
1221 : public: \
1222 : DEFINE_PARAMETERS(__VA_ARGS__) \
1223 : DECLARE_DEFAULT_DESCRIPTOR(Name##Descriptor, CallInterfaceDescriptor) \
1224 : };
1225 54478809 : BUILTIN_LIST_TFS(DEFINE_TFS_BUILTIN_DESCRIPTOR)
1226 : #undef DEFINE_TFS_BUILTIN_DESCRIPTOR
1227 :
1228 : #undef DECLARE_DEFAULT_DESCRIPTOR
1229 : #undef DECLARE_DESCRIPTOR_WITH_BASE
1230 : #undef DECLARE_DESCRIPTOR
1231 : #undef DECLARE_JS_COMPATIBLE_DESCRIPTOR
1232 : #undef DEFINE_RESULT_AND_PARAMETERS
1233 : #undef DEFINE_RESULT_AND_PARAMETERS_NO_CONTEXT
1234 : #undef DEFINE_PARAMETERS
1235 : #undef DEFINE_PARAMETERS_NO_CONTEXT
1236 : #undef DEFINE_RESULT_AND_PARAMETER_TYPES
1237 : #undef DEFINE_PARAMETER_TYPES
1238 : #undef DEFINE_JS_PARAMETERS
1239 : #undef DEFINE_JS_PARAMETER_TYPES
1240 :
1241 : // We define the association between CallDescriptors::Key and the specialized
1242 : // descriptor here to reduce boilerplate and mistakes.
1243 : #define DEF_KEY(name, ...) \
1244 : CallDescriptors::Key name##Descriptor::key() { return CallDescriptors::name; }
1245 : INTERFACE_DESCRIPTOR_LIST(DEF_KEY)
1246 : #undef DEF_KEY
1247 : } // namespace internal
1248 : } // namespace v8
1249 :
1250 : #endif // V8_INTERFACE_DESCRIPTORS_H_
|
