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.
9 #include "src/interface-descriptors.h"
14 const Register CallInterfaceDescriptor::ContextRegister() { return cp; }
17 const Register LoadDescriptor::ReceiverRegister() { return r1; }
18 const Register LoadDescriptor::NameRegister() { return r2; }
21 const Register VectorLoadICTrampolineDescriptor::SlotRegister() { return r0; }
24 const Register VectorLoadICDescriptor::VectorRegister() { return r3; }
27 const Register StoreDescriptor::ReceiverRegister() { return r1; }
28 const Register StoreDescriptor::NameRegister() { return r2; }
29 const Register StoreDescriptor::ValueRegister() { return r0; }
32 const Register StoreTransitionDescriptor::MapRegister() { return r3; }
35 const Register ElementTransitionAndStoreDescriptor::MapRegister() { return r3; }
38 const Register InstanceofDescriptor::left() { return r0; }
39 const Register InstanceofDescriptor::right() { return r1; }
42 const Register ArgumentsAccessReadDescriptor::index() { return r1; }
43 const Register ArgumentsAccessReadDescriptor::parameter_count() { return r0; }
46 const Register ApiGetterDescriptor::function_address() { return r2; }
49 const Register MathPowTaggedDescriptor::exponent() { return r2; }
52 const Register MathPowIntegerDescriptor::exponent() {
53 return MathPowTaggedDescriptor::exponent();
57 void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData* data) {
58 Register registers[] = {cp, r2};
59 data->Initialize(arraysize(registers), registers, NULL);
63 void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData* data) {
64 Register registers[] = {cp, r1};
65 data->Initialize(arraysize(registers), registers, NULL);
69 void ToNumberDescriptor::Initialize(CallInterfaceDescriptorData* data) {
70 Register registers[] = {cp, r0};
71 data->Initialize(arraysize(registers), registers, NULL);
75 void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData* data) {
76 Register registers[] = {cp, r0};
77 data->Initialize(arraysize(registers), registers, NULL);
81 void FastCloneShallowArrayDescriptor::Initialize(
82 CallInterfaceDescriptorData* data) {
83 Register registers[] = {cp, r3, r2, r1};
84 Representation representations[] = {
85 Representation::Tagged(), Representation::Tagged(), Representation::Smi(),
86 Representation::Tagged()};
87 data->Initialize(arraysize(registers), registers, representations);
91 void FastCloneShallowObjectDescriptor::Initialize(
92 CallInterfaceDescriptorData* data) {
93 Register registers[] = {cp, r3, r2, r1, r0};
94 data->Initialize(arraysize(registers), registers, NULL);
98 void CreateAllocationSiteDescriptor::Initialize(
99 CallInterfaceDescriptorData* data) {
100 Register registers[] = {cp, r2, r3};
101 Representation representations[] = {Representation::Tagged(),
102 Representation::Tagged(),
103 Representation::Smi()};
104 data->Initialize(arraysize(registers), registers, representations);
108 void CreateWeakCellDescriptor::Initialize(CallInterfaceDescriptorData* data) {
109 Register registers[] = {cp, r2, r3, r1};
110 Representation representations[] = {
111 Representation::Tagged(), Representation::Tagged(), Representation::Smi(),
112 Representation::Tagged()};
113 data->Initialize(arraysize(registers), registers, representations);
117 void StoreArrayLiteralElementDescriptor::Initialize(
118 CallInterfaceDescriptorData* data) {
119 Register registers[] = {cp, r3, r0};
120 data->Initialize(arraysize(registers), registers, NULL);
124 void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
125 Register registers[] = {cp, r1};
126 data->Initialize(arraysize(registers), registers, NULL);
130 void CallFunctionWithFeedbackDescriptor::Initialize(
131 CallInterfaceDescriptorData* data) {
132 Register registers[] = {cp, r1, r3};
133 Representation representations[] = {Representation::Tagged(),
134 Representation::Tagged(),
135 Representation::Smi()};
136 data->Initialize(arraysize(registers), registers, representations);
140 void CallFunctionWithFeedbackAndVectorDescriptor::Initialize(
141 CallInterfaceDescriptorData* data) {
142 Register registers[] = {cp, r1, r3, r2};
143 Representation representations[] = {
144 Representation::Tagged(), Representation::Tagged(), Representation::Smi(),
145 Representation::Tagged()};
146 data->Initialize(arraysize(registers), registers, representations);
150 void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData* data) {
151 // r0 : number of arguments
152 // r1 : the function to call
153 // r2 : feedback vector
154 // r3 : (only if r2 is not the megamorphic symbol) slot in feedback
156 // TODO(turbofan): So far we don't gather type feedback and hence skip the
157 // slot parameter, but ArrayConstructStub needs the vector to be undefined.
158 Register registers[] = {cp, r0, r1, r2};
159 data->Initialize(arraysize(registers), registers, NULL);
163 void RegExpConstructResultDescriptor::Initialize(
164 CallInterfaceDescriptorData* data) {
165 Register registers[] = {cp, r2, r1, r0};
166 data->Initialize(arraysize(registers), registers, NULL);
170 void TransitionElementsKindDescriptor::Initialize(
171 CallInterfaceDescriptorData* data) {
172 Register registers[] = {cp, r0, r1};
173 data->Initialize(arraysize(registers), registers, NULL);
177 void AllocateHeapNumberDescriptor::Initialize(
178 CallInterfaceDescriptorData* data) {
181 Register registers[] = {cp};
182 data->Initialize(arraysize(registers), registers, nullptr);
186 void ArrayConstructorConstantArgCountDescriptor::Initialize(
187 CallInterfaceDescriptorData* data) {
190 // r0 -- number of arguments
192 // r2 -- allocation site with elements kind
193 Register registers[] = {cp, r1, r2};
194 data->Initialize(arraysize(registers), registers, NULL);
198 void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
199 // stack param count needs (constructor pointer, and single argument)
200 Register registers[] = {cp, r1, r2, r0};
201 Representation representations[] = {
202 Representation::Tagged(), Representation::Tagged(),
203 Representation::Tagged(), Representation::Integer32()};
204 data->Initialize(arraysize(registers), registers, representations);
208 void InternalArrayConstructorConstantArgCountDescriptor::Initialize(
209 CallInterfaceDescriptorData* data) {
212 // r0 -- number of arguments
213 // r1 -- constructor function
214 Register registers[] = {cp, r1};
215 data->Initialize(arraysize(registers), registers, NULL);
219 void InternalArrayConstructorDescriptor::Initialize(
220 CallInterfaceDescriptorData* data) {
221 // stack param count needs (constructor pointer, and single argument)
222 Register registers[] = {cp, r1, r0};
223 Representation representations[] = {Representation::Tagged(),
224 Representation::Tagged(),
225 Representation::Integer32()};
226 data->Initialize(arraysize(registers), registers, representations);
230 void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) {
231 Register registers[] = {cp, r0};
232 data->Initialize(arraysize(registers), registers, NULL);
236 void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) {
237 Register registers[] = {cp, r0};
238 data->Initialize(arraysize(registers), registers, NULL);
242 void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) {
243 Register registers[] = {cp, r1, r0};
244 data->Initialize(arraysize(registers), registers, NULL);
248 void BinaryOpWithAllocationSiteDescriptor::Initialize(
249 CallInterfaceDescriptorData* data) {
250 Register registers[] = {cp, r2, r1, r0};
251 data->Initialize(arraysize(registers), registers, NULL);
255 void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) {
256 Register registers[] = {cp, r1, r0};
257 data->Initialize(arraysize(registers), registers, NULL);
261 void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
262 static PlatformInterfaceDescriptor noInlineDescriptor =
263 PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS);
265 Register registers[] = {
269 Representation representations[] = {
270 Representation::Tagged(), // context
271 Representation::Tagged(), // key
273 data->Initialize(arraysize(registers), registers, representations,
274 &noInlineDescriptor);
278 void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
279 static PlatformInterfaceDescriptor noInlineDescriptor =
280 PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS);
282 Register registers[] = {
286 Representation representations[] = {
287 Representation::Tagged(), // context
288 Representation::Tagged(), // name
290 data->Initialize(arraysize(registers), registers, representations,
291 &noInlineDescriptor);
295 void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) {
296 static PlatformInterfaceDescriptor default_descriptor =
297 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
299 Register registers[] = {
303 Representation representations[] = {
304 Representation::Tagged(), // context
305 Representation::Tagged(), // receiver
307 data->Initialize(arraysize(registers), registers, representations,
308 &default_descriptor);
312 void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
313 static PlatformInterfaceDescriptor default_descriptor =
314 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
316 Register registers[] = {
319 r0, // actual number of arguments
320 r2, // expected number of arguments
322 Representation representations[] = {
323 Representation::Tagged(), // context
324 Representation::Tagged(), // JSFunction
325 Representation::Integer32(), // actual number of arguments
326 Representation::Integer32(), // expected number of arguments
328 data->Initialize(arraysize(registers), registers, representations,
329 &default_descriptor);
333 void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
334 static PlatformInterfaceDescriptor default_descriptor =
335 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
337 Register registers[] = {
342 r1, // api_function_address
343 r3, // actual number of arguments
345 Representation representations[] = {
346 Representation::Tagged(), // context
347 Representation::Tagged(), // callee
348 Representation::Tagged(), // call_data
349 Representation::Tagged(), // holder
350 Representation::External(), // api_function_address
351 Representation::Integer32(), // actual number of arguments
353 data->Initialize(arraysize(registers), registers, representations,
354 &default_descriptor);
358 void ApiAccessorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
359 static PlatformInterfaceDescriptor default_descriptor =
360 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
362 Register registers[] = {
367 r1, // api_function_address
369 Representation representations[] = {
370 Representation::Tagged(), // context
371 Representation::Tagged(), // callee
372 Representation::Tagged(), // call_data
373 Representation::Tagged(), // holder
374 Representation::External(), // api_function_address
376 data->Initialize(arraysize(registers), registers, representations,
377 &default_descriptor);
380 } // namespace v8::internal
382 #endif // V8_TARGET_ARCH_ARM