OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/v8.h" | 5 #include "src/v8.h" |
6 | 6 |
7 #if V8_TARGET_ARCH_ARM64 | 7 #if V8_TARGET_ARCH_ARM64 |
8 | 8 |
9 #include "src/interface-descriptors.h" | 9 #include "src/interface-descriptors.h" |
10 | 10 |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
61 const Register MathPowTaggedDescriptor::exponent() { return x11; } | 61 const Register MathPowTaggedDescriptor::exponent() { return x11; } |
62 | 62 |
63 | 63 |
64 const Register MathPowIntegerDescriptor::exponent() { return x12; } | 64 const Register MathPowIntegerDescriptor::exponent() { return x12; } |
65 | 65 |
66 | 66 |
67 const Register GrowArrayElementsDescriptor::ObjectRegister() { return x0; } | 67 const Register GrowArrayElementsDescriptor::ObjectRegister() { return x0; } |
68 const Register GrowArrayElementsDescriptor::KeyRegister() { return x3; } | 68 const Register GrowArrayElementsDescriptor::KeyRegister() { return x3; } |
69 | 69 |
70 | 70 |
71 void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 71 void FastNewClosureDescriptor::InitializePlatformSpecific( |
| 72 CallInterfaceDescriptorData* data) { |
72 // cp: context | 73 // cp: context |
73 // x2: function info | 74 // x2: function info |
74 Register registers[] = {cp, x2}; | 75 Register registers[] = {cp, x2}; |
75 data->Initialize(arraysize(registers), registers, NULL); | 76 data->InitializePlatformSpecific(arraysize(registers), registers); |
76 } | 77 } |
77 | 78 |
78 | 79 |
79 void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 80 void FastNewContextDescriptor::InitializePlatformSpecific( |
| 81 CallInterfaceDescriptorData* data) { |
80 // cp: context | 82 // cp: context |
81 // x1: function | 83 // x1: function |
82 Register registers[] = {cp, x1}; | 84 Register registers[] = {cp, x1}; |
83 data->Initialize(arraysize(registers), registers, NULL); | 85 data->InitializePlatformSpecific(arraysize(registers), registers); |
84 } | 86 } |
85 | 87 |
86 | 88 |
87 void ToNumberDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 89 void ToNumberDescriptor::InitializePlatformSpecific( |
| 90 CallInterfaceDescriptorData* data) { |
88 // cp: context | 91 // cp: context |
89 // x0: value | 92 // x0: value |
90 Register registers[] = {cp, x0}; | 93 Register registers[] = {cp, x0}; |
91 data->Initialize(arraysize(registers), registers, NULL); | 94 data->InitializePlatformSpecific(arraysize(registers), registers); |
92 } | 95 } |
93 | 96 |
94 | 97 |
95 void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 98 void NumberToStringDescriptor::InitializePlatformSpecific( |
| 99 CallInterfaceDescriptorData* data) { |
96 // cp: context | 100 // cp: context |
97 // x0: value | 101 // x0: value |
98 Register registers[] = {cp, x0}; | 102 Register registers[] = {cp, x0}; |
99 data->Initialize(arraysize(registers), registers, NULL); | 103 data->InitializePlatformSpecific(arraysize(registers), registers); |
100 } | 104 } |
101 | 105 |
102 | 106 |
103 void TypeofDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 107 void TypeofDescriptor::InitializePlatformSpecific( |
| 108 CallInterfaceDescriptorData* data) { |
104 Register registers[] = {cp, x3}; | 109 Register registers[] = {cp, x3}; |
105 data->Initialize(arraysize(registers), registers, NULL); | 110 data->InitializePlatformSpecific(arraysize(registers), registers); |
106 } | 111 } |
107 | 112 |
108 | 113 |
109 void FastCloneShallowArrayDescriptor::Initialize( | 114 void FastCloneShallowArrayDescriptor::InitializePlatformSpecific( |
110 CallInterfaceDescriptorData* data) { | 115 CallInterfaceDescriptorData* data) { |
111 // cp: context | 116 // cp: context |
112 // x3: array literals array | 117 // x3: array literals array |
113 // x2: array literal index | 118 // x2: array literal index |
114 // x1: constant elements | 119 // x1: constant elements |
115 Register registers[] = {cp, x3, x2, x1}; | 120 Register registers[] = {cp, x3, x2, x1}; |
116 Representation representations[] = { | 121 data->InitializePlatformSpecific(arraysize(registers), registers); |
117 Representation::Tagged(), Representation::Tagged(), Representation::Smi(), | |
118 Representation::Tagged()}; | |
119 data->Initialize(arraysize(registers), registers, representations); | |
120 } | 122 } |
121 | 123 |
122 | 124 |
123 void FastCloneShallowObjectDescriptor::Initialize( | 125 void FastCloneShallowObjectDescriptor::InitializePlatformSpecific( |
124 CallInterfaceDescriptorData* data) { | 126 CallInterfaceDescriptorData* data) { |
125 // cp: context | 127 // cp: context |
126 // x3: object literals array | 128 // x3: object literals array |
127 // x2: object literal index | 129 // x2: object literal index |
128 // x1: constant properties | 130 // x1: constant properties |
129 // x0: object literal flags | 131 // x0: object literal flags |
130 Register registers[] = {cp, x3, x2, x1, x0}; | 132 Register registers[] = {cp, x3, x2, x1, x0}; |
131 data->Initialize(arraysize(registers), registers, NULL); | 133 data->InitializePlatformSpecific(arraysize(registers), registers); |
132 } | 134 } |
133 | 135 |
134 | 136 |
135 void CreateAllocationSiteDescriptor::Initialize( | 137 void CreateAllocationSiteDescriptor::InitializePlatformSpecific( |
136 CallInterfaceDescriptorData* data) { | 138 CallInterfaceDescriptorData* data) { |
137 // cp: context | 139 // cp: context |
138 // x2: feedback vector | 140 // x2: feedback vector |
139 // x3: call feedback slot | 141 // x3: call feedback slot |
140 Register registers[] = {cp, x2, x3}; | 142 Register registers[] = {cp, x2, x3}; |
141 Representation representations[] = {Representation::Tagged(), | 143 data->InitializePlatformSpecific(arraysize(registers), registers); |
142 Representation::Tagged(), | |
143 Representation::Smi()}; | |
144 data->Initialize(arraysize(registers), registers, representations); | |
145 } | 144 } |
146 | 145 |
147 | 146 |
148 void CreateWeakCellDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 147 void CreateWeakCellDescriptor::InitializePlatformSpecific( |
| 148 CallInterfaceDescriptorData* data) { |
149 // cp: context | 149 // cp: context |
150 // x2: feedback vector | 150 // x2: feedback vector |
151 // x3: call feedback slot | 151 // x3: call feedback slot |
152 // x1: tagged value to put in the weak cell | 152 // x1: tagged value to put in the weak cell |
153 Register registers[] = {cp, x2, x3, x1}; | 153 Register registers[] = {cp, x2, x3, x1}; |
154 Representation representations[] = { | 154 data->InitializePlatformSpecific(arraysize(registers), registers); |
155 Representation::Tagged(), Representation::Tagged(), Representation::Smi(), | |
156 Representation::Tagged()}; | |
157 data->Initialize(arraysize(registers), registers, representations); | |
158 } | 155 } |
159 | 156 |
160 | 157 |
161 void StoreArrayLiteralElementDescriptor::Initialize( | 158 void StoreArrayLiteralElementDescriptor::InitializePlatformSpecific( |
162 CallInterfaceDescriptorData* data) { | 159 CallInterfaceDescriptorData* data) { |
163 Register registers[] = {cp, x3, x0}; | 160 Register registers[] = {cp, x3, x0}; |
164 data->Initialize(arraysize(registers), registers, NULL); | 161 data->InitializePlatformSpecific(arraysize(registers), registers); |
165 } | 162 } |
166 | 163 |
167 | 164 |
168 void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 165 void CallFunctionDescriptor::InitializePlatformSpecific( |
| 166 CallInterfaceDescriptorData* data) { |
169 // x1 function the function to call | 167 // x1 function the function to call |
170 Register registers[] = {cp, x1}; | 168 Register registers[] = {cp, x1}; |
171 data->Initialize(arraysize(registers), registers, NULL); | 169 data->InitializePlatformSpecific(arraysize(registers), registers); |
172 } | 170 } |
173 | 171 |
174 | 172 |
175 void CallFunctionWithFeedbackDescriptor::Initialize( | 173 void CallFunctionWithFeedbackDescriptor::InitializePlatformSpecific( |
176 CallInterfaceDescriptorData* data) { | 174 CallInterfaceDescriptorData* data) { |
177 Register registers[] = {cp, x1, x3}; | 175 Register registers[] = {cp, x1, x3}; |
178 Representation representations[] = {Representation::Tagged(), | 176 data->InitializePlatformSpecific(arraysize(registers), registers); |
179 Representation::Tagged(), | |
180 Representation::Smi()}; | |
181 data->Initialize(arraysize(registers), registers, representations); | |
182 } | 177 } |
183 | 178 |
184 | 179 |
185 void CallFunctionWithFeedbackAndVectorDescriptor::Initialize( | 180 void CallFunctionWithFeedbackAndVectorDescriptor::InitializePlatformSpecific( |
186 CallInterfaceDescriptorData* data) { | 181 CallInterfaceDescriptorData* data) { |
187 Register registers[] = {cp, x1, x3, x2}; | 182 Register registers[] = {cp, x1, x3, x2}; |
188 Representation representations[] = { | 183 data->InitializePlatformSpecific(arraysize(registers), registers); |
189 Representation::Tagged(), Representation::Tagged(), Representation::Smi(), | |
190 Representation::Tagged()}; | |
191 data->Initialize(arraysize(registers), registers, representations); | |
192 } | 184 } |
193 | 185 |
194 | 186 |
195 void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 187 void CallConstructDescriptor::InitializePlatformSpecific( |
| 188 CallInterfaceDescriptorData* data) { |
196 // x0 : number of arguments | 189 // x0 : number of arguments |
197 // x1 : the function to call | 190 // x1 : the function to call |
198 // x2 : feedback vector | 191 // x2 : feedback vector |
199 // x3 : slot in feedback vector (smi) (if r2 is not the megamorphic symbol) | 192 // x3 : slot in feedback vector (smi) (if r2 is not the megamorphic symbol) |
200 // TODO(turbofan): So far we don't gather type feedback and hence skip the | 193 // TODO(turbofan): So far we don't gather type feedback and hence skip the |
201 // slot parameter, but ArrayConstructStub needs the vector to be undefined. | 194 // slot parameter, but ArrayConstructStub needs the vector to be undefined. |
202 Register registers[] = {cp, x0, x1, x2}; | 195 Register registers[] = {cp, x0, x1, x2}; |
203 data->Initialize(arraysize(registers), registers, NULL); | 196 data->InitializePlatformSpecific(arraysize(registers), registers); |
204 } | 197 } |
205 | 198 |
206 | 199 |
207 void RegExpConstructResultDescriptor::Initialize( | 200 void RegExpConstructResultDescriptor::InitializePlatformSpecific( |
208 CallInterfaceDescriptorData* data) { | 201 CallInterfaceDescriptorData* data) { |
209 // cp: context | 202 // cp: context |
210 // x2: length | 203 // x2: length |
211 // x1: index (of last match) | 204 // x1: index (of last match) |
212 // x0: string | 205 // x0: string |
213 Register registers[] = {cp, x2, x1, x0}; | 206 Register registers[] = {cp, x2, x1, x0}; |
214 data->Initialize(arraysize(registers), registers, NULL); | 207 data->InitializePlatformSpecific(arraysize(registers), registers); |
215 } | 208 } |
216 | 209 |
217 | 210 |
218 void TransitionElementsKindDescriptor::Initialize( | 211 void TransitionElementsKindDescriptor::InitializePlatformSpecific( |
219 CallInterfaceDescriptorData* data) { | 212 CallInterfaceDescriptorData* data) { |
220 // cp: context | 213 // cp: context |
221 // x0: value (js_array) | 214 // x0: value (js_array) |
222 // x1: to_map | 215 // x1: to_map |
223 Register registers[] = {cp, x0, x1}; | 216 Register registers[] = {cp, x0, x1}; |
224 data->Initialize(arraysize(registers), registers, NULL); | 217 data->InitializePlatformSpecific(arraysize(registers), registers); |
225 } | 218 } |
226 | 219 |
227 | 220 |
228 void AllocateHeapNumberDescriptor::Initialize( | 221 void AllocateHeapNumberDescriptor::InitializePlatformSpecific( |
229 CallInterfaceDescriptorData* data) { | 222 CallInterfaceDescriptorData* data) { |
230 // cp: context | 223 // cp: context |
231 Register registers[] = {cp}; | 224 Register registers[] = {cp}; |
232 data->Initialize(arraysize(registers), registers, nullptr); | 225 data->InitializePlatformSpecific(arraysize(registers), registers, nullptr); |
233 } | 226 } |
234 | 227 |
235 | 228 |
236 void ArrayConstructorConstantArgCountDescriptor::Initialize( | 229 void ArrayConstructorConstantArgCountDescriptor::InitializePlatformSpecific( |
237 CallInterfaceDescriptorData* data) { | 230 CallInterfaceDescriptorData* data) { |
238 // cp: context | 231 // cp: context |
239 // x1: function | 232 // x1: function |
240 // x2: allocation site with elements kind | 233 // x2: allocation site with elements kind |
241 // x0: number of arguments to the constructor function | 234 // x0: number of arguments to the constructor function |
242 Register registers[] = {cp, x1, x2}; | 235 Register registers[] = {cp, x1, x2}; |
243 data->Initialize(arraysize(registers), registers, NULL); | 236 data->InitializePlatformSpecific(arraysize(registers), registers); |
244 } | 237 } |
245 | 238 |
246 | 239 |
247 void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 240 void ArrayConstructorDescriptor::InitializePlatformSpecific( |
| 241 CallInterfaceDescriptorData* data) { |
248 // stack param count needs (constructor pointer, and single argument) | 242 // stack param count needs (constructor pointer, and single argument) |
249 Register registers[] = {cp, x1, x2, x0}; | 243 Register registers[] = {cp, x1, x2, x0}; |
250 Representation representations[] = { | 244 data->InitializePlatformSpecific(arraysize(registers), registers); |
251 Representation::Tagged(), Representation::Tagged(), | |
252 Representation::Tagged(), Representation::Integer32()}; | |
253 data->Initialize(arraysize(registers), registers, representations); | |
254 } | 245 } |
255 | 246 |
256 | 247 |
257 void InternalArrayConstructorConstantArgCountDescriptor::Initialize( | 248 void InternalArrayConstructorConstantArgCountDescriptor:: |
258 CallInterfaceDescriptorData* data) { | 249 InitializePlatformSpecific(CallInterfaceDescriptorData* data) { |
259 // cp: context | 250 // cp: context |
260 // x1: constructor function | 251 // x1: constructor function |
261 // x0: number of arguments to the constructor function | 252 // x0: number of arguments to the constructor function |
262 Register registers[] = {cp, x1}; | 253 Register registers[] = {cp, x1}; |
263 data->Initialize(arraysize(registers), registers, NULL); | 254 data->InitializePlatformSpecific(arraysize(registers), registers); |
264 } | 255 } |
265 | 256 |
266 | 257 |
267 void InternalArrayConstructorDescriptor::Initialize( | 258 void InternalArrayConstructorDescriptor::InitializePlatformSpecific( |
268 CallInterfaceDescriptorData* data) { | 259 CallInterfaceDescriptorData* data) { |
269 // stack param count needs (constructor pointer, and single argument) | 260 // stack param count needs (constructor pointer, and single argument) |
270 Register registers[] = {cp, x1, x0}; | 261 Register registers[] = {cp, x1, x0}; |
271 Representation representations[] = {Representation::Tagged(), | 262 data->InitializePlatformSpecific(arraysize(registers), registers); |
272 Representation::Tagged(), | |
273 Representation::Integer32()}; | |
274 data->Initialize(arraysize(registers), registers, representations); | |
275 } | 263 } |
276 | 264 |
277 | 265 |
278 void CompareDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 266 void CompareDescriptor::InitializePlatformSpecific( |
| 267 CallInterfaceDescriptorData* data) { |
279 // cp: context | 268 // cp: context |
280 // x1: left operand | 269 // x1: left operand |
281 // x0: right operand | 270 // x0: right operand |
282 Register registers[] = {cp, x1, x0}; | 271 Register registers[] = {cp, x1, x0}; |
283 data->Initialize(arraysize(registers), registers, NULL); | 272 data->InitializePlatformSpecific(arraysize(registers), registers); |
284 } | 273 } |
285 | 274 |
286 | 275 |
287 void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 276 void CompareNilDescriptor::InitializePlatformSpecific( |
| 277 CallInterfaceDescriptorData* data) { |
288 // cp: context | 278 // cp: context |
289 // x0: value to compare | 279 // x0: value to compare |
290 Register registers[] = {cp, x0}; | 280 Register registers[] = {cp, x0}; |
291 data->Initialize(arraysize(registers), registers, NULL); | 281 data->InitializePlatformSpecific(arraysize(registers), registers); |
292 } | 282 } |
293 | 283 |
294 | 284 |
295 void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 285 void ToBooleanDescriptor::InitializePlatformSpecific( |
| 286 CallInterfaceDescriptorData* data) { |
296 // cp: context | 287 // cp: context |
297 // x0: value | 288 // x0: value |
298 Register registers[] = {cp, x0}; | 289 Register registers[] = {cp, x0}; |
299 data->Initialize(arraysize(registers), registers, NULL); | 290 data->InitializePlatformSpecific(arraysize(registers), registers); |
300 } | 291 } |
301 | 292 |
302 | 293 |
303 void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 294 void BinaryOpDescriptor::InitializePlatformSpecific( |
| 295 CallInterfaceDescriptorData* data) { |
304 // cp: context | 296 // cp: context |
305 // x1: left operand | 297 // x1: left operand |
306 // x0: right operand | 298 // x0: right operand |
307 Register registers[] = {cp, x1, x0}; | 299 Register registers[] = {cp, x1, x0}; |
308 data->Initialize(arraysize(registers), registers, NULL); | 300 data->InitializePlatformSpecific(arraysize(registers), registers); |
309 } | 301 } |
310 | 302 |
311 | 303 |
312 void BinaryOpWithAllocationSiteDescriptor::Initialize( | 304 void BinaryOpWithAllocationSiteDescriptor::InitializePlatformSpecific( |
313 CallInterfaceDescriptorData* data) { | 305 CallInterfaceDescriptorData* data) { |
314 // cp: context | 306 // cp: context |
315 // x2: allocation site | 307 // x2: allocation site |
316 // x1: left operand | 308 // x1: left operand |
317 // x0: right operand | 309 // x0: right operand |
318 Register registers[] = {cp, x2, x1, x0}; | 310 Register registers[] = {cp, x2, x1, x0}; |
319 data->Initialize(arraysize(registers), registers, NULL); | 311 data->InitializePlatformSpecific(arraysize(registers), registers); |
320 } | 312 } |
321 | 313 |
322 | 314 |
323 void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 315 void StringAddDescriptor::InitializePlatformSpecific( |
| 316 CallInterfaceDescriptorData* data) { |
324 // cp: context | 317 // cp: context |
325 // x1: left operand | 318 // x1: left operand |
326 // x0: right operand | 319 // x0: right operand |
327 Register registers[] = {cp, x1, x0}; | 320 Register registers[] = {cp, x1, x0}; |
328 data->Initialize(arraysize(registers), registers, NULL); | 321 data->InitializePlatformSpecific(arraysize(registers), registers); |
329 } | 322 } |
330 | 323 |
331 | 324 |
332 void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 325 void KeyedDescriptor::InitializePlatformSpecific( |
| 326 CallInterfaceDescriptorData* data) { |
333 static PlatformInterfaceDescriptor noInlineDescriptor = | 327 static PlatformInterfaceDescriptor noInlineDescriptor = |
334 PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS); | 328 PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS); |
335 | 329 |
336 Register registers[] = { | 330 Register registers[] = { |
337 cp, // context | 331 cp, // context |
338 x2, // key | 332 x2, // key |
339 }; | 333 }; |
340 Representation representations[] = { | 334 data->InitializePlatformSpecific(arraysize(registers), registers, |
341 Representation::Tagged(), // context | 335 &noInlineDescriptor); |
342 Representation::Tagged(), // key | |
343 }; | |
344 data->Initialize(arraysize(registers), registers, representations, | |
345 &noInlineDescriptor); | |
346 } | 336 } |
347 | 337 |
348 | 338 |
349 void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 339 void NamedDescriptor::InitializePlatformSpecific( |
| 340 CallInterfaceDescriptorData* data) { |
350 static PlatformInterfaceDescriptor noInlineDescriptor = | 341 static PlatformInterfaceDescriptor noInlineDescriptor = |
351 PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS); | 342 PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS); |
352 | 343 |
353 Register registers[] = { | 344 Register registers[] = { |
354 cp, // context | 345 cp, // context |
355 x2, // name | 346 x2, // name |
356 }; | 347 }; |
357 Representation representations[] = { | 348 data->InitializePlatformSpecific(arraysize(registers), registers, |
358 Representation::Tagged(), // context | 349 &noInlineDescriptor); |
359 Representation::Tagged(), // name | |
360 }; | |
361 data->Initialize(arraysize(registers), registers, representations, | |
362 &noInlineDescriptor); | |
363 } | 350 } |
364 | 351 |
365 | 352 |
366 void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 353 void CallHandlerDescriptor::InitializePlatformSpecific( |
| 354 CallInterfaceDescriptorData* data) { |
367 static PlatformInterfaceDescriptor default_descriptor = | 355 static PlatformInterfaceDescriptor default_descriptor = |
368 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS); | 356 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS); |
369 | 357 |
370 Register registers[] = { | 358 Register registers[] = { |
371 cp, // context | 359 cp, // context |
372 x0, // receiver | 360 x0, // receiver |
373 }; | 361 }; |
374 Representation representations[] = { | 362 data->InitializePlatformSpecific(arraysize(registers), registers, |
375 Representation::Tagged(), // context | 363 &default_descriptor); |
376 Representation::Tagged(), // receiver | |
377 }; | |
378 data->Initialize(arraysize(registers), registers, representations, | |
379 &default_descriptor); | |
380 } | 364 } |
381 | 365 |
382 | 366 |
383 void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 367 void ArgumentAdaptorDescriptor::InitializePlatformSpecific( |
| 368 CallInterfaceDescriptorData* data) { |
384 static PlatformInterfaceDescriptor default_descriptor = | 369 static PlatformInterfaceDescriptor default_descriptor = |
385 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS); | 370 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS); |
386 | 371 |
387 Register registers[] = { | 372 Register registers[] = { |
388 cp, // context | 373 cp, // context |
389 x1, // JSFunction | 374 x1, // JSFunction |
390 x0, // actual number of arguments | 375 x0, // actual number of arguments |
391 x2, // expected number of arguments | 376 x2, // expected number of arguments |
392 }; | 377 }; |
393 Representation representations[] = { | 378 data->InitializePlatformSpecific(arraysize(registers), registers, |
394 Representation::Tagged(), // context | 379 &default_descriptor); |
395 Representation::Tagged(), // JSFunction | |
396 Representation::Integer32(), // actual number of arguments | |
397 Representation::Integer32(), // expected number of arguments | |
398 }; | |
399 data->Initialize(arraysize(registers), registers, representations, | |
400 &default_descriptor); | |
401 } | 380 } |
402 | 381 |
403 | 382 |
404 void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 383 void ApiFunctionDescriptor::InitializePlatformSpecific( |
| 384 CallInterfaceDescriptorData* data) { |
405 static PlatformInterfaceDescriptor default_descriptor = | 385 static PlatformInterfaceDescriptor default_descriptor = |
406 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS); | 386 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS); |
407 | 387 |
408 Register registers[] = { | 388 Register registers[] = { |
409 cp, // context | 389 cp, // context |
410 x0, // callee | 390 x0, // callee |
411 x4, // call_data | 391 x4, // call_data |
412 x2, // holder | 392 x2, // holder |
413 x1, // api_function_address | 393 x1, // api_function_address |
414 x3, // actual number of arguments | 394 x3, // actual number of arguments |
415 }; | 395 }; |
416 Representation representations[] = { | 396 data->InitializePlatformSpecific(arraysize(registers), registers, |
417 Representation::Tagged(), // context | 397 &default_descriptor); |
418 Representation::Tagged(), // callee | |
419 Representation::Tagged(), // call_data | |
420 Representation::Tagged(), // holder | |
421 Representation::External(), // api_function_address | |
422 Representation::Integer32(), // actual number of arguments | |
423 }; | |
424 data->Initialize(arraysize(registers), registers, representations, | |
425 &default_descriptor); | |
426 } | 398 } |
427 | 399 |
428 | 400 |
429 void ApiAccessorDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 401 void ApiAccessorDescriptor::InitializePlatformSpecific( |
| 402 CallInterfaceDescriptorData* data) { |
430 static PlatformInterfaceDescriptor default_descriptor = | 403 static PlatformInterfaceDescriptor default_descriptor = |
431 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS); | 404 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS); |
432 | 405 |
433 Register registers[] = { | 406 Register registers[] = { |
434 cp, // context | 407 cp, // context |
435 x0, // callee | 408 x0, // callee |
436 x4, // call_data | 409 x4, // call_data |
437 x2, // holder | 410 x2, // holder |
438 x1, // api_function_address | 411 x1, // api_function_address |
439 }; | 412 }; |
440 Representation representations[] = { | 413 data->InitializePlatformSpecific(arraysize(registers), registers, |
441 Representation::Tagged(), // context | 414 &default_descriptor); |
442 Representation::Tagged(), // callee | |
443 Representation::Tagged(), // call_data | |
444 Representation::Tagged(), // holder | |
445 Representation::External(), // api_function_address | |
446 }; | |
447 data->Initialize(arraysize(registers), registers, representations, | |
448 &default_descriptor); | |
449 } | 415 } |
450 | 416 |
451 | 417 |
452 void MathRoundVariantDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 418 void MathRoundVariantDescriptor::InitializePlatformSpecific( |
| 419 CallInterfaceDescriptorData* data) { |
453 Register registers[] = { | 420 Register registers[] = { |
454 cp, // context | 421 cp, // context |
455 x1, // math rounding function | 422 x1, // math rounding function |
456 x3, // vector slot id | 423 x3, // vector slot id |
457 }; | 424 }; |
458 Representation representations[] = { | 425 data->InitializePlatformSpecific(arraysize(registers), registers); |
459 Representation::Tagged(), // | |
460 Representation::Tagged(), // | |
461 Representation::Tagged(), // | |
462 }; | |
463 data->Initialize(arraysize(registers), registers, representations); | |
464 } | 426 } |
465 } // namespace internal | 427 } // namespace internal |
466 } // namespace v8 | 428 } // namespace v8 |
467 | 429 |
468 #endif // V8_TARGET_ARCH_ARM64 | 430 #endif // V8_TARGET_ARCH_ARM64 |
OLD | NEW |