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_CALL_INTERFACE_DESCRIPTOR_H_
6 : #define V8_CALL_INTERFACE_DESCRIPTOR_H_
7 :
8 : #include <memory>
9 :
10 : #include "src/assembler.h"
11 : #include "src/globals.h"
12 : #include "src/macro-assembler.h"
13 :
14 : namespace v8 {
15 : namespace internal {
16 :
17 : class PlatformInterfaceDescriptor;
18 :
19 : #define INTERFACE_DESCRIPTOR_LIST(V) \
20 : V(Void) \
21 : V(ContextOnly) \
22 : V(Load) \
23 : V(LoadWithVector) \
24 : V(LoadField) \
25 : V(LoadICProtoArray) \
26 : V(LoadGlobal) \
27 : V(LoadGlobalWithVector) \
28 : V(Store) \
29 : V(StoreWithVector) \
30 : V(StoreNamedTransition) \
31 : V(StoreTransition) \
32 : V(FastNewClosure) \
33 : V(FastNewFunctionContext) \
34 : V(FastNewObject) \
35 : V(FastNewArguments) \
36 : V(RecordWrite) \
37 : V(TypeConversion) \
38 : V(TypeConversionStackParameter) \
39 : V(Typeof) \
40 : V(CallFunction) \
41 : V(CallVarargs) \
42 : V(CallForwardVarargs) \
43 : V(CallWithSpread) \
44 : V(CallWithArrayLike) \
45 : V(CallTrampoline) \
46 : V(ConstructStub) \
47 : V(ConstructVarargs) \
48 : V(ConstructForwardVarargs) \
49 : V(ConstructWithSpread) \
50 : V(ConstructWithArrayLike) \
51 : V(ConstructTrampoline) \
52 : V(TransitionElementsKind) \
53 : V(AllocateHeapNumber) \
54 : V(Builtin) \
55 : V(ArrayConstructor) \
56 : V(IteratingArrayBuiltin) \
57 : V(ArrayNoArgumentConstructor) \
58 : V(ArraySingleArgumentConstructor) \
59 : V(ArrayNArgumentsConstructor) \
60 : V(Compare) \
61 : V(BinaryOp) \
62 : V(StringAdd) \
63 : V(StringCharAt) \
64 : V(StringCharCodeAt) \
65 : V(StringCompare) \
66 : V(ForInPrepare) \
67 : V(GetProperty) \
68 : V(ArgumentAdaptor) \
69 : V(ApiCallback) \
70 : V(ApiGetter) \
71 : V(MathPowTagged) \
72 : V(MathPowInteger) \
73 : V(GrowArrayElements) \
74 : V(NewArgumentsElements) \
75 : V(InterpreterDispatch) \
76 : V(InterpreterPushArgsThenCall) \
77 : V(InterpreterPushArgsThenConstruct) \
78 : V(InterpreterCEntry) \
79 : V(ResumeGenerator) \
80 : V(FrameDropperTrampoline) \
81 : V(WasmRuntimeCall) \
82 : BUILTIN_LIST_TFS(V)
83 :
84 11526840 : class V8_EXPORT_PRIVATE CallInterfaceDescriptorData {
85 : public:
86 : CallInterfaceDescriptorData()
87 : : register_param_count_(-1),
88 : param_count_(-1),
89 5939863 : allocatable_registers_(0) {}
90 :
91 : // A copy of the passed in registers and param_representations is made
92 : // and owned by the CallInterfaceDescriptorData.
93 :
94 : void InitializePlatformSpecific(
95 : int register_parameter_count, const Register* registers,
96 : PlatformInterfaceDescriptor* platform_descriptor = nullptr);
97 :
98 : // if machine_types is null, then an array of size
99 : // (parameter_count + extra_parameter_count) will be created with
100 : // MachineType::AnyTagged() for each member.
101 : //
102 : // if machine_types is not null, then it should be of the size
103 : // parameter_count. Those members of the parameter array will be initialized
104 : // from {machine_types}, and the rest initialized to MachineType::AnyTagged().
105 : void InitializePlatformIndependent(int parameter_count,
106 : int extra_parameter_count,
107 : const MachineType* machine_types);
108 :
109 : bool IsInitialized() const {
110 6924994 : return register_param_count_ >= 0 && param_count_ >= 0;
111 : }
112 :
113 : int param_count() const { return param_count_; }
114 : int register_param_count() const { return register_param_count_; }
115 16343176 : Register register_param(int index) const { return register_params_[index]; }
116 : Register* register_params() const { return register_params_.get(); }
117 7368800 : MachineType param_type(int index) const { return machine_types_[index]; }
118 : PlatformInterfaceDescriptor* platform_specific_descriptor() const {
119 : return platform_specific_descriptor_;
120 : }
121 :
122 : void RestrictAllocatableRegisters(const Register* registers, int num) {
123 : DCHECK_EQ(allocatable_registers_, 0);
124 274995 : for (int i = 0; i < num; ++i) {
125 549990 : allocatable_registers_ |= registers[i].bit();
126 : }
127 : DCHECK_GT(NumRegs(allocatable_registers_), 0);
128 : }
129 :
130 : RegList allocatable_registers() const { return allocatable_registers_; }
131 :
132 : private:
133 : int register_param_count_;
134 : int param_count_;
135 :
136 : // Specifying the set of registers that could be used by the register
137 : // allocator. Currently, it's only used by RecordWrite code stub.
138 : RegList allocatable_registers_;
139 :
140 : // The Register params are allocated dynamically by the
141 : // InterfaceDescriptor, and freed on destruction. This is because static
142 : // arrays of Registers cause creation of runtime static initializers
143 : // which we don't want.
144 : std::unique_ptr<Register[]> register_params_;
145 : std::unique_ptr<MachineType[]> machine_types_;
146 :
147 : PlatformInterfaceDescriptor* platform_specific_descriptor_;
148 :
149 : DISALLOW_COPY_AND_ASSIGN(CallInterfaceDescriptorData);
150 : };
151 :
152 :
153 : class CallDescriptors {
154 : public:
155 : enum Key {
156 : #define DEF_ENUM(name, ...) name,
157 : INTERFACE_DESCRIPTOR_LIST(DEF_ENUM)
158 : #undef DEF_ENUM
159 : NUMBER_OF_DESCRIPTORS
160 : };
161 : };
162 :
163 10601679 : class V8_EXPORT_PRIVATE CallInterfaceDescriptor {
164 : public:
165 0 : CallInterfaceDescriptor() : data_(nullptr) {}
166 6676935 : virtual ~CallInterfaceDescriptor() {}
167 :
168 : CallInterfaceDescriptor(Isolate* isolate, CallDescriptors::Key key)
169 14976719 : : data_(isolate->call_descriptor_data(key)) {}
170 :
171 20570 : int GetParameterCount() const { return data()->param_count(); }
172 :
173 2779409 : int GetRegisterParameterCount() const {
174 2782963 : return data()->register_param_count();
175 : }
176 :
177 64085 : int GetStackParameterCount() const {
178 1945161 : return data()->param_count() - data()->register_param_count();
179 : }
180 :
181 7368032 : Register GetRegisterParameter(int index) const {
182 : return data()->register_param(index);
183 : }
184 :
185 : MachineType GetParameterType(int index) const {
186 : DCHECK(index < data()->param_count());
187 : return data()->param_type(index);
188 : }
189 :
190 : // Some platforms have extra information to associate with the descriptor.
191 : PlatformInterfaceDescriptor* platform_specific_descriptor() const {
192 : return data()->platform_specific_descriptor();
193 : }
194 :
195 2715720 : RegList allocatable_registers() const {
196 3036912 : return data()->allocatable_registers();
197 : }
198 :
199 : static const Register ContextRegister();
200 :
201 : const char* DebugName(Isolate* isolate) const;
202 :
203 : protected:
204 : const CallInterfaceDescriptorData* data() const { return data_; }
205 :
206 0 : virtual void InitializePlatformSpecific(CallInterfaceDescriptorData* data) {
207 0 : UNREACHABLE();
208 : }
209 :
210 1044981 : virtual void InitializePlatformIndependent(
211 1044981 : CallInterfaceDescriptorData* data) {
212 : data->InitializePlatformIndependent(data->register_param_count(), 0,
213 1044981 : nullptr);
214 1044981 : }
215 :
216 6924994 : void Initialize(Isolate* isolate, CallDescriptors::Key key) {
217 13849988 : if (!data()->IsInitialized()) {
218 : // We should only initialize descriptors on the isolate's main thread.
219 : DCHECK(ThreadId::Current().Equals(isolate->thread_id()));
220 5939888 : CallInterfaceDescriptorData* d = isolate->call_descriptor_data(key);
221 : DCHECK(d == data()); // d should be a modifiable pointer to data().
222 5939888 : InitializePlatformSpecific(d);
223 5939888 : InitializePlatformIndependent(d);
224 : }
225 6924992 : }
226 :
227 : // Initializes |data| using the platform dependent default set of registers.
228 : // It is intended to be used for TurboFan stubs when particular set of
229 : // registers does not matter.
230 : static void DefaultInitializePlatformSpecific(
231 : CallInterfaceDescriptorData* data, int register_parameter_count);
232 :
233 : private:
234 : const CallInterfaceDescriptorData* data_;
235 : };
236 :
237 : #define DECLARE_DESCRIPTOR_WITH_BASE(name, base) \
238 : public: \
239 : explicit name(Isolate* isolate) : base(isolate, key()) { \
240 : Initialize(isolate, key()); \
241 : } \
242 : static inline CallDescriptors::Key key();
243 :
244 : static const int kMaxBuiltinRegisterParams = 5;
245 :
246 : #define DECLARE_DEFAULT_DESCRIPTOR(name, base, parameter_count) \
247 : DECLARE_DESCRIPTOR_WITH_BASE(name, base) \
248 : protected: \
249 : static const int kRegisterParams = \
250 : parameter_count > kMaxBuiltinRegisterParams ? kMaxBuiltinRegisterParams \
251 : : parameter_count; \
252 : static const int kStackParams = parameter_count - kRegisterParams; \
253 : void InitializePlatformSpecific(CallInterfaceDescriptorData* data) \
254 : override { \
255 : DefaultInitializePlatformSpecific(data, kRegisterParams); \
256 : } \
257 : void InitializePlatformIndependent(CallInterfaceDescriptorData* data) \
258 : override { \
259 : data->InitializePlatformIndependent(kRegisterParams, kStackParams, \
260 : nullptr); \
261 : } \
262 : name(Isolate* isolate, CallDescriptors::Key key) : base(isolate, key) {} \
263 : \
264 : public:
265 :
266 : #define DECLARE_DESCRIPTOR(name, base) \
267 : DECLARE_DESCRIPTOR_WITH_BASE(name, base) \
268 : protected: \
269 : void InitializePlatformSpecific(CallInterfaceDescriptorData* data) override; \
270 : name(Isolate* isolate, CallDescriptors::Key key) : base(isolate, key) {} \
271 : \
272 : public:
273 :
274 : #define DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(name, base) \
275 : DECLARE_DESCRIPTOR(name, base) \
276 : protected: \
277 : void InitializePlatformIndependent(CallInterfaceDescriptorData* data) \
278 : override; \
279 : \
280 : public:
281 :
282 : #define DECLARE_DESCRIPTOR_WITH_STACK_ARGS(name, base) \
283 : DECLARE_DESCRIPTOR_WITH_BASE(name, base) \
284 : protected: \
285 : void InitializePlatformIndependent(CallInterfaceDescriptorData* data) \
286 : override { \
287 : data->InitializePlatformIndependent(0, kParameterCount, nullptr); \
288 : } \
289 : void InitializePlatformSpecific(CallInterfaceDescriptorData* data) \
290 : override { \
291 : data->InitializePlatformSpecific(0, nullptr); \
292 : } \
293 : \
294 : public:
295 :
296 : #define DEFINE_EMPTY_PARAMETERS() \
297 : enum ParameterIndices { \
298 : kParameterCount, \
299 : kContext = kParameterCount /* implicit parameter */ \
300 : };
301 :
302 : #define DEFINE_PARAMETERS(...) \
303 : enum ParameterIndices { \
304 : __VA_ARGS__, \
305 : \
306 : kParameterCount, \
307 : kContext = kParameterCount /* implicit parameter */ \
308 : };
309 :
310 : #define DECLARE_BUILTIN_DESCRIPTOR(name) \
311 : DECLARE_DESCRIPTOR_WITH_BASE(name, BuiltinDescriptor) \
312 : protected: \
313 : void InitializePlatformIndependent(CallInterfaceDescriptorData* data) \
314 : override { \
315 : MachineType machine_types[] = {MachineType::AnyTagged(), \
316 : MachineType::AnyTagged(), \
317 : MachineType::Int32()}; \
318 : data->InitializePlatformIndependent(arraysize(machine_types), \
319 : kStackParameterCount, machine_types); \
320 : } \
321 : void InitializePlatformSpecific(CallInterfaceDescriptorData* data) \
322 : override { \
323 : Register registers[] = {TargetRegister(), NewTargetRegister(), \
324 : ArgumentsCountRegister()}; \
325 : data->InitializePlatformSpecific(arraysize(registers), registers); \
326 : } \
327 : \
328 : public:
329 :
330 : #define DEFINE_BUILTIN_PARAMETERS(...) \
331 : enum ParameterIndices { \
332 : kReceiver, \
333 : kBeforeFirstStackParameter = kReceiver, \
334 : __VA_ARGS__, \
335 : kAfterLastStackParameter, \
336 : kNewTarget = kAfterLastStackParameter, \
337 : kArgumentsCount, \
338 : kContext, /* implicit parameter */ \
339 : kParameterCount = kContext, \
340 : kArity = kAfterLastStackParameter - kBeforeFirstStackParameter - 1, \
341 : kStackParameterCount = kArity + 1 \
342 : };
343 :
344 54999 : class V8_EXPORT_PRIVATE VoidDescriptor : public CallInterfaceDescriptor {
345 : public:
346 55275 : DECLARE_DESCRIPTOR(VoidDescriptor, CallInterfaceDescriptor)
347 : };
348 :
349 54999 : class ContextOnlyDescriptor : public CallInterfaceDescriptor {
350 : public:
351 56413 : DECLARE_DESCRIPTOR(ContextOnlyDescriptor, CallInterfaceDescriptor)
352 : };
353 :
354 : // LoadDescriptor is used by all stubs that implement Load/KeyedLoad ICs.
355 166206 : class LoadDescriptor : public CallInterfaceDescriptor {
356 : public:
357 : DEFINE_PARAMETERS(kReceiver, kName, kSlot)
358 184734 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(LoadDescriptor,
359 : CallInterfaceDescriptor)
360 :
361 : static const Register ReceiverRegister();
362 : static const Register NameRegister();
363 : static const Register SlotRegister();
364 : };
365 :
366 : // LoadFieldDescriptor is used by the shared handler that loads a field from an
367 : // object based on the smi-encoded field description.
368 55030 : class LoadFieldDescriptor : public CallInterfaceDescriptor {
369 : public:
370 : DEFINE_PARAMETERS(kReceiver, kSmiHandler)
371 55061 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(LoadFieldDescriptor,
372 : CallInterfaceDescriptor)
373 :
374 : static const Register ReceiverRegister();
375 : static const Register SmiHandlerRegister();
376 : };
377 :
378 110184 : class LoadGlobalDescriptor : public CallInterfaceDescriptor {
379 : public:
380 : DEFINE_PARAMETERS(kName, kSlot)
381 307380 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(LoadGlobalDescriptor,
382 : CallInterfaceDescriptor)
383 :
384 : static const Register NameRegister() {
385 109998 : return LoadDescriptor::NameRegister();
386 : }
387 :
388 : static const Register SlotRegister() {
389 109998 : return LoadDescriptor::SlotRegister();
390 : }
391 : };
392 :
393 220492 : class StoreDescriptor : public CallInterfaceDescriptor {
394 : public:
395 : DEFINE_PARAMETERS(kReceiver, kName, kValue, kSlot)
396 614998 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(StoreDescriptor,
397 : CallInterfaceDescriptor)
398 :
399 : static const Register ReceiverRegister();
400 : static const Register NameRegister();
401 : static const Register ValueRegister();
402 : static const Register SlotRegister();
403 :
404 : #if V8_TARGET_ARCH_IA32
405 : static const bool kPassLastArgsOnStack = true;
406 : #else
407 : static const bool kPassLastArgsOnStack = false;
408 : #endif
409 :
410 : // Pass value and slot through the stack.
411 : static const int kStackArgumentsCount = kPassLastArgsOnStack ? 2 : 0;
412 : };
413 :
414 110029 : class StoreTransitionDescriptor : public StoreDescriptor {
415 : public:
416 : DEFINE_PARAMETERS(kReceiver, kName, kMap, kValue, kSlot, kVector)
417 111820 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(StoreTransitionDescriptor,
418 : StoreDescriptor)
419 :
420 : static const Register MapRegister();
421 : static const Register SlotRegister();
422 : static const Register VectorRegister();
423 :
424 : // Pass value, slot and vector through the stack.
425 : static const int kStackArgumentsCount = kPassLastArgsOnStack ? 3 : 0;
426 : };
427 :
428 54999 : class StoreNamedTransitionDescriptor : public StoreTransitionDescriptor {
429 : public:
430 : DEFINE_PARAMETERS(kReceiver, kFieldOffset, kMap, kValue, kSlot, kVector,
431 : kName)
432 54999 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(StoreNamedTransitionDescriptor,
433 : StoreTransitionDescriptor)
434 :
435 : // Always pass name on the stack.
436 : static const bool kPassLastArgsOnStack = true;
437 : static const int kStackArgumentsCount =
438 : StoreTransitionDescriptor::kStackArgumentsCount + 1;
439 :
440 : static const Register NameRegister() { return no_reg; }
441 : static const Register FieldOffsetRegister() {
442 54999 : return StoreTransitionDescriptor::NameRegister();
443 : }
444 : };
445 :
446 55402 : class StoreWithVectorDescriptor : public StoreDescriptor {
447 : public:
448 : DEFINE_PARAMETERS(kReceiver, kName, kValue, kSlot, kVector)
449 65709 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(StoreWithVectorDescriptor,
450 : StoreDescriptor)
451 :
452 : static const Register VectorRegister();
453 :
454 : // Pass value, slot and vector through the stack.
455 : static const int kStackArgumentsCount = kPassLastArgsOnStack ? 3 : 0;
456 : };
457 :
458 111145 : class LoadWithVectorDescriptor : public LoadDescriptor {
459 : public:
460 : DEFINE_PARAMETERS(kReceiver, kName, kSlot, kVector)
461 148480 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(LoadWithVectorDescriptor,
462 : LoadDescriptor)
463 :
464 : static const Register VectorRegister();
465 : };
466 :
467 55061 : class LoadICProtoArrayDescriptor : public LoadWithVectorDescriptor {
468 : public:
469 : DEFINE_PARAMETERS(kReceiver, kName, kSlot, kVector, kHandler)
470 56487 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(LoadICProtoArrayDescriptor,
471 : LoadWithVectorDescriptor)
472 :
473 : static const Register HandlerRegister();
474 : };
475 :
476 55123 : class LoadGlobalWithVectorDescriptor : public LoadGlobalDescriptor {
477 : public:
478 : DEFINE_PARAMETERS(kName, kSlot, kVector)
479 55499 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(LoadGlobalWithVectorDescriptor,
480 : LoadGlobalDescriptor)
481 :
482 : static const Register VectorRegister() {
483 54999 : return LoadWithVectorDescriptor::VectorRegister();
484 : }
485 : };
486 :
487 55030 : class FastNewClosureDescriptor : public CallInterfaceDescriptor {
488 : public:
489 : DEFINE_PARAMETERS(kSharedFunctionInfo, kVector, kSlot)
490 55061 : DECLARE_DESCRIPTOR(FastNewClosureDescriptor, CallInterfaceDescriptor)
491 : };
492 :
493 55061 : class FastNewFunctionContextDescriptor : public CallInterfaceDescriptor {
494 : public:
495 : DEFINE_PARAMETERS(kFunction, kSlots)
496 66105 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(FastNewFunctionContextDescriptor,
497 : CallInterfaceDescriptor)
498 :
499 : static const Register FunctionRegister();
500 : static const Register SlotsRegister();
501 : };
502 :
503 55030 : class FastNewObjectDescriptor : public CallInterfaceDescriptor {
504 : public:
505 : DEFINE_PARAMETERS(kTarget, kNewTarget)
506 55061 : DECLARE_DESCRIPTOR(FastNewObjectDescriptor, CallInterfaceDescriptor)
507 : static const Register TargetRegister();
508 : static const Register NewTargetRegister();
509 : };
510 :
511 54999 : class FastNewArgumentsDescriptor : public CallInterfaceDescriptor {
512 : public:
513 : DEFINE_PARAMETERS(kFunction)
514 54999 : DECLARE_DESCRIPTOR(FastNewArgumentsDescriptor, CallInterfaceDescriptor)
515 : static const Register TargetRegister();
516 : };
517 :
518 55030 : class RecordWriteDescriptor final : public CallInterfaceDescriptor {
519 : public:
520 : DEFINE_PARAMETERS(kObject, kSlot, kIsolate, kRememberedSet, kFPMode)
521 55061 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(RecordWriteDescriptor,
522 : CallInterfaceDescriptor)
523 : };
524 :
525 55464 : class TypeConversionDescriptor final : public CallInterfaceDescriptor {
526 : public:
527 : DEFINE_PARAMETERS(kArgument)
528 63505 : DECLARE_DESCRIPTOR(TypeConversionDescriptor, CallInterfaceDescriptor)
529 :
530 : static const Register ArgumentRegister();
531 : };
532 :
533 55030 : class TypeConversionStackParameterDescriptor final
534 : : public CallInterfaceDescriptor {
535 : public:
536 : DEFINE_PARAMETERS(kArgument)
537 55061 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(
538 : TypeConversionStackParameterDescriptor, CallInterfaceDescriptor)
539 : };
540 :
541 54999 : class ForInPrepareDescriptor final : public CallInterfaceDescriptor {
542 : public:
543 : DEFINE_PARAMETERS(kObject)
544 164997 : DECLARE_DEFAULT_DESCRIPTOR(ForInPrepareDescriptor, CallInterfaceDescriptor,
545 : kParameterCount)
546 : };
547 :
548 54999 : class GetPropertyDescriptor final : public CallInterfaceDescriptor {
549 : public:
550 : DEFINE_PARAMETERS(kObject, kKey)
551 172263 : DECLARE_DEFAULT_DESCRIPTOR(GetPropertyDescriptor, CallInterfaceDescriptor,
552 : kParameterCount)
553 : };
554 :
555 55092 : class TypeofDescriptor : public CallInterfaceDescriptor {
556 : public:
557 : DEFINE_PARAMETERS(kObject)
558 55185 : DECLARE_DESCRIPTOR(TypeofDescriptor, CallInterfaceDescriptor)
559 : };
560 :
561 55154 : class CallTrampolineDescriptor : public CallInterfaceDescriptor {
562 : public:
563 : DEFINE_PARAMETERS(kFunction, kActualArgumentsCount)
564 691710 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(CallTrampolineDescriptor,
565 : CallInterfaceDescriptor)
566 : };
567 :
568 54999 : class CallVarargsDescriptor : public CallInterfaceDescriptor {
569 : public:
570 : DEFINE_PARAMETERS(kTarget, kActualArgumentsCount, kArgumentsList,
571 : kArgumentsLength)
572 55247 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(CallVarargsDescriptor,
573 : CallInterfaceDescriptor)
574 : };
575 :
576 54999 : class CallForwardVarargsDescriptor : public CallInterfaceDescriptor {
577 : public:
578 : DEFINE_PARAMETERS(kTarget, kActualArgumentsCount, kStartIndex)
579 55783 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(CallForwardVarargsDescriptor,
580 : CallInterfaceDescriptor)
581 : };
582 :
583 55030 : class CallWithSpreadDescriptor : public CallInterfaceDescriptor {
584 : public:
585 : DEFINE_PARAMETERS(kTarget, kArgumentsCount, kSpread)
586 56729 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(CallWithSpreadDescriptor,
587 : CallInterfaceDescriptor)
588 : };
589 :
590 55030 : class CallWithArrayLikeDescriptor : public CallInterfaceDescriptor {
591 : public:
592 : DEFINE_PARAMETERS(kTarget, kArgumentsList)
593 55659 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(CallWithArrayLikeDescriptor,
594 : CallInterfaceDescriptor)
595 : };
596 :
597 54999 : class ConstructVarargsDescriptor : public CallInterfaceDescriptor {
598 : public:
599 : DEFINE_PARAMETERS(kTarget, kNewTarget, kActualArgumentsCount, kArgumentsList,
600 : kArgumentsLength)
601 55247 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(ConstructVarargsDescriptor,
602 : CallInterfaceDescriptor)
603 : };
604 :
605 54999 : class ConstructForwardVarargsDescriptor : public CallInterfaceDescriptor {
606 : public:
607 : DEFINE_PARAMETERS(kTarget, kNewTarget, kActualArgumentsCount, kStartIndex)
608 55905 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(
609 : ConstructForwardVarargsDescriptor, CallInterfaceDescriptor)
610 : };
611 :
612 55030 : class ConstructWithSpreadDescriptor : public CallInterfaceDescriptor {
613 : public:
614 : DEFINE_PARAMETERS(kTarget, kNewTarget, kArgumentsCount, kSpread)
615 55155 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(ConstructWithSpreadDescriptor,
616 : CallInterfaceDescriptor)
617 : };
618 :
619 55030 : class ConstructWithArrayLikeDescriptor : public CallInterfaceDescriptor {
620 : public:
621 : DEFINE_PARAMETERS(kTarget, kNewTarget, kArgumentsList)
622 55061 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(ConstructWithArrayLikeDescriptor,
623 : CallInterfaceDescriptor)
624 : };
625 :
626 69305 : class ConstructStubDescriptor : public CallInterfaceDescriptor {
627 : public:
628 : DEFINE_PARAMETERS(kFunction, kNewTarget, kActualArgumentsCount,
629 : kAllocationSite)
630 83611 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(ConstructStubDescriptor,
631 : CallInterfaceDescriptor)
632 : };
633 :
634 :
635 55030 : class ConstructTrampolineDescriptor : public CallInterfaceDescriptor {
636 : public:
637 : DEFINE_PARAMETERS(kFunction, kNewTarget, kActualArgumentsCount)
638 78329 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(ConstructTrampolineDescriptor,
639 : CallInterfaceDescriptor)
640 : };
641 :
642 :
643 54999 : class CallFunctionDescriptor : public CallInterfaceDescriptor {
644 : public:
645 54999 : DECLARE_DESCRIPTOR(CallFunctionDescriptor, CallInterfaceDescriptor)
646 : };
647 :
648 54999 : class TransitionElementsKindDescriptor : public CallInterfaceDescriptor {
649 : public:
650 : DEFINE_PARAMETERS(kObject, kMap)
651 55185 : DECLARE_DESCRIPTOR(TransitionElementsKindDescriptor, CallInterfaceDescriptor)
652 : };
653 :
654 :
655 55030 : class AllocateHeapNumberDescriptor : public CallInterfaceDescriptor {
656 : public:
657 : DEFINE_EMPTY_PARAMETERS()
658 55061 : DECLARE_DESCRIPTOR(AllocateHeapNumberDescriptor, CallInterfaceDescriptor)
659 : };
660 :
661 109998 : class BuiltinDescriptor : public CallInterfaceDescriptor {
662 : public:
663 : // TODO(ishell): Where is kFunction??
664 : DEFINE_PARAMETERS(kNewTarget, kArgumentsCount)
665 115472 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(BuiltinDescriptor,
666 : CallInterfaceDescriptor)
667 : static const Register ArgumentsCountRegister();
668 : static const Register NewTargetRegister();
669 : static const Register TargetRegister();
670 : };
671 :
672 54999 : class IteratingArrayBuiltinDescriptor : public BuiltinDescriptor {
673 : public:
674 : DEFINE_BUILTIN_PARAMETERS(kCallback, kThisArg)
675 164997 : DECLARE_BUILTIN_DESCRIPTOR(IteratingArrayBuiltinDescriptor)
676 : };
677 :
678 54999 : class ArrayConstructorDescriptor : public CallInterfaceDescriptor {
679 : public:
680 : DEFINE_PARAMETERS(kTarget, kNewTarget, kActualArgumentsCount, kAllocationSite)
681 55043 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(ArrayConstructorDescriptor,
682 : CallInterfaceDescriptor)
683 : };
684 :
685 54999 : class ArrayNoArgumentConstructorDescriptor : public CallInterfaceDescriptor {
686 : public:
687 : DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount,
688 : kFunctionParameter)
689 55619 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(
690 : ArrayNoArgumentConstructorDescriptor, CallInterfaceDescriptor)
691 : };
692 :
693 54999 : class ArraySingleArgumentConstructorDescriptor
694 : : public CallInterfaceDescriptor {
695 : public:
696 : DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount,
697 : kFunctionParameter, kArraySizeSmiParameter)
698 55809 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(
699 : ArraySingleArgumentConstructorDescriptor, CallInterfaceDescriptor)
700 : };
701 :
702 54999 : class ArrayNArgumentsConstructorDescriptor : public CallInterfaceDescriptor {
703 : public:
704 : DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount)
705 54999 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(
706 : ArrayNArgumentsConstructorDescriptor, CallInterfaceDescriptor)
707 : };
708 :
709 55402 : class CompareDescriptor : public CallInterfaceDescriptor {
710 : public:
711 : DEFINE_PARAMETERS(kLeft, kRight)
712 55805 : DECLARE_DESCRIPTOR(CompareDescriptor, CallInterfaceDescriptor)
713 : };
714 :
715 :
716 55340 : class BinaryOpDescriptor : public CallInterfaceDescriptor {
717 : public:
718 : DEFINE_PARAMETERS(kLeft, kRight)
719 55681 : DECLARE_DESCRIPTOR(BinaryOpDescriptor, CallInterfaceDescriptor)
720 : };
721 :
722 :
723 54999 : class StringAddDescriptor : public CallInterfaceDescriptor {
724 : public:
725 : DEFINE_PARAMETERS(kLeft, kRight)
726 152675 : DECLARE_DESCRIPTOR(StringAddDescriptor, CallInterfaceDescriptor)
727 : };
728 :
729 55030 : class StringCharAtDescriptor final : public CallInterfaceDescriptor {
730 : public:
731 : DEFINE_PARAMETERS(kReceiver, kPosition)
732 55061 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(StringCharAtDescriptor,
733 : CallInterfaceDescriptor)
734 : };
735 :
736 55030 : class StringCharCodeAtDescriptor final : public CallInterfaceDescriptor {
737 : public:
738 : DEFINE_PARAMETERS(kReceiver, kPosition)
739 55061 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(StringCharCodeAtDescriptor,
740 : CallInterfaceDescriptor)
741 : };
742 :
743 54999 : class StringCompareDescriptor : public CallInterfaceDescriptor {
744 : public:
745 : DEFINE_PARAMETERS(kLeft, kRight)
746 54999 : DECLARE_DESCRIPTOR(StringCompareDescriptor, CallInterfaceDescriptor)
747 :
748 : static const Register LeftRegister();
749 : static const Register RightRegister();
750 : };
751 :
752 54999 : class ArgumentAdaptorDescriptor : public CallInterfaceDescriptor {
753 : public:
754 : DEFINE_PARAMETERS(kFunction, kNewTarget, kActualArgumentsCount,
755 : kExpectedArgumentsCount)
756 151765 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(ArgumentAdaptorDescriptor,
757 : CallInterfaceDescriptor)
758 : };
759 :
760 54999 : class ApiCallbackDescriptor : public CallInterfaceDescriptor {
761 : public:
762 : DEFINE_PARAMETERS(kFunction, kCallData, kHolder, kApiFunctionAddress)
763 77251 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(ApiCallbackDescriptor,
764 : CallInterfaceDescriptor)
765 : };
766 :
767 54999 : class ApiGetterDescriptor : public CallInterfaceDescriptor {
768 : public:
769 : DEFINE_PARAMETERS(kReceiver, kHolder, kCallback)
770 57355 : DECLARE_DESCRIPTOR(ApiGetterDescriptor, CallInterfaceDescriptor)
771 :
772 : static const Register ReceiverRegister();
773 : static const Register HolderRegister();
774 : static const Register CallbackRegister();
775 : };
776 :
777 54999 : class MathPowTaggedDescriptor : public CallInterfaceDescriptor {
778 : public:
779 : DEFINE_PARAMETERS(kExponent)
780 54999 : DECLARE_DESCRIPTOR(MathPowTaggedDescriptor, CallInterfaceDescriptor)
781 :
782 : static const Register exponent();
783 : };
784 :
785 54999 : class MathPowIntegerDescriptor : public CallInterfaceDescriptor {
786 : public:
787 : DEFINE_PARAMETERS(kExponent)
788 54999 : DECLARE_DESCRIPTOR(MathPowIntegerDescriptor, CallInterfaceDescriptor)
789 :
790 : static const Register exponent();
791 : };
792 :
793 : // TODO(turbofan): We should probably rename this to GrowFastElementsDescriptor.
794 55061 : class GrowArrayElementsDescriptor : public CallInterfaceDescriptor {
795 : public:
796 : DEFINE_PARAMETERS(kObject, kKey)
797 55123 : DECLARE_DESCRIPTOR(GrowArrayElementsDescriptor, CallInterfaceDescriptor)
798 :
799 : static const Register ObjectRegister();
800 : static const Register KeyRegister();
801 : };
802 :
803 55030 : class NewArgumentsElementsDescriptor final : public CallInterfaceDescriptor {
804 : public:
805 : DEFINE_PARAMETERS(kFrame, kLength, kMappedCount)
806 55061 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(NewArgumentsElementsDescriptor,
807 : CallInterfaceDescriptor)
808 : };
809 :
810 68887 : class V8_EXPORT_PRIVATE InterpreterDispatchDescriptor
811 : : public CallInterfaceDescriptor {
812 : public:
813 : DEFINE_PARAMETERS(kAccumulator, kBytecodeOffset, kBytecodeArray,
814 : kDispatchTable)
815 119803 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(InterpreterDispatchDescriptor,
816 : CallInterfaceDescriptor)
817 : };
818 :
819 54999 : class InterpreterPushArgsThenCallDescriptor : public CallInterfaceDescriptor {
820 : public:
821 : DEFINE_PARAMETERS(kNumberOfArguments, kFirstArgument, kFunction)
822 56115 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(
823 : InterpreterPushArgsThenCallDescriptor, CallInterfaceDescriptor)
824 : };
825 :
826 54999 : class InterpreterPushArgsThenConstructDescriptor
827 : : public CallInterfaceDescriptor {
828 : public:
829 : DEFINE_PARAMETERS(kNumberOfArguments, kNewTarget, kConstructor,
830 : kFeedbackElement, kFirstArgument)
831 55557 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(
832 : InterpreterPushArgsThenConstructDescriptor, CallInterfaceDescriptor)
833 : };
834 :
835 54999 : class InterpreterCEntryDescriptor : public CallInterfaceDescriptor {
836 : public:
837 : DEFINE_PARAMETERS(kNumberOfArguments, kFirstArgument, kFunctionEntry)
838 55395 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(InterpreterCEntryDescriptor,
839 : CallInterfaceDescriptor)
840 : };
841 :
842 54999 : class ResumeGeneratorDescriptor final : public CallInterfaceDescriptor {
843 : public:
844 55557 : DECLARE_DESCRIPTOR(ResumeGeneratorDescriptor, CallInterfaceDescriptor)
845 : };
846 :
847 54999 : class FrameDropperTrampolineDescriptor final : public CallInterfaceDescriptor {
848 56301 : DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(FrameDropperTrampolineDescriptor,
849 : CallInterfaceDescriptor)
850 : };
851 :
852 211364 : class WasmRuntimeCallDescriptor final : public CallInterfaceDescriptor {
853 : public:
854 : DEFINE_EMPTY_PARAMETERS()
855 477672 : DECLARE_DEFAULT_DESCRIPTOR(WasmRuntimeCallDescriptor, CallInterfaceDescriptor,
856 : 0)
857 : };
858 :
859 : #define DEFINE_TFS_BUILTIN_DESCRIPTOR(Name, ...) \
860 : class Name##Descriptor : public CallInterfaceDescriptor { \
861 : public: \
862 : DEFINE_PARAMETERS(__VA_ARGS__) \
863 : DECLARE_DEFAULT_DESCRIPTOR(Name##Descriptor, CallInterfaceDescriptor, \
864 : kParameterCount) \
865 : };
866 7589862 : BUILTIN_LIST_TFS(DEFINE_TFS_BUILTIN_DESCRIPTOR)
867 : #undef DEFINE_TFS_BUILTIN_DESCRIPTOR
868 :
869 : #undef DECLARE_DEFAULT_DESCRIPTOR
870 : #undef DECLARE_DESCRIPTOR_WITH_BASE
871 : #undef DECLARE_DESCRIPTOR
872 : #undef DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE
873 : #undef DECLARE_DESCRIPTOR_WITH_BASE_AND_FUNCTION_TYPE_ARG
874 : #undef DEFINE_PARAMETERS
875 :
876 : // We define the association between CallDescriptors::Key and the specialized
877 : // descriptor here to reduce boilerplate and mistakes.
878 : #define DEF_KEY(name, ...) \
879 : CallDescriptors::Key name##Descriptor::key() { return CallDescriptors::name; }
880 : INTERFACE_DESCRIPTOR_LIST(DEF_KEY)
881 : #undef DEF_KEY
882 : } // namespace internal
883 : } // namespace v8
884 :
885 :
886 : #if V8_TARGET_ARCH_ARM64
887 : #include "src/arm64/interface-descriptors-arm64.h"
888 : #elif V8_TARGET_ARCH_ARM
889 : #include "src/arm/interface-descriptors-arm.h"
890 : #endif
891 :
892 : #endif // V8_CALL_INTERFACE_DESCRIPTOR_H_
|
