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