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