interface-descriptors.cc revision f3b273f5e6ffd2f6ba1c18a27a17db41dfb113c3 
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 LoadDescriptor::InitializePlatformIndependent(
78    CallInterfaceDescriptorData* data) {
79  // kReceiver, kName, kSlot
80  MachineType machine_types[] = {MachineType::AnyTagged(),
81                                 MachineType::AnyTagged(),
82                                 MachineType::TaggedSigned()};
83  data->InitializePlatformIndependent(arraysize(machine_types), 0,
84                                      machine_types);
85}
86
87void LoadDescriptor::InitializePlatformSpecific(
88    CallInterfaceDescriptorData* data) {
89  Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister()};
90  data->InitializePlatformSpecific(arraysize(registers), registers);
91}
92
93void LoadGlobalDescriptor::InitializePlatformIndependent(
94    CallInterfaceDescriptorData* data) {
95  // kSlot
96  MachineType machine_types[] = {MachineType::TaggedSigned()};
97  data->InitializePlatformIndependent(arraysize(machine_types), 0,
98                                      machine_types);
99}
100
101void LoadGlobalDescriptor::InitializePlatformSpecific(
102    CallInterfaceDescriptorData* data) {
103  Register registers[] = {LoadWithVectorDescriptor::SlotRegister()};
104  data->InitializePlatformSpecific(arraysize(registers), registers);
105}
106
107void LoadGlobalWithVectorDescriptor::InitializePlatformIndependent(
108    CallInterfaceDescriptorData* data) {
109  // kSlot, kVector
110  MachineType machine_types[] = {MachineType::TaggedSigned(),
111                                 MachineType::AnyTagged()};
112  data->InitializePlatformIndependent(arraysize(machine_types), 0,
113                                      machine_types);
114}
115
116void LoadGlobalWithVectorDescriptor::InitializePlatformSpecific(
117    CallInterfaceDescriptorData* data) {
118  Register registers[] = {LoadWithVectorDescriptor::SlotRegister(),
119                          LoadWithVectorDescriptor::VectorRegister()};
120  data->InitializePlatformSpecific(arraysize(registers), registers);
121}
122
123void StoreDescriptor::InitializePlatformIndependent(
124    CallInterfaceDescriptorData* data) {
125  // kReceiver, kName, kValue, kSlot
126  MachineType machine_types[] = {
127      MachineType::AnyTagged(), MachineType::AnyTagged(),
128      MachineType::AnyTagged(), MachineType::TaggedSigned()};
129  data->InitializePlatformIndependent(arraysize(machine_types), 0,
130                                      machine_types);
131}
132
133void StoreDescriptor::InitializePlatformSpecific(
134    CallInterfaceDescriptorData* data) {
135  Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
136                          SlotRegister()};
137
138  int len = arraysize(registers) - kStackArgumentsCount;
139  data->InitializePlatformSpecific(len, registers);
140}
141
142void StoreTransitionDescriptor::InitializePlatformSpecific(
143    CallInterfaceDescriptorData* data) {
144  Register registers[] = {
145      ReceiverRegister(), NameRegister(), MapRegister(),
146      ValueRegister(),    SlotRegister(), VectorRegister(),
147  };
148  int len = arraysize(registers) - kStackArgumentsCount;
149  data->InitializePlatformSpecific(len, registers);
150}
151
152void StoreTransitionDescriptor::InitializePlatformIndependent(
153    CallInterfaceDescriptorData* data) {
154  // kReceiver, kName, kMap, kValue, kSlot, kVector
155  MachineType machine_types[] = {
156      MachineType::AnyTagged(),    MachineType::AnyTagged(),
157      MachineType::AnyTagged(),    MachineType::AnyTagged(),
158      MachineType::TaggedSigned(), MachineType::AnyTagged()};
159  data->InitializePlatformIndependent(arraysize(machine_types), 0,
160                                      machine_types);
161}
162
163void StoreNamedTransitionDescriptor::InitializePlatformIndependent(
164    CallInterfaceDescriptorData* data) {
165  // kReceiver, kFieldOffset, kMap, kValue, kSlot, kVector, kName
166  MachineType machine_types[] = {
167      MachineType::AnyTagged(),    MachineType::TaggedSigned(),
168      MachineType::AnyTagged(),    MachineType::AnyTagged(),
169      MachineType::TaggedSigned(), MachineType::AnyTagged(),
170      MachineType::AnyTagged()};
171  data->InitializePlatformIndependent(arraysize(machine_types), 0,
172                                      machine_types);
173}
174
175void StoreNamedTransitionDescriptor::InitializePlatformSpecific(
176    CallInterfaceDescriptorData* data) {
177  Register registers[] = {
178      ReceiverRegister(), FieldOffsetRegister(), MapRegister(),
179      ValueRegister(),    SlotRegister(),        VectorRegister(),
180      NameRegister(),
181  };
182  int len = arraysize(registers) - kStackArgumentsCount;
183  data->InitializePlatformSpecific(len, registers);
184}
185
186void StoreGlobalViaContextDescriptor::InitializePlatformIndependent(
187    CallInterfaceDescriptorData* data) {
188  // kSlot, kValue
189  MachineType machine_types[] = {MachineType::Int32(),
190                                 MachineType::AnyTagged()};
191  data->InitializePlatformIndependent(arraysize(machine_types), 0,
192                                      machine_types);
193}
194
195void StoreGlobalViaContextDescriptor::InitializePlatformSpecific(
196    CallInterfaceDescriptorData* data) {
197  Register registers[] = {SlotRegister(), ValueRegister()};
198  data->InitializePlatformSpecific(arraysize(registers), registers);
199}
200
201
202void StringCompareDescriptor::InitializePlatformSpecific(
203    CallInterfaceDescriptorData* data) {
204  Register registers[] = {LeftRegister(), RightRegister()};
205  data->InitializePlatformSpecific(arraysize(registers), registers);
206}
207
208void TypeConversionDescriptor::InitializePlatformSpecific(
209    CallInterfaceDescriptorData* data) {
210  Register registers[] = {ArgumentRegister()};
211  data->InitializePlatformSpecific(arraysize(registers), registers);
212}
213
214void MathPowTaggedDescriptor::InitializePlatformSpecific(
215    CallInterfaceDescriptorData* data) {
216  Register registers[] = {exponent()};
217  data->InitializePlatformSpecific(arraysize(registers), registers);
218}
219
220void MathPowIntegerDescriptor::InitializePlatformSpecific(
221    CallInterfaceDescriptorData* data) {
222  Register registers[] = {exponent()};
223  data->InitializePlatformSpecific(arraysize(registers), registers);
224}
225
226void LoadWithVectorDescriptor::InitializePlatformIndependent(
227    CallInterfaceDescriptorData* data) {
228  // kReceiver, kName, kSlot, kVector
229  MachineType machine_types[] = {
230      MachineType::AnyTagged(), MachineType::AnyTagged(),
231      MachineType::TaggedSigned(), MachineType::AnyTagged()};
232  data->InitializePlatformIndependent(arraysize(machine_types), 0,
233                                      machine_types);
234}
235
236
237void LoadWithVectorDescriptor::InitializePlatformSpecific(
238    CallInterfaceDescriptorData* data) {
239  Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister(),
240                          VectorRegister()};
241  data->InitializePlatformSpecific(arraysize(registers), registers);
242}
243
244void StoreWithVectorDescriptor::InitializePlatformIndependent(
245    CallInterfaceDescriptorData* data) {
246  // kReceiver, kName, kValue, kSlot, kVector
247  MachineType machine_types[] = {
248      MachineType::AnyTagged(), MachineType::AnyTagged(),
249      MachineType::AnyTagged(), MachineType::TaggedSigned(),
250      MachineType::AnyTagged()};
251  data->InitializePlatformIndependent(arraysize(machine_types), 0,
252                                      machine_types);
253}
254
255void StoreWithVectorDescriptor::InitializePlatformSpecific(
256    CallInterfaceDescriptorData* data) {
257  Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
258                          SlotRegister(), VectorRegister()};
259  int len = arraysize(registers) - kStackArgumentsCount;
260  data->InitializePlatformSpecific(len, registers);
261}
262
263void BinaryOpWithVectorDescriptor::InitializePlatformIndependent(
264    CallInterfaceDescriptorData* data) {
265  // kLeft, kRight, kSlot, kVector
266  MachineType machine_types[] = {MachineType::AnyTagged(),
267                                 MachineType::AnyTagged(), MachineType::Int32(),
268                                 MachineType::AnyTagged()};
269  data->InitializePlatformIndependent(arraysize(machine_types), 0,
270                                      machine_types);
271}
272
273const Register ApiGetterDescriptor::ReceiverRegister() {
274  return LoadDescriptor::ReceiverRegister();
275}
276
277void ApiGetterDescriptor::InitializePlatformSpecific(
278    CallInterfaceDescriptorData* data) {
279  Register registers[] = {ReceiverRegister(), HolderRegister(),
280                          CallbackRegister()};
281  data->InitializePlatformSpecific(arraysize(registers), registers);
282}
283
284void ContextOnlyDescriptor::InitializePlatformSpecific(
285    CallInterfaceDescriptorData* data) {
286  data->InitializePlatformSpecific(0, nullptr);
287}
288
289void GrowArrayElementsDescriptor::InitializePlatformSpecific(
290    CallInterfaceDescriptorData* data) {
291  Register registers[] = {ObjectRegister(), KeyRegister()};
292  data->InitializePlatformSpecific(arraysize(registers), registers);
293}
294
295void VarArgFunctionDescriptor::InitializePlatformIndependent(
296    CallInterfaceDescriptorData* data) {
297  // kActualArgumentsCount
298  MachineType machine_types[] = {MachineType::Int32()};
299  data->InitializePlatformIndependent(arraysize(machine_types), 0,
300                                      machine_types);
301}
302
303void FastCloneRegExpDescriptor::InitializePlatformIndependent(
304    CallInterfaceDescriptorData* data) {
305  // kClosure, kLiteralIndex, kPattern, kFlags
306  MachineType machine_types[] = {
307      MachineType::AnyTagged(), MachineType::TaggedSigned(),
308      MachineType::AnyTagged(), MachineType::AnyTagged()};
309  data->InitializePlatformIndependent(arraysize(machine_types), 0,
310                                      machine_types);
311}
312
313void FastCloneShallowArrayDescriptor::InitializePlatformIndependent(
314    CallInterfaceDescriptorData* data) {
315  // kClosure, kLiteralIndex, kConstantElements
316  MachineType machine_types[] = {MachineType::AnyTagged(),
317                                 MachineType::TaggedSigned(),
318                                 MachineType::AnyTagged()};
319  data->InitializePlatformIndependent(arraysize(machine_types), 0,
320                                      machine_types);
321}
322
323void CreateAllocationSiteDescriptor::InitializePlatformIndependent(
324    CallInterfaceDescriptorData* data) {
325  // kVector, kSlot
326  MachineType machine_types[] = {MachineType::AnyTagged(),
327                                 MachineType::TaggedSigned()};
328  data->InitializePlatformIndependent(arraysize(machine_types), 0,
329                                      machine_types);
330}
331
332void CreateWeakCellDescriptor::InitializePlatformIndependent(
333    CallInterfaceDescriptorData* data) {
334  // kVector, kSlot, kValue
335  MachineType machine_types[] = {MachineType::AnyTagged(),
336                                 MachineType::TaggedSigned(),
337                                 MachineType::AnyTagged()};
338  data->InitializePlatformIndependent(arraysize(machine_types), 0,
339                                      machine_types);
340}
341
342void CallTrampolineDescriptor::InitializePlatformIndependent(
343    CallInterfaceDescriptorData* data) {
344  // kFunction, kActualArgumentsCount
345  MachineType machine_types[] = {MachineType::AnyTagged(),
346                                 MachineType::Int32()};
347  data->InitializePlatformIndependent(arraysize(machine_types), 0,
348                                      machine_types);
349}
350
351void ConstructStubDescriptor::InitializePlatformIndependent(
352    CallInterfaceDescriptorData* data) {
353  // kFunction, kNewTarget, kActualArgumentsCount, kAllocationSite
354  MachineType machine_types[] = {MachineType::AnyTagged(),
355                                 MachineType::AnyTagged(), MachineType::Int32(),
356                                 MachineType::AnyTagged()};
357  data->InitializePlatformIndependent(arraysize(machine_types), 0,
358                                      machine_types);
359}
360
361void ConstructTrampolineDescriptor::InitializePlatformIndependent(
362    CallInterfaceDescriptorData* data) {
363  // kFunction, kNewTarget, kActualArgumentsCount
364  MachineType machine_types[] = {
365      MachineType::AnyTagged(), MachineType::AnyTagged(), MachineType::Int32()};
366  data->InitializePlatformIndependent(arraysize(machine_types), 0,
367                                      machine_types);
368}
369
370void CallFunctionWithFeedbackDescriptor::InitializePlatformIndependent(
371    CallInterfaceDescriptorData* data) {
372  // kFunction, kSlot
373  MachineType machine_types[] = {MachineType::AnyTagged(),
374                                 MachineType::TaggedSigned()};
375  data->InitializePlatformIndependent(arraysize(machine_types), 0,
376                                      machine_types);
377}
378
379void CallFunctionWithFeedbackAndVectorDescriptor::InitializePlatformIndependent(
380    CallInterfaceDescriptorData* data) {
381  // kFunction, kSlot, kVector
382  MachineType machine_types[] = {MachineType::TaggedPointer(),
383                                 MachineType::TaggedSigned(),
384                                 MachineType::AnyTagged()};
385  data->InitializePlatformIndependent(arraysize(machine_types), 0,
386                                      machine_types);
387}
388
389void ArrayNoArgumentConstructorDescriptor::InitializePlatformIndependent(
390    CallInterfaceDescriptorData* data) {
391  // kFunction, kAllocationSite, kActualArgumentsCount, kFunctionParameter
392  MachineType machine_types[] = {MachineType::TaggedPointer(),
393                                 MachineType::AnyTagged(), MachineType::Int32(),
394                                 MachineType::AnyTagged()};
395  data->InitializePlatformIndependent(arraysize(machine_types), 0,
396                                      machine_types);
397}
398
399void ArraySingleArgumentConstructorDescriptor::InitializePlatformIndependent(
400    CallInterfaceDescriptorData* data) {
401  // kFunction, kAllocationSite, kActualArgumentsCount, kFunctionParameter,
402  // kArraySizeSmiParameter
403  MachineType machine_types[] = {
404      MachineType::TaggedPointer(), MachineType::AnyTagged(),
405      MachineType::Int32(), MachineType::AnyTagged(), MachineType::AnyTagged()};
406  data->InitializePlatformIndependent(arraysize(machine_types), 0,
407                                      machine_types);
408}
409
410void ArrayNArgumentsConstructorDescriptor::InitializePlatformIndependent(
411    CallInterfaceDescriptorData* data) {
412  // kFunction, kAllocationSite, kActualArgumentsCount
413  MachineType machine_types[] = {MachineType::TaggedPointer(),
414                                 MachineType::AnyTagged(),
415                                 MachineType::Int32()};
416  data->InitializePlatformIndependent(arraysize(machine_types), 0,
417                                      machine_types);
418}
419
420void ArgumentAdaptorDescriptor::InitializePlatformIndependent(
421    CallInterfaceDescriptorData* data) {
422  // kFunction, kNewTarget, kActualArgumentsCount, kExpectedArgumentsCount
423  MachineType machine_types[] = {MachineType::TaggedPointer(),
424                                 MachineType::AnyTagged(), MachineType::Int32(),
425                                 MachineType::Int32()};
426  data->InitializePlatformIndependent(arraysize(machine_types), 0,
427                                      machine_types);
428}
429
430void ApiCallbackDescriptor::InitializePlatformIndependent(
431    CallInterfaceDescriptorData* data) {
432  // kFunction, kCallData, kHolder, kApiFunctionAddress
433  MachineType machine_types[] = {
434      MachineType::AnyTagged(), MachineType::AnyTagged(),
435      MachineType::AnyTagged(), MachineType::Pointer()};
436  data->InitializePlatformIndependent(arraysize(machine_types), 0,
437                                      machine_types);
438}
439
440void InterpreterDispatchDescriptor::InitializePlatformIndependent(
441    CallInterfaceDescriptorData* data) {
442  // kAccumulator, kBytecodeOffset, kBytecodeArray, kDispatchTable
443  MachineType machine_types[] = {
444      MachineType::AnyTagged(), MachineType::IntPtr(), MachineType::AnyTagged(),
445      MachineType::AnyTagged()};
446  data->InitializePlatformIndependent(arraysize(machine_types), 0,
447                                      machine_types);
448}
449
450void InterpreterPushArgsAndCallDescriptor::InitializePlatformIndependent(
451    CallInterfaceDescriptorData* data) {
452  // kNumberOfArguments, kFirstArgument, kFunction
453  MachineType machine_types[] = {MachineType::Int32(), MachineType::Pointer(),
454                                 MachineType::AnyTagged()};
455  data->InitializePlatformIndependent(arraysize(machine_types), 0,
456                                      machine_types);
457}
458
459void InterpreterPushArgsAndConstructDescriptor::InitializePlatformIndependent(
460    CallInterfaceDescriptorData* data) {
461  // kNumberOfArguments, kNewTarget, kConstructor, kFeedbackElement,
462  // kFirstArgument
463  MachineType machine_types[] = {
464      MachineType::Int32(), MachineType::AnyTagged(), MachineType::AnyTagged(),
465      MachineType::AnyTagged(), MachineType::Pointer()};
466  data->InitializePlatformIndependent(arraysize(machine_types), 0,
467                                      machine_types);
468}
469
470void InterpreterPushArgsAndConstructArrayDescriptor::
471    InitializePlatformIndependent(CallInterfaceDescriptorData* data) {
472  // kNumberOfArguments, kFunction, kFeedbackElement, kFirstArgument
473  MachineType machine_types[] = {MachineType::Int32(), MachineType::AnyTagged(),
474                                 MachineType::AnyTagged(),
475                                 MachineType::Pointer()};
476  data->InitializePlatformIndependent(arraysize(machine_types), 0,
477                                      machine_types);
478}
479
480void InterpreterCEntryDescriptor::InitializePlatformIndependent(
481    CallInterfaceDescriptorData* data) {
482  // kNumberOfArguments, kFirstArgument, kFunctionEntry
483  MachineType machine_types[] = {MachineType::Int32(), MachineType::Pointer(),
484                                 MachineType::Pointer()};
485  data->InitializePlatformIndependent(arraysize(machine_types), 0,
486                                      machine_types);
487}
488
489}  // namespace internal
490}  // namespace v8
491