V8 Project
interface-descriptors-arm64.cc
Go to the documentation of this file.
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/v8.h"
6 
7 #if V8_TARGET_ARCH_ARM64
8 
10 
11 namespace v8 {
12 namespace internal {
13 
14 const Register CallInterfaceDescriptor::ContextRegister() { return cp; }
15 
16 
17 const Register LoadDescriptor::ReceiverRegister() { return x1; }
18 const Register LoadDescriptor::NameRegister() { return x2; }
19 
20 
21 const Register VectorLoadICTrampolineDescriptor::SlotRegister() { return x0; }
22 
23 
24 const Register VectorLoadICDescriptor::VectorRegister() { return x3; }
25 
26 
27 const Register StoreDescriptor::ReceiverRegister() { return x1; }
28 const Register StoreDescriptor::NameRegister() { return x2; }
29 const Register StoreDescriptor::ValueRegister() { return x0; }
30 
31 
32 const Register ElementTransitionAndStoreDescriptor::MapRegister() { return x3; }
33 
34 
35 const Register InstanceofDescriptor::left() {
36  // Object to check (instanceof lhs).
37  return x11;
38 }
39 
40 
41 const Register InstanceofDescriptor::right() {
42  // Constructor function (instanceof rhs).
43  return x10;
44 }
45 
46 
47 const Register ArgumentsAccessReadDescriptor::index() { return x1; }
48 const Register ArgumentsAccessReadDescriptor::parameter_count() { return x0; }
49 
50 
51 const Register ApiGetterDescriptor::function_address() { return x2; }
52 
53 
54 const Register MathPowTaggedDescriptor::exponent() { return x11; }
55 
56 
57 const Register MathPowIntegerDescriptor::exponent() { return x12; }
58 
59 
60 void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData* data) {
61  // cp: context
62  // x2: function info
63  Register registers[] = {cp, x2};
64  data->Initialize(arraysize(registers), registers, NULL);
65 }
66 
67 
68 void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData* data) {
69  // cp: context
70  // x1: function
71  Register registers[] = {cp, x1};
72  data->Initialize(arraysize(registers), registers, NULL);
73 }
74 
75 
76 void ToNumberDescriptor::Initialize(CallInterfaceDescriptorData* data) {
77  // cp: context
78  // x0: value
79  Register registers[] = {cp, x0};
80  data->Initialize(arraysize(registers), registers, NULL);
81 }
82 
83 
84 void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData* data) {
85  // cp: context
86  // x0: value
87  Register registers[] = {cp, x0};
88  data->Initialize(arraysize(registers), registers, NULL);
89 }
90 
91 
92 void FastCloneShallowArrayDescriptor::Initialize(
93  CallInterfaceDescriptorData* data) {
94  // cp: context
95  // x3: array literals array
96  // x2: array literal index
97  // x1: constant elements
98  Register registers[] = {cp, x3, x2, x1};
99  Representation representations[] = {
102  data->Initialize(arraysize(registers), registers, representations);
103 }
104 
105 
106 void FastCloneShallowObjectDescriptor::Initialize(
107  CallInterfaceDescriptorData* data) {
108  // cp: context
109  // x3: object literals array
110  // x2: object literal index
111  // x1: constant properties
112  // x0: object literal flags
113  Register registers[] = {cp, x3, x2, x1, x0};
114  data->Initialize(arraysize(registers), registers, NULL);
115 }
116 
117 
118 void CreateAllocationSiteDescriptor::Initialize(
119  CallInterfaceDescriptorData* data) {
120  // cp: context
121  // x2: feedback vector
122  // x3: call feedback slot
123  Register registers[] = {cp, x2, x3};
124  data->Initialize(arraysize(registers), registers, NULL);
125 }
126 
127 
128 void StoreArrayLiteralElementDescriptor::Initialize(
129  CallInterfaceDescriptorData* data) {
130  Register registers[] = {cp, x3, x0};
131  data->Initialize(arraysize(registers), registers, NULL);
132 }
133 
134 
135 void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
136  // x1 function the function to call
137  Register registers[] = {cp, x1};
138  data->Initialize(arraysize(registers), registers, NULL);
139 }
140 
141 
142 void CallFunctionWithFeedbackDescriptor::Initialize(
143  CallInterfaceDescriptorData* data) {
144  Register registers[] = {cp, x1, x3};
145  Representation representations[] = {Representation::Tagged(),
148  data->Initialize(arraysize(registers), registers, representations);
149 }
150 
151 
152 void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData* data) {
153  // x0 : number of arguments
154  // x1 : the function to call
155  // x2 : feedback vector
156  // x3 : slot in feedback vector (smi) (if r2 is not the megamorphic symbol)
157  // TODO(turbofan): So far we don't gather type feedback and hence skip the
158  // slot parameter, but ArrayConstructStub needs the vector to be undefined.
159  Register registers[] = {cp, x0, x1, x2};
160  data->Initialize(arraysize(registers), registers, NULL);
161 }
162 
163 
164 void RegExpConstructResultDescriptor::Initialize(
165  CallInterfaceDescriptorData* data) {
166  // cp: context
167  // x2: length
168  // x1: index (of last match)
169  // x0: string
170  Register registers[] = {cp, x2, x1, x0};
171  data->Initialize(arraysize(registers), registers, NULL);
172 }
173 
174 
175 void TransitionElementsKindDescriptor::Initialize(
176  CallInterfaceDescriptorData* data) {
177  // cp: context
178  // x0: value (js_array)
179  // x1: to_map
180  Register registers[] = {cp, x0, x1};
181  data->Initialize(arraysize(registers), registers, NULL);
182 }
183 
184 
185 void ArrayConstructorConstantArgCountDescriptor::Initialize(
186  CallInterfaceDescriptorData* data) {
187  // cp: context
188  // x1: function
189  // x2: allocation site with elements kind
190  // x0: number of arguments to the constructor function
191  Register registers[] = {cp, x1, x2};
192  data->Initialize(arraysize(registers), registers, NULL);
193 }
194 
195 
196 void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
197  // stack param count needs (constructor pointer, and single argument)
198  Register registers[] = {cp, x1, x2, x0};
199  Representation representations[] = {
202  data->Initialize(arraysize(registers), registers, representations);
203 }
204 
205 
206 void InternalArrayConstructorConstantArgCountDescriptor::Initialize(
207  CallInterfaceDescriptorData* data) {
208  // cp: context
209  // x1: constructor function
210  // x0: number of arguments to the constructor function
211  Register registers[] = {cp, x1};
212  data->Initialize(arraysize(registers), registers, NULL);
213 }
214 
215 
216 void InternalArrayConstructorDescriptor::Initialize(
217  CallInterfaceDescriptorData* data) {
218  // stack param count needs (constructor pointer, and single argument)
219  Register registers[] = {cp, x1, x0};
220  Representation representations[] = {Representation::Tagged(),
223  data->Initialize(arraysize(registers), registers, representations);
224 }
225 
226 
227 void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) {
228  // cp: context
229  // x0: value to compare
230  Register registers[] = {cp, x0};
231  data->Initialize(arraysize(registers), registers, NULL);
232 }
233 
234 
235 void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) {
236  // cp: context
237  // x0: value
238  Register registers[] = {cp, x0};
239  data->Initialize(arraysize(registers), registers, NULL);
240 }
241 
242 
243 void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) {
244  // cp: context
245  // x1: left operand
246  // x0: right operand
247  Register registers[] = {cp, x1, x0};
248  data->Initialize(arraysize(registers), registers, NULL);
249 }
250 
251 
252 void BinaryOpWithAllocationSiteDescriptor::Initialize(
253  CallInterfaceDescriptorData* data) {
254  // cp: context
255  // x2: allocation site
256  // x1: left operand
257  // x0: right operand
258  Register registers[] = {cp, x2, x1, x0};
259  data->Initialize(arraysize(registers), registers, NULL);
260 }
261 
262 
263 void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) {
264  // cp: context
265  // x1: left operand
266  // x0: right operand
267  Register registers[] = {cp, x1, x0};
268  data->Initialize(arraysize(registers), registers, NULL);
269 }
270 
271 
272 void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
273  static PlatformInterfaceDescriptor noInlineDescriptor =
274  PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS);
275 
276  Register registers[] = {
277  cp, // context
278  x2, // key
279  };
280  Representation representations[] = {
281  Representation::Tagged(), // context
282  Representation::Tagged(), // key
283  };
284  data->Initialize(arraysize(registers), registers, representations,
285  &noInlineDescriptor);
286 }
287 
288 
289 void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
290  static PlatformInterfaceDescriptor noInlineDescriptor =
291  PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS);
292 
293  Register registers[] = {
294  cp, // context
295  x2, // name
296  };
297  Representation representations[] = {
298  Representation::Tagged(), // context
299  Representation::Tagged(), // name
300  };
301  data->Initialize(arraysize(registers), registers, representations,
302  &noInlineDescriptor);
303 }
304 
305 
306 void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) {
307  static PlatformInterfaceDescriptor default_descriptor =
308  PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
309 
310  Register registers[] = {
311  cp, // context
312  x0, // receiver
313  };
314  Representation representations[] = {
315  Representation::Tagged(), // context
316  Representation::Tagged(), // receiver
317  };
318  data->Initialize(arraysize(registers), registers, representations,
319  &default_descriptor);
320 }
321 
322 
323 void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
324  static PlatformInterfaceDescriptor default_descriptor =
325  PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
326 
327  Register registers[] = {
328  cp, // context
329  x1, // JSFunction
330  x0, // actual number of arguments
331  x2, // expected number of arguments
332  };
333  Representation representations[] = {
334  Representation::Tagged(), // context
335  Representation::Tagged(), // JSFunction
336  Representation::Integer32(), // actual number of arguments
337  Representation::Integer32(), // expected number of arguments
338  };
339  data->Initialize(arraysize(registers), registers, representations,
340  &default_descriptor);
341 }
342 
343 
344 void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
345  static PlatformInterfaceDescriptor default_descriptor =
346  PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
347 
348  Register registers[] = {
349  cp, // context
350  x0, // callee
351  x4, // call_data
352  x2, // holder
353  x1, // api_function_address
354  };
355  Representation representations[] = {
356  Representation::Tagged(), // context
357  Representation::Tagged(), // callee
358  Representation::Tagged(), // call_data
359  Representation::Tagged(), // holder
360  Representation::External(), // api_function_address
361  };
362  data->Initialize(arraysize(registers), registers, representations,
363  &default_descriptor);
364 }
365 }
366 } // namespace v8::internal
367 
368 #endif // V8_TARGET_ARCH_ARM64
static const Register function_address()
void Initialize(int register_parameter_count, Register *registers, Representation *param_representations, PlatformInterfaceDescriptor *platform_descriptor=NULL)
static const Register ContextRegister()
const CallInterfaceDescriptorData * data() const
static const Register left()
static const Register right()
static const Register ReceiverRegister()
static const Register NameRegister()
static const Register exponent()
static const Register exponent()
static Representation External()
static Representation Smi()
static Representation Integer32()
static Representation Tagged()
static const Register ReceiverRegister()
static const Register NameRegister()
static const Register ValueRegister()
static const Register VectorRegister()
enable harmony numeric enable harmony object literal extensions Optimize object Array DOM strings and string trace pretenuring decisions of HAllocate instructions Enables optimizations which favor memory size over execution speed maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining trace the tracking of allocation sites deoptimize every n garbage collections perform array bounds checks elimination analyze liveness of environment slots and zap dead values flushes the cache of optimized code for closures on every GC allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes enable context specialization in TurboFan execution budget before interrupt is triggered max percentage of megamorphic generic ICs to allow optimization enable use of SAHF instruction if enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable use of MLS instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long enable alignment of csp to bytes on platforms which prefer the register to always be NULL
#define arraysize(array)
Definition: macros.h:86
const Register cp
Debugger support for the V8 JavaScript engine.
Definition: accessors.cc:20