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_ARM
8
9 #include "src/interface-descriptors.h"
10
11 namespace v8 {
12 namespace internal {
13
ContextRegister()14 const Register CallInterfaceDescriptor::ContextRegister() { return cp; }
15
16
ReceiverRegister()17 const Register LoadDescriptor::ReceiverRegister() { return r1; }
NameRegister()18 const Register LoadDescriptor::NameRegister() { return r2; }
19
20
SlotRegister()21 const Register VectorLoadICTrampolineDescriptor::SlotRegister() { return r0; }
22
23
VectorRegister()24 const Register VectorLoadICDescriptor::VectorRegister() { return r3; }
25
26
ReceiverRegister()27 const Register StoreDescriptor::ReceiverRegister() { return r1; }
NameRegister()28 const Register StoreDescriptor::NameRegister() { return r2; }
ValueRegister()29 const Register StoreDescriptor::ValueRegister() { return r0; }
30
31
MapRegister()32 const Register ElementTransitionAndStoreDescriptor::MapRegister() { return r3; }
33
34
left()35 const Register InstanceofDescriptor::left() { return r0; }
right()36 const Register InstanceofDescriptor::right() { return r1; }
37
38
index()39 const Register ArgumentsAccessReadDescriptor::index() { return r1; }
parameter_count()40 const Register ArgumentsAccessReadDescriptor::parameter_count() { return r0; }
41
42
function_address()43 const Register ApiGetterDescriptor::function_address() { return r2; }
44
45
exponent()46 const Register MathPowTaggedDescriptor::exponent() { return r2; }
47
48
exponent()49 const Register MathPowIntegerDescriptor::exponent() {
50 return MathPowTaggedDescriptor::exponent();
51 }
52
53
Initialize(CallInterfaceDescriptorData * data)54 void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData* data) {
55 Register registers[] = {cp, r2};
56 data->Initialize(arraysize(registers), registers, NULL);
57 }
58
59
Initialize(CallInterfaceDescriptorData * data)60 void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData* data) {
61 Register registers[] = {cp, r1};
62 data->Initialize(arraysize(registers), registers, NULL);
63 }
64
65
Initialize(CallInterfaceDescriptorData * data)66 void ToNumberDescriptor::Initialize(CallInterfaceDescriptorData* data) {
67 Register registers[] = {cp, r0};
68 data->Initialize(arraysize(registers), registers, NULL);
69 }
70
71
Initialize(CallInterfaceDescriptorData * data)72 void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData* data) {
73 Register registers[] = {cp, r0};
74 data->Initialize(arraysize(registers), registers, NULL);
75 }
76
77
Initialize(CallInterfaceDescriptorData * data)78 void FastCloneShallowArrayDescriptor::Initialize(
79 CallInterfaceDescriptorData* data) {
80 Register registers[] = {cp, r3, r2, r1};
81 Representation representations[] = {
82 Representation::Tagged(), Representation::Tagged(), Representation::Smi(),
83 Representation::Tagged()};
84 data->Initialize(arraysize(registers), registers, representations);
85 }
86
87
Initialize(CallInterfaceDescriptorData * data)88 void FastCloneShallowObjectDescriptor::Initialize(
89 CallInterfaceDescriptorData* data) {
90 Register registers[] = {cp, r3, r2, r1, r0};
91 data->Initialize(arraysize(registers), registers, NULL);
92 }
93
94
Initialize(CallInterfaceDescriptorData * data)95 void CreateAllocationSiteDescriptor::Initialize(
96 CallInterfaceDescriptorData* data) {
97 Register registers[] = {cp, r2, r3};
98 data->Initialize(arraysize(registers), registers, NULL);
99 }
100
101
Initialize(CallInterfaceDescriptorData * data)102 void StoreArrayLiteralElementDescriptor::Initialize(
103 CallInterfaceDescriptorData* data) {
104 Register registers[] = {cp, r3, r0};
105 data->Initialize(arraysize(registers), registers, NULL);
106 }
107
108
Initialize(CallInterfaceDescriptorData * data)109 void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
110 Register registers[] = {cp, r1};
111 data->Initialize(arraysize(registers), registers, NULL);
112 }
113
114
Initialize(CallInterfaceDescriptorData * data)115 void CallFunctionWithFeedbackDescriptor::Initialize(
116 CallInterfaceDescriptorData* data) {
117 Register registers[] = {cp, r1, r3};
118 Representation representations[] = {Representation::Tagged(),
119 Representation::Tagged(),
120 Representation::Smi()};
121 data->Initialize(arraysize(registers), registers, representations);
122 }
123
124
Initialize(CallInterfaceDescriptorData * data)125 void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData* data) {
126 // r0 : number of arguments
127 // r1 : the function to call
128 // r2 : feedback vector
129 // r3 : (only if r2 is not the megamorphic symbol) slot in feedback
130 // vector (Smi)
131 // TODO(turbofan): So far we don't gather type feedback and hence skip the
132 // slot parameter, but ArrayConstructStub needs the vector to be undefined.
133 Register registers[] = {cp, r0, r1, r2};
134 data->Initialize(arraysize(registers), registers, NULL);
135 }
136
137
Initialize(CallInterfaceDescriptorData * data)138 void RegExpConstructResultDescriptor::Initialize(
139 CallInterfaceDescriptorData* data) {
140 Register registers[] = {cp, r2, r1, r0};
141 data->Initialize(arraysize(registers), registers, NULL);
142 }
143
144
Initialize(CallInterfaceDescriptorData * data)145 void TransitionElementsKindDescriptor::Initialize(
146 CallInterfaceDescriptorData* data) {
147 Register registers[] = {cp, r0, r1};
148 data->Initialize(arraysize(registers), registers, NULL);
149 }
150
151
Initialize(CallInterfaceDescriptorData * data)152 void ArrayConstructorConstantArgCountDescriptor::Initialize(
153 CallInterfaceDescriptorData* data) {
154 // register state
155 // cp -- context
156 // r0 -- number of arguments
157 // r1 -- function
158 // r2 -- allocation site with elements kind
159 Register registers[] = {cp, r1, r2};
160 data->Initialize(arraysize(registers), registers, NULL);
161 }
162
163
Initialize(CallInterfaceDescriptorData * data)164 void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
165 // stack param count needs (constructor pointer, and single argument)
166 Register registers[] = {cp, r1, r2, r0};
167 Representation representations[] = {
168 Representation::Tagged(), Representation::Tagged(),
169 Representation::Tagged(), Representation::Integer32()};
170 data->Initialize(arraysize(registers), registers, representations);
171 }
172
173
Initialize(CallInterfaceDescriptorData * data)174 void InternalArrayConstructorConstantArgCountDescriptor::Initialize(
175 CallInterfaceDescriptorData* data) {
176 // register state
177 // cp -- context
178 // r0 -- number of arguments
179 // r1 -- constructor function
180 Register registers[] = {cp, r1};
181 data->Initialize(arraysize(registers), registers, NULL);
182 }
183
184
Initialize(CallInterfaceDescriptorData * data)185 void InternalArrayConstructorDescriptor::Initialize(
186 CallInterfaceDescriptorData* data) {
187 // stack param count needs (constructor pointer, and single argument)
188 Register registers[] = {cp, r1, r0};
189 Representation representations[] = {Representation::Tagged(),
190 Representation::Tagged(),
191 Representation::Integer32()};
192 data->Initialize(arraysize(registers), registers, representations);
193 }
194
195
Initialize(CallInterfaceDescriptorData * data)196 void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) {
197 Register registers[] = {cp, r0};
198 data->Initialize(arraysize(registers), registers, NULL);
199 }
200
201
Initialize(CallInterfaceDescriptorData * data)202 void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) {
203 Register registers[] = {cp, r0};
204 data->Initialize(arraysize(registers), registers, NULL);
205 }
206
207
Initialize(CallInterfaceDescriptorData * data)208 void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) {
209 Register registers[] = {cp, r1, r0};
210 data->Initialize(arraysize(registers), registers, NULL);
211 }
212
213
Initialize(CallInterfaceDescriptorData * data)214 void BinaryOpWithAllocationSiteDescriptor::Initialize(
215 CallInterfaceDescriptorData* data) {
216 Register registers[] = {cp, r2, r1, r0};
217 data->Initialize(arraysize(registers), registers, NULL);
218 }
219
220
Initialize(CallInterfaceDescriptorData * data)221 void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) {
222 Register registers[] = {cp, r1, r0};
223 data->Initialize(arraysize(registers), registers, NULL);
224 }
225
226
Initialize(CallInterfaceDescriptorData * data)227 void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
228 static PlatformInterfaceDescriptor noInlineDescriptor =
229 PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS);
230
231 Register registers[] = {
232 cp, // context
233 r2, // key
234 };
235 Representation representations[] = {
236 Representation::Tagged(), // context
237 Representation::Tagged(), // key
238 };
239 data->Initialize(arraysize(registers), registers, representations,
240 &noInlineDescriptor);
241 }
242
243
Initialize(CallInterfaceDescriptorData * data)244 void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
245 static PlatformInterfaceDescriptor noInlineDescriptor =
246 PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS);
247
248 Register registers[] = {
249 cp, // context
250 r2, // name
251 };
252 Representation representations[] = {
253 Representation::Tagged(), // context
254 Representation::Tagged(), // name
255 };
256 data->Initialize(arraysize(registers), registers, representations,
257 &noInlineDescriptor);
258 }
259
260
Initialize(CallInterfaceDescriptorData * data)261 void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) {
262 static PlatformInterfaceDescriptor default_descriptor =
263 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
264
265 Register registers[] = {
266 cp, // context
267 r0, // receiver
268 };
269 Representation representations[] = {
270 Representation::Tagged(), // context
271 Representation::Tagged(), // receiver
272 };
273 data->Initialize(arraysize(registers), registers, representations,
274 &default_descriptor);
275 }
276
277
Initialize(CallInterfaceDescriptorData * data)278 void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
279 static PlatformInterfaceDescriptor default_descriptor =
280 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
281
282 Register registers[] = {
283 cp, // context
284 r1, // JSFunction
285 r0, // actual number of arguments
286 r2, // expected number of arguments
287 };
288 Representation representations[] = {
289 Representation::Tagged(), // context
290 Representation::Tagged(), // JSFunction
291 Representation::Integer32(), // actual number of arguments
292 Representation::Integer32(), // expected number of arguments
293 };
294 data->Initialize(arraysize(registers), registers, representations,
295 &default_descriptor);
296 }
297
298
Initialize(CallInterfaceDescriptorData * data)299 void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
300 static PlatformInterfaceDescriptor default_descriptor =
301 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
302
303 Register registers[] = {
304 cp, // context
305 r0, // callee
306 r4, // call_data
307 r2, // holder
308 r1, // api_function_address
309 };
310 Representation representations[] = {
311 Representation::Tagged(), // context
312 Representation::Tagged(), // callee
313 Representation::Tagged(), // call_data
314 Representation::Tagged(), // holder
315 Representation::External(), // api_function_address
316 };
317 data->Initialize(arraysize(registers), registers, representations,
318 &default_descriptor);
319 }
320 }
321 } // namespace v8::internal
322
323 #endif // V8_TARGET_ARCH_ARM
324