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