1// Copyright 2012 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#include "src/interface-descriptors.h"
6
7namespace v8 {
8namespace internal {
9
10
11void CallInterfaceDescriptorData::InitializePlatformSpecific(
12    int register_parameter_count, const Register* registers,
13    PlatformInterfaceDescriptor* platform_descriptor) {
14  platform_specific_descriptor_ = platform_descriptor;
15  register_param_count_ = register_parameter_count;
16
17  // InterfaceDescriptor owns a copy of the registers array.
18  register_params_.reset(NewArray<Register>(register_parameter_count));
19  for (int i = 0; i < register_parameter_count; i++) {
20    register_params_[i] = registers[i];
21  }
22}
23
24void CallInterfaceDescriptorData::InitializePlatformIndependent(
25    int parameter_count, int extra_parameter_count,
26    const MachineType* machine_types) {
27  // InterfaceDescriptor owns a copy of the MachineType array.
28  // We only care about parameters, not receiver and result.
29  param_count_ = parameter_count + extra_parameter_count;
30  machine_types_.reset(NewArray<MachineType>(param_count_));
31  for (int i = 0; i < param_count_; i++) {
32    if (machine_types == NULL || i >= parameter_count) {
33      machine_types_[i] = MachineType::AnyTagged();
34    } else {
35      machine_types_[i] = machine_types[i];
36    }
37  }
38}
39
40const char* CallInterfaceDescriptor::DebugName(Isolate* isolate) const {
41  CallInterfaceDescriptorData* start = isolate->call_descriptor_data(0);
42  size_t index = data_ - start;
43  DCHECK(index < CallDescriptors::NUMBER_OF_DESCRIPTORS);
44  CallDescriptors::Key key = static_cast<CallDescriptors::Key>(index);
45  switch (key) {
46#define DEF_CASE(NAME)        \
47  case CallDescriptors::NAME: \
48    return #NAME " Descriptor";
49    INTERFACE_DESCRIPTOR_LIST(DEF_CASE)
50#undef DEF_CASE
51    case CallDescriptors::NUMBER_OF_DESCRIPTORS:
52      break;
53  }
54  return "";
55}
56
57
58void VoidDescriptor::InitializePlatformSpecific(
59    CallInterfaceDescriptorData* data) {
60  data->InitializePlatformSpecific(0, nullptr);
61}
62
63void FastNewFunctionContextDescriptor::InitializePlatformIndependent(
64    CallInterfaceDescriptorData* data) {
65  MachineType machine_types[] = {MachineType::AnyTagged(),
66                                 MachineType::Int32()};
67  data->InitializePlatformIndependent(arraysize(machine_types), 0,
68                                      machine_types);
69}
70
71void FastNewFunctionContextDescriptor::InitializePlatformSpecific(
72    CallInterfaceDescriptorData* data) {
73  Register registers[] = {FunctionRegister(), SlotsRegister()};
74  data->InitializePlatformSpecific(arraysize(registers), registers);
75}
76
77void FastNewObjectDescriptor::InitializePlatformSpecific(
78    CallInterfaceDescriptorData* data) {
79  Register registers[] = {TargetRegister(), NewTargetRegister()};
80  data->InitializePlatformSpecific(arraysize(registers), registers);
81}
82
83const Register FastNewObjectDescriptor::TargetRegister() {
84  return kJSFunctionRegister;
85}
86
87const Register FastNewObjectDescriptor::NewTargetRegister() {
88  return kJavaScriptCallNewTargetRegister;
89}
90
91void FastNewArgumentsDescriptor::InitializePlatformSpecific(
92    CallInterfaceDescriptorData* data) {
93  Register registers[] = {TargetRegister()};
94  data->InitializePlatformSpecific(arraysize(registers), registers);
95}
96
97const Register FastNewArgumentsDescriptor::TargetRegister() {
98  return kJSFunctionRegister;
99}
100
101void LoadDescriptor::InitializePlatformIndependent(
102    CallInterfaceDescriptorData* data) {
103  // kReceiver, kName, kSlot
104  MachineType machine_types[] = {MachineType::AnyTagged(),
105                                 MachineType::AnyTagged(),
106                                 MachineType::TaggedSigned()};
107  data->InitializePlatformIndependent(arraysize(machine_types), 0,
108                                      machine_types);
109}
110
111void LoadDescriptor::InitializePlatformSpecific(
112    CallInterfaceDescriptorData* data) {
113  Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister()};
114  data->InitializePlatformSpecific(arraysize(registers), registers);
115}
116
117void LoadFieldDescriptor::InitializePlatformIndependent(
118    CallInterfaceDescriptorData* data) {
119  // kReceiver, kSmiHandler
120  MachineType machine_types[] = {MachineType::AnyTagged(),
121                                 MachineType::AnyTagged()};
122  data->InitializePlatformIndependent(arraysize(machine_types), 0,
123                                      machine_types);
124}
125
126void LoadFieldDescriptor::InitializePlatformSpecific(
127    CallInterfaceDescriptorData* data) {
128  Register registers[] = {ReceiverRegister(), SmiHandlerRegister()};
129  data->InitializePlatformSpecific(arraysize(registers), registers);
130}
131
132void LoadGlobalDescriptor::InitializePlatformIndependent(
133    CallInterfaceDescriptorData* data) {
134  // kName, kSlot
135  MachineType machine_types[] = {MachineType::AnyTagged(),
136                                 MachineType::TaggedSigned()};
137  data->InitializePlatformIndependent(arraysize(machine_types), 0,
138                                      machine_types);
139}
140
141void LoadGlobalDescriptor::InitializePlatformSpecific(
142    CallInterfaceDescriptorData* data) {
143  Register registers[] = {NameRegister(), SlotRegister()};
144  data->InitializePlatformSpecific(arraysize(registers), registers);
145}
146
147void LoadGlobalWithVectorDescriptor::InitializePlatformIndependent(
148    CallInterfaceDescriptorData* data) {
149  // kName, kSlot, kVector
150  MachineType machine_types[] = {MachineType::AnyTagged(),
151                                 MachineType::TaggedSigned(),
152                                 MachineType::AnyTagged()};
153  data->InitializePlatformIndependent(arraysize(machine_types), 0,
154                                      machine_types);
155}
156
157void LoadGlobalWithVectorDescriptor::InitializePlatformSpecific(
158    CallInterfaceDescriptorData* data) {
159  Register registers[] = {NameRegister(), SlotRegister(), VectorRegister()};
160  data->InitializePlatformSpecific(arraysize(registers), registers);
161}
162
163void StoreDescriptor::InitializePlatformIndependent(
164    CallInterfaceDescriptorData* data) {
165  // kReceiver, kName, kValue, kSlot
166  MachineType machine_types[] = {
167      MachineType::AnyTagged(), MachineType::AnyTagged(),
168      MachineType::AnyTagged(), MachineType::TaggedSigned()};
169  data->InitializePlatformIndependent(arraysize(machine_types), 0,
170                                      machine_types);
171}
172
173void StoreDescriptor::InitializePlatformSpecific(
174    CallInterfaceDescriptorData* data) {
175  Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
176                          SlotRegister()};
177
178  int len = arraysize(registers) - kStackArgumentsCount;
179  data->InitializePlatformSpecific(len, registers);
180}
181
182void StoreTransitionDescriptor::InitializePlatformSpecific(
183    CallInterfaceDescriptorData* data) {
184  Register registers[] = {
185      ReceiverRegister(), NameRegister(), MapRegister(),
186      ValueRegister(),    SlotRegister(), VectorRegister(),
187  };
188  int len = arraysize(registers) - kStackArgumentsCount;
189  data->InitializePlatformSpecific(len, registers);
190}
191
192void StoreTransitionDescriptor::InitializePlatformIndependent(
193    CallInterfaceDescriptorData* data) {
194  // kReceiver, kName, kMap, kValue, kSlot, kVector
195  MachineType machine_types[] = {
196      MachineType::AnyTagged(),    MachineType::AnyTagged(),
197      MachineType::AnyTagged(),    MachineType::AnyTagged(),
198      MachineType::TaggedSigned(), MachineType::AnyTagged()};
199  data->InitializePlatformIndependent(arraysize(machine_types), 0,
200                                      machine_types);
201}
202
203void StoreNamedTransitionDescriptor::InitializePlatformIndependent(
204    CallInterfaceDescriptorData* data) {
205  // kReceiver, kFieldOffset, kMap, kValue, kSlot, kVector, kName
206  MachineType machine_types[] = {
207      MachineType::AnyTagged(),    MachineType::TaggedSigned(),
208      MachineType::AnyTagged(),    MachineType::AnyTagged(),
209      MachineType::TaggedSigned(), MachineType::AnyTagged(),
210      MachineType::AnyTagged()};
211  data->InitializePlatformIndependent(arraysize(machine_types), 0,
212                                      machine_types);
213}
214
215void StoreNamedTransitionDescriptor::InitializePlatformSpecific(
216    CallInterfaceDescriptorData* data) {
217  Register registers[] = {
218      ReceiverRegister(), FieldOffsetRegister(), MapRegister(),
219      ValueRegister(),    SlotRegister(),        VectorRegister(),
220      NameRegister(),
221  };
222  int len = arraysize(registers) - kStackArgumentsCount;
223  data->InitializePlatformSpecific(len, registers);
224}
225
226void StringCharAtDescriptor::InitializePlatformIndependent(
227    CallInterfaceDescriptorData* data) {
228  // kReceiver, kPosition
229  MachineType machine_types[] = {MachineType::AnyTagged(),
230                                 MachineType::IntPtr()};
231  data->InitializePlatformIndependent(arraysize(machine_types), 0,
232                                      machine_types);
233}
234
235void StringCharAtDescriptor::InitializePlatformSpecific(
236    CallInterfaceDescriptorData* data) {
237  DefaultInitializePlatformSpecific(data, kParameterCount);
238}
239
240void StringCharCodeAtDescriptor::InitializePlatformIndependent(
241    CallInterfaceDescriptorData* data) {
242  // kReceiver, kPosition
243  // TODO(turbofan): Allow builtins to return untagged values.
244  MachineType machine_types[] = {MachineType::AnyTagged(),
245                                 MachineType::IntPtr()};
246  data->InitializePlatformIndependent(arraysize(machine_types), 0,
247                                      machine_types);
248}
249
250void StringCharCodeAtDescriptor::InitializePlatformSpecific(
251    CallInterfaceDescriptorData* data) {
252  DefaultInitializePlatformSpecific(data, kParameterCount);
253}
254
255void StringCompareDescriptor::InitializePlatformSpecific(
256    CallInterfaceDescriptorData* data) {
257  Register registers[] = {LeftRegister(), RightRegister()};
258  data->InitializePlatformSpecific(arraysize(registers), registers);
259}
260
261void TypeConversionDescriptor::InitializePlatformSpecific(
262    CallInterfaceDescriptorData* data) {
263  Register registers[] = {ArgumentRegister()};
264  data->InitializePlatformSpecific(arraysize(registers), registers);
265}
266
267void MathPowTaggedDescriptor::InitializePlatformSpecific(
268    CallInterfaceDescriptorData* data) {
269  Register registers[] = {exponent()};
270  data->InitializePlatformSpecific(arraysize(registers), registers);
271}
272
273void MathPowIntegerDescriptor::InitializePlatformSpecific(
274    CallInterfaceDescriptorData* data) {
275  Register registers[] = {exponent()};
276  data->InitializePlatformSpecific(arraysize(registers), registers);
277}
278
279const Register LoadFieldDescriptor::ReceiverRegister() {
280  // Reuse the register from the LoadDescriptor, since given the
281  // LoadFieldDescriptor's usage, it doesn't matter exactly which registers are
282  // used to pass parameters in.
283  return LoadDescriptor::ReceiverRegister();
284}
285const Register LoadFieldDescriptor::SmiHandlerRegister() {
286  // Reuse the register from the LoadDescriptor, since given the
287  // LoadFieldDescriptor's usage, it doesn't matter exactly which registers are
288  // used to pass parameters in.
289  return LoadDescriptor::NameRegister();
290}
291
292void LoadWithVectorDescriptor::InitializePlatformIndependent(
293    CallInterfaceDescriptorData* data) {
294  // kReceiver, kName, kSlot, kVector
295  MachineType machine_types[] = {
296      MachineType::AnyTagged(), MachineType::AnyTagged(),
297      MachineType::TaggedSigned(), MachineType::AnyTagged()};
298  data->InitializePlatformIndependent(arraysize(machine_types), 0,
299                                      machine_types);
300}
301
302void LoadWithVectorDescriptor::InitializePlatformSpecific(
303    CallInterfaceDescriptorData* data) {
304  Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister(),
305                          VectorRegister()};
306  data->InitializePlatformSpecific(arraysize(registers), registers);
307}
308
309void LoadICProtoArrayDescriptor::InitializePlatformIndependent(
310    CallInterfaceDescriptorData* data) {
311  // kReceiver, kName, kSlot, kVector, kHandler
312  MachineType machine_types[] = {
313      MachineType::AnyTagged(), MachineType::AnyTagged(),
314      MachineType::TaggedSigned(), MachineType::AnyTagged(),
315      MachineType::AnyTagged()};
316  data->InitializePlatformIndependent(arraysize(machine_types), 0,
317                                      machine_types);
318}
319
320void LoadICProtoArrayDescriptor::InitializePlatformSpecific(
321    CallInterfaceDescriptorData* data) {
322  Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister(),
323                          VectorRegister(), HandlerRegister()};
324  data->InitializePlatformSpecific(arraysize(registers), registers);
325}
326
327void StoreWithVectorDescriptor::InitializePlatformIndependent(
328    CallInterfaceDescriptorData* data) {
329  // kReceiver, kName, kValue, kSlot, kVector
330  MachineType machine_types[] = {
331      MachineType::AnyTagged(), MachineType::AnyTagged(),
332      MachineType::AnyTagged(), MachineType::TaggedSigned(),
333      MachineType::AnyTagged()};
334  data->InitializePlatformIndependent(arraysize(machine_types), 0,
335                                      machine_types);
336}
337
338void StoreWithVectorDescriptor::InitializePlatformSpecific(
339    CallInterfaceDescriptorData* data) {
340  Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
341                          SlotRegister(), VectorRegister()};
342  int len = arraysize(registers) - kStackArgumentsCount;
343  data->InitializePlatformSpecific(len, registers);
344}
345
346void BinaryOpWithVectorDescriptor::InitializePlatformIndependent(
347    CallInterfaceDescriptorData* data) {
348  // kLeft, kRight, kSlot, kVector
349  MachineType machine_types[] = {MachineType::AnyTagged(),
350                                 MachineType::AnyTagged(), MachineType::Int32(),
351                                 MachineType::AnyTagged()};
352  data->InitializePlatformIndependent(arraysize(machine_types), 0,
353                                      machine_types);
354}
355
356const Register ApiGetterDescriptor::ReceiverRegister() {
357  return LoadDescriptor::ReceiverRegister();
358}
359
360void ApiGetterDescriptor::InitializePlatformSpecific(
361    CallInterfaceDescriptorData* data) {
362  Register registers[] = {ReceiverRegister(), HolderRegister(),
363                          CallbackRegister()};
364  data->InitializePlatformSpecific(arraysize(registers), registers);
365}
366
367void ContextOnlyDescriptor::InitializePlatformSpecific(
368    CallInterfaceDescriptorData* data) {
369  data->InitializePlatformSpecific(0, nullptr);
370}
371
372void GrowArrayElementsDescriptor::InitializePlatformSpecific(
373    CallInterfaceDescriptorData* data) {
374  Register registers[] = {ObjectRegister(), KeyRegister()};
375  data->InitializePlatformSpecific(arraysize(registers), registers);
376}
377
378void NewArgumentsElementsDescriptor::InitializePlatformIndependent(
379    CallInterfaceDescriptorData* data) {
380  MachineType const kMachineTypes[] = {MachineType::IntPtr()};
381  data->InitializePlatformIndependent(arraysize(kMachineTypes), 0,
382                                      kMachineTypes);
383}
384
385void NewArgumentsElementsDescriptor::InitializePlatformSpecific(
386    CallInterfaceDescriptorData* data) {
387  DefaultInitializePlatformSpecific(data, 1);
388}
389
390void VarArgFunctionDescriptor::InitializePlatformIndependent(
391    CallInterfaceDescriptorData* data) {
392  // kActualArgumentsCount
393  MachineType machine_types[] = {MachineType::Int32()};
394  data->InitializePlatformIndependent(arraysize(machine_types), 0,
395                                      machine_types);
396}
397
398void FastCloneRegExpDescriptor::InitializePlatformIndependent(
399    CallInterfaceDescriptorData* data) {
400  // kClosure, kLiteralIndex, kPattern, kFlags
401  MachineType machine_types[] = {
402      MachineType::AnyTagged(), MachineType::TaggedSigned(),
403      MachineType::AnyTagged(), MachineType::AnyTagged()};
404  data->InitializePlatformIndependent(arraysize(machine_types), 0,
405                                      machine_types);
406}
407
408void FastCloneShallowArrayDescriptor::InitializePlatformIndependent(
409    CallInterfaceDescriptorData* data) {
410  // kClosure, kLiteralIndex, kConstantElements
411  MachineType machine_types[] = {MachineType::AnyTagged(),
412                                 MachineType::TaggedSigned(),
413                                 MachineType::AnyTagged()};
414  data->InitializePlatformIndependent(arraysize(machine_types), 0,
415                                      machine_types);
416}
417
418void CreateAllocationSiteDescriptor::InitializePlatformIndependent(
419    CallInterfaceDescriptorData* data) {
420  // kVector, kSlot
421  MachineType machine_types[] = {MachineType::AnyTagged(),
422                                 MachineType::TaggedSigned()};
423  data->InitializePlatformIndependent(arraysize(machine_types), 0,
424                                      machine_types);
425}
426
427void CreateWeakCellDescriptor::InitializePlatformIndependent(
428    CallInterfaceDescriptorData* data) {
429  // kVector, kSlot, kValue
430  MachineType machine_types[] = {MachineType::AnyTagged(),
431                                 MachineType::TaggedSigned(),
432                                 MachineType::AnyTagged()};
433  data->InitializePlatformIndependent(arraysize(machine_types), 0,
434                                      machine_types);
435}
436
437void CallTrampolineDescriptor::InitializePlatformIndependent(
438    CallInterfaceDescriptorData* data) {
439  // kFunction, kActualArgumentsCount
440  MachineType machine_types[] = {MachineType::AnyTagged(),
441                                 MachineType::Int32()};
442  data->InitializePlatformIndependent(arraysize(machine_types), 0,
443                                      machine_types);
444}
445
446void CallForwardVarargsDescriptor::InitializePlatformIndependent(
447    CallInterfaceDescriptorData* data) {
448  // kTarget, kStartIndex
449  MachineType machine_types[] = {MachineType::AnyTagged(),
450                                 MachineType::Int32()};
451  data->InitializePlatformIndependent(arraysize(machine_types), 0,
452                                      machine_types);
453}
454
455void ConstructStubDescriptor::InitializePlatformIndependent(
456    CallInterfaceDescriptorData* data) {
457  // kFunction, kNewTarget, kActualArgumentsCount, kAllocationSite
458  MachineType machine_types[] = {MachineType::AnyTagged(),
459                                 MachineType::AnyTagged(), MachineType::Int32(),
460                                 MachineType::AnyTagged()};
461  data->InitializePlatformIndependent(arraysize(machine_types), 0,
462                                      machine_types);
463}
464
465void ConstructTrampolineDescriptor::InitializePlatformIndependent(
466    CallInterfaceDescriptorData* data) {
467  // kFunction, kNewTarget, kActualArgumentsCount
468  MachineType machine_types[] = {
469      MachineType::AnyTagged(), MachineType::AnyTagged(), MachineType::Int32()};
470  data->InitializePlatformIndependent(arraysize(machine_types), 0,
471                                      machine_types);
472}
473
474void CallICDescriptor::InitializePlatformIndependent(
475    CallInterfaceDescriptorData* data) {
476  // kTarget, kActualArgumentsCount, kSlot, kVector
477  MachineType machine_types[] = {MachineType::AnyTagged(), MachineType::Int32(),
478                                 MachineType::Int32(),
479                                 MachineType::AnyTagged()};
480  data->InitializePlatformIndependent(arraysize(machine_types), 0,
481                                      machine_types);
482}
483
484void CallICTrampolineDescriptor::InitializePlatformIndependent(
485    CallInterfaceDescriptorData* data) {
486  // kTarget, kActualArgumentsCount, kSlot
487  MachineType machine_types[] = {MachineType::AnyTagged(), MachineType::Int32(),
488                                 MachineType::Int32()};
489  data->InitializePlatformIndependent(arraysize(machine_types), 0,
490                                      machine_types);
491}
492
493void BuiltinDescriptor::InitializePlatformIndependent(
494    CallInterfaceDescriptorData* data) {
495  // kTarget, kNewTarget, kArgumentsCount
496  MachineType machine_types[] = {
497      MachineType::AnyTagged(), MachineType::AnyTagged(), MachineType::Int32()};
498  data->InitializePlatformIndependent(arraysize(machine_types), 0,
499                                      machine_types);
500}
501
502void BuiltinDescriptor::InitializePlatformSpecific(
503    CallInterfaceDescriptorData* data) {
504  Register registers[] = {TargetRegister(), NewTargetRegister(),
505                          ArgumentsCountRegister()};
506  data->InitializePlatformSpecific(arraysize(registers), registers);
507}
508
509const Register BuiltinDescriptor::ArgumentsCountRegister() {
510  return kJavaScriptCallArgCountRegister;
511}
512const Register BuiltinDescriptor::NewTargetRegister() {
513  return kJavaScriptCallNewTargetRegister;
514}
515
516const Register BuiltinDescriptor::TargetRegister() {
517  return kJSFunctionRegister;
518}
519
520void ArrayConstructorDescriptor::InitializePlatformIndependent(
521    CallInterfaceDescriptorData* data) {
522  // kTarget, kNewTarget, kActualArgumentsCount, kAllocationSite
523  MachineType machine_types[] = {MachineType::AnyTagged(),
524                                 MachineType::AnyTagged(), MachineType::Int32(),
525                                 MachineType::AnyTagged()};
526  data->InitializePlatformIndependent(arraysize(machine_types), 0,
527                                      machine_types);
528}
529
530void ArrayNoArgumentConstructorDescriptor::InitializePlatformIndependent(
531    CallInterfaceDescriptorData* data) {
532  // kFunction, kAllocationSite, kActualArgumentsCount, kFunctionParameter
533  MachineType machine_types[] = {MachineType::TaggedPointer(),
534                                 MachineType::AnyTagged(), MachineType::Int32(),
535                                 MachineType::AnyTagged()};
536  data->InitializePlatformIndependent(arraysize(machine_types), 0,
537                                      machine_types);
538}
539
540void ArraySingleArgumentConstructorDescriptor::InitializePlatformIndependent(
541    CallInterfaceDescriptorData* data) {
542  // kFunction, kAllocationSite, kActualArgumentsCount, kFunctionParameter,
543  // kArraySizeSmiParameter
544  MachineType machine_types[] = {
545      MachineType::TaggedPointer(), MachineType::AnyTagged(),
546      MachineType::Int32(), MachineType::AnyTagged(), MachineType::AnyTagged()};
547  data->InitializePlatformIndependent(arraysize(machine_types), 0,
548                                      machine_types);
549}
550
551void ArrayNArgumentsConstructorDescriptor::InitializePlatformIndependent(
552    CallInterfaceDescriptorData* data) {
553  // kFunction, kAllocationSite, kActualArgumentsCount
554  MachineType machine_types[] = {
555      MachineType::AnyTagged(), MachineType::AnyTagged(), MachineType::Int32()};
556  data->InitializePlatformIndependent(arraysize(machine_types), 0,
557                                      machine_types);
558}
559
560void ArgumentAdaptorDescriptor::InitializePlatformIndependent(
561    CallInterfaceDescriptorData* data) {
562  // kFunction, kNewTarget, kActualArgumentsCount, kExpectedArgumentsCount
563  MachineType machine_types[] = {MachineType::TaggedPointer(),
564                                 MachineType::AnyTagged(), MachineType::Int32(),
565                                 MachineType::Int32()};
566  data->InitializePlatformIndependent(arraysize(machine_types), 0,
567                                      machine_types);
568}
569
570void ApiCallbackDescriptor::InitializePlatformIndependent(
571    CallInterfaceDescriptorData* data) {
572  // kFunction, kCallData, kHolder, kApiFunctionAddress
573  MachineType machine_types[] = {
574      MachineType::AnyTagged(), MachineType::AnyTagged(),
575      MachineType::AnyTagged(), MachineType::Pointer()};
576  data->InitializePlatformIndependent(arraysize(machine_types), 0,
577                                      machine_types);
578}
579
580void InterpreterDispatchDescriptor::InitializePlatformIndependent(
581    CallInterfaceDescriptorData* data) {
582  // kAccumulator, kBytecodeOffset, kBytecodeArray, kDispatchTable
583  MachineType machine_types[] = {
584      MachineType::AnyTagged(), MachineType::IntPtr(), MachineType::AnyTagged(),
585      MachineType::IntPtr()};
586  data->InitializePlatformIndependent(arraysize(machine_types), 0,
587                                      machine_types);
588}
589
590void InterpreterPushArgsAndCallDescriptor::InitializePlatformIndependent(
591    CallInterfaceDescriptorData* data) {
592  // kNumberOfArguments, kFirstArgument, kFunction
593  MachineType machine_types[] = {MachineType::Int32(), MachineType::Pointer(),
594                                 MachineType::AnyTagged()};
595  data->InitializePlatformIndependent(arraysize(machine_types), 0,
596                                      machine_types);
597}
598
599void InterpreterPushArgsAndConstructDescriptor::InitializePlatformIndependent(
600    CallInterfaceDescriptorData* data) {
601  // kNumberOfArguments, kNewTarget, kConstructor, kFeedbackElement,
602  // kFirstArgument
603  MachineType machine_types[] = {
604      MachineType::Int32(), MachineType::AnyTagged(), MachineType::AnyTagged(),
605      MachineType::AnyTagged(), MachineType::Pointer()};
606  data->InitializePlatformIndependent(arraysize(machine_types), 0,
607                                      machine_types);
608}
609
610void InterpreterPushArgsAndConstructArrayDescriptor::
611    InitializePlatformIndependent(CallInterfaceDescriptorData* data) {
612  // kNumberOfArguments, kFunction, kFeedbackElement, kFirstArgument
613  MachineType machine_types[] = {MachineType::Int32(), MachineType::AnyTagged(),
614                                 MachineType::AnyTagged(),
615                                 MachineType::Pointer()};
616  data->InitializePlatformIndependent(arraysize(machine_types), 0,
617                                      machine_types);
618}
619
620void InterpreterCEntryDescriptor::InitializePlatformIndependent(
621    CallInterfaceDescriptorData* data) {
622  // kNumberOfArguments, kFirstArgument, kFunctionEntry
623  MachineType machine_types[] = {MachineType::Int32(), MachineType::Pointer(),
624                                 MachineType::Pointer()};
625  data->InitializePlatformIndependent(arraysize(machine_types), 0,
626                                      machine_types);
627}
628
629void FrameDropperTrampolineDescriptor::InitializePlatformIndependent(
630    CallInterfaceDescriptorData* data) {
631  // New FP value.
632  MachineType machine_types[] = {MachineType::Pointer()};
633  data->InitializePlatformIndependent(arraysize(machine_types), 0,
634                                      machine_types);
635}
636
637}  // namespace internal
638}  // namespace v8
639