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 |
11 namespace v8 { | 11 namespace v8 { |
12 namespace internal { | 12 namespace internal { |
13 | 13 |
14 const Register CallInterfaceDescriptor::ContextRegister() { return cp; } | 14 const Register CallInterfaceDescriptor::ContextRegister() { return cp; } |
15 | 15 |
16 | 16 |
17 void CallDescriptors::InitializeForIsolate(Isolate* isolate) { | 17 const Register LoadDescriptor::ReceiverRegister() { return x1; } |
18 static PlatformInterfaceDescriptor default_descriptor = | 18 const Register LoadDescriptor::NameRegister() { return x2; } |
19 PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS); | 19 |
20 | 20 |
| 21 const Register VectorLoadICDescriptor::ReceiverRegister() { |
| 22 return LoadDescriptor::ReceiverRegister(); |
| 23 } |
| 24 |
| 25 |
| 26 const Register VectorLoadICDescriptor::NameRegister() { |
| 27 return LoadDescriptor::NameRegister(); |
| 28 } |
| 29 |
| 30 |
| 31 const Register VectorLoadICDescriptor::SlotRegister() { return x0; } |
| 32 const Register VectorLoadICDescriptor::VectorRegister() { return x3; } |
| 33 |
| 34 |
| 35 const Register StoreDescriptor::ReceiverRegister() { return x1; } |
| 36 const Register StoreDescriptor::NameRegister() { return x2; } |
| 37 const Register StoreDescriptor::ValueRegister() { return x0; } |
| 38 |
| 39 |
| 40 const Register ElementTransitionAndStoreDescriptor::ReceiverRegister() { |
| 41 return StoreDescriptor::ReceiverRegister(); |
| 42 } |
| 43 |
| 44 |
| 45 const Register ElementTransitionAndStoreDescriptor::NameRegister() { |
| 46 return StoreDescriptor::NameRegister(); |
| 47 } |
| 48 |
| 49 |
| 50 const Register ElementTransitionAndStoreDescriptor::ValueRegister() { |
| 51 return StoreDescriptor::ValueRegister(); |
| 52 } |
| 53 |
| 54 |
| 55 const Register ElementTransitionAndStoreDescriptor::MapRegister() { return x3; } |
| 56 |
| 57 |
| 58 const Register InstanceofDescriptor::left() { |
| 59 // Object to check (instanceof lhs). |
| 60 return x11; |
| 61 } |
| 62 |
| 63 |
| 64 const Register InstanceofDescriptor::right() { |
| 65 // Constructor function (instanceof rhs). |
| 66 return x10; |
| 67 } |
| 68 |
| 69 |
| 70 void FastNewClosureDescriptor::Initialize(Isolate* isolate) { |
| 71 // cp: context |
| 72 // x2: function info |
| 73 Register registers[] = {cp, x2}; |
| 74 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 75 } |
| 76 |
| 77 |
| 78 void FastNewContextDescriptor::Initialize(Isolate* isolate) { |
| 79 // cp: context |
| 80 // x1: function |
| 81 Register registers[] = {cp, x1}; |
| 82 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 83 } |
| 84 |
| 85 |
| 86 void ToNumberDescriptor::Initialize(Isolate* isolate) { |
| 87 // cp: context |
| 88 // x0: value |
| 89 Register registers[] = {cp, x0}; |
| 90 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 91 } |
| 92 |
| 93 |
| 94 void NumberToStringDescriptor::Initialize(Isolate* isolate) { |
| 95 // cp: context |
| 96 // x0: value |
| 97 Register registers[] = {cp, x0}; |
| 98 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 99 } |
| 100 |
| 101 |
| 102 void FastCloneShallowArrayDescriptor::Initialize(Isolate* isolate) { |
| 103 // cp: context |
| 104 // x3: array literals array |
| 105 // x2: array literal index |
| 106 // x1: constant elements |
| 107 Register registers[] = {cp, x3, x2, x1}; |
| 108 Representation representations[] = { |
| 109 Representation::Tagged(), Representation::Tagged(), Representation::Smi(), |
| 110 Representation::Tagged()}; |
| 111 InitializeData(isolate, key(), arraysize(registers), registers, |
| 112 representations); |
| 113 } |
| 114 |
| 115 |
| 116 void FastCloneShallowObjectDescriptor::Initialize(Isolate* isolate) { |
| 117 // cp: context |
| 118 // x3: object literals array |
| 119 // x2: object literal index |
| 120 // x1: constant properties |
| 121 // x0: object literal flags |
| 122 Register registers[] = {cp, x3, x2, x1, x0}; |
| 123 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 124 } |
| 125 |
| 126 |
| 127 void CreateAllocationSiteDescriptor::Initialize(Isolate* isolate) { |
| 128 // cp: context |
| 129 // x2: feedback vector |
| 130 // x3: call feedback slot |
| 131 Register registers[] = {cp, x2, x3}; |
| 132 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 133 } |
| 134 |
| 135 |
| 136 void CallFunctionDescriptor::Initialize(Isolate* isolate) { |
| 137 // x1 function the function to call |
| 138 Register registers[] = {cp, x1}; |
| 139 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 140 } |
| 141 |
| 142 |
| 143 void CallConstructDescriptor::Initialize(Isolate* isolate) { |
| 144 // x0 : number of arguments |
| 145 // x1 : the function to call |
| 146 // x2 : feedback vector |
| 147 // x3 : slot in feedback vector (smi) (if r2 is not the megamorphic symbol) |
| 148 // TODO(turbofan): So far we don't gather type feedback and hence skip the |
| 149 // slot parameter, but ArrayConstructStub needs the vector to be undefined. |
| 150 Register registers[] = {cp, x0, x1, x2}; |
| 151 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 152 } |
| 153 |
| 154 |
| 155 void RegExpConstructResultDescriptor::Initialize(Isolate* isolate) { |
| 156 // cp: context |
| 157 // x2: length |
| 158 // x1: index (of last match) |
| 159 // x0: string |
| 160 Register registers[] = {cp, x2, x1, x0}; |
| 161 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 162 } |
| 163 |
| 164 |
| 165 void TransitionElementsKindDescriptor::Initialize(Isolate* isolate) { |
| 166 // cp: context |
| 167 // x0: value (js_array) |
| 168 // x1: to_map |
| 169 Register registers[] = {cp, x0, x1}; |
| 170 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 171 } |
| 172 |
| 173 |
| 174 void ArrayConstructorConstantArgCountDescriptor::Initialize(Isolate* isolate) { |
| 175 // cp: context |
| 176 // x1: function |
| 177 // x2: allocation site with elements kind |
| 178 // x0: number of arguments to the constructor function |
| 179 Register registers[] = {cp, x1, x2}; |
| 180 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 181 } |
| 182 |
| 183 |
| 184 void ArrayConstructorDescriptor::Initialize(Isolate* isolate) { |
| 185 // stack param count needs (constructor pointer, and single argument) |
| 186 Register registers[] = {cp, x1, x2, x0}; |
| 187 Representation representations[] = { |
| 188 Representation::Tagged(), Representation::Tagged(), |
| 189 Representation::Tagged(), Representation::Integer32()}; |
| 190 InitializeData(isolate, key(), arraysize(registers), registers, |
| 191 representations); |
| 192 } |
| 193 |
| 194 |
| 195 void InternalArrayConstructorConstantArgCountDescriptor::Initialize( |
| 196 Isolate* isolate) { |
| 197 // cp: context |
| 198 // x1: constructor function |
| 199 // x0: number of arguments to the constructor function |
| 200 Register registers[] = {cp, x1}; |
| 201 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 202 } |
| 203 |
| 204 |
| 205 void InternalArrayConstructorDescriptor::Initialize(Isolate* isolate) { |
| 206 // stack param count needs (constructor pointer, and single argument) |
| 207 Register registers[] = {cp, x1, x0}; |
| 208 Representation representations[] = {Representation::Tagged(), |
| 209 Representation::Tagged(), |
| 210 Representation::Integer32()}; |
| 211 InitializeData(isolate, key(), arraysize(registers), registers, |
| 212 representations); |
| 213 } |
| 214 |
| 215 |
| 216 void CompareNilDescriptor::Initialize(Isolate* isolate) { |
| 217 // cp: context |
| 218 // x0: value to compare |
| 219 Register registers[] = {cp, x0}; |
| 220 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 221 } |
| 222 |
| 223 |
| 224 void ToBooleanDescriptor::Initialize(Isolate* isolate) { |
| 225 // cp: context |
| 226 // x0: value |
| 227 Register registers[] = {cp, x0}; |
| 228 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 229 } |
| 230 |
| 231 |
| 232 void BinaryOpDescriptor::Initialize(Isolate* isolate) { |
| 233 // cp: context |
| 234 // x1: left operand |
| 235 // x0: right operand |
| 236 Register registers[] = {cp, x1, x0}; |
| 237 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 238 } |
| 239 |
| 240 |
| 241 void BinaryOpWithAllocationSiteDescriptor::Initialize(Isolate* isolate) { |
| 242 // cp: context |
| 243 // x2: allocation site |
| 244 // x1: left operand |
| 245 // x0: right operand |
| 246 Register registers[] = {cp, x2, x1, x0}; |
| 247 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 248 } |
| 249 |
| 250 |
| 251 void StringAddDescriptor::Initialize(Isolate* isolate) { |
| 252 // cp: context |
| 253 // x1: left operand |
| 254 // x0: right operand |
| 255 Register registers[] = {cp, x1, x0}; |
| 256 InitializeData(isolate, key(), arraysize(registers), registers, NULL); |
| 257 } |
| 258 |
| 259 |
| 260 void KeyedDescriptor::Initialize(Isolate* isolate) { |
21 static PlatformInterfaceDescriptor noInlineDescriptor = | 261 static PlatformInterfaceDescriptor noInlineDescriptor = |
22 PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS); | 262 PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS); |
23 | 263 |
24 InitializeForIsolateAllPlatforms(isolate); | 264 Register registers[] = { |
25 | 265 cp, // context |
26 { | 266 x2, // key |
27 CallInterfaceDescriptor* descriptor = | 267 }; |
28 isolate->call_descriptor(CallDescriptorKey::FastNewClosureCall); | 268 Representation representations[] = { |
29 // cp: context | 269 Representation::Tagged(), // context |
30 // x2: function info | 270 Representation::Tagged(), // key |
31 Register registers[] = {cp, x2}; | 271 }; |
32 descriptor->Initialize(arraysize(registers), registers, NULL); | 272 InitializeData(isolate, key(), arraysize(registers), registers, |
33 } | 273 representations, &noInlineDescriptor); |
34 { | 274 } |
35 CallInterfaceDescriptor* descriptor = | 275 |
36 isolate->call_descriptor(CallDescriptorKey::FastNewContextCall); | 276 |
37 // cp: context | 277 void NamedDescriptor::Initialize(Isolate* isolate) { |
38 // x1: function | 278 static PlatformInterfaceDescriptor noInlineDescriptor = |
39 Register registers[] = {cp, x1}; | 279 PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS); |
40 descriptor->Initialize(arraysize(registers), registers, NULL); | 280 |
41 } | 281 Register registers[] = { |
42 { | 282 cp, // context |
43 CallInterfaceDescriptor* descriptor = | 283 x2, // name |
44 isolate->call_descriptor(CallDescriptorKey::ToNumberCall); | 284 }; |
45 // cp: context | 285 Representation representations[] = { |
46 // x0: value | 286 Representation::Tagged(), // context |
47 Register registers[] = {cp, x0}; | 287 Representation::Tagged(), // name |
48 descriptor->Initialize(arraysize(registers), registers, NULL); | 288 }; |
49 } | 289 InitializeData(isolate, key(), arraysize(registers), registers, |
50 { | 290 representations, &noInlineDescriptor); |
51 CallInterfaceDescriptor* descriptor = | 291 } |
52 isolate->call_descriptor(CallDescriptorKey::NumberToStringCall); | 292 |
53 // cp: context | 293 |
54 // x0: value | 294 void CallHandlerDescriptor::Initialize(Isolate* isolate) { |
55 Register registers[] = {cp, x0}; | 295 Register registers[] = { |
56 descriptor->Initialize(arraysize(registers), registers, NULL); | 296 cp, // context |
57 } | 297 x0, // receiver |
58 { | 298 }; |
59 CallInterfaceDescriptor* descriptor = | 299 Representation representations[] = { |
60 isolate->call_descriptor(CallDescriptorKey::FastCloneShallowArrayCall); | 300 Representation::Tagged(), // context |
61 // cp: context | 301 Representation::Tagged(), // receiver |
62 // x3: array literals array | 302 }; |
63 // x2: array literal index | 303 InitializeData(isolate, key(), arraysize(registers), registers, |
64 // x1: constant elements | 304 representations); |
65 Register registers[] = {cp, x3, x2, x1}; | 305 } |
66 Representation representations[] = { | 306 |
67 Representation::Tagged(), Representation::Tagged(), | 307 |
68 Representation::Smi(), Representation::Tagged()}; | 308 void ArgumentAdaptorDescriptor::Initialize(Isolate* isolate) { |
69 descriptor->Initialize(arraysize(registers), registers, representations); | 309 Register registers[] = { |
70 } | 310 cp, // context |
71 { | 311 x1, // JSFunction |
72 CallInterfaceDescriptor* descriptor = | 312 x0, // actual number of arguments |
73 isolate->call_descriptor(CallDescriptorKey::FastCloneShallowObjectCall); | 313 x2, // expected number of arguments |
74 // cp: context | 314 }; |
75 // x3: object literals array | 315 Representation representations[] = { |
76 // x2: object literal index | 316 Representation::Tagged(), // context |
77 // x1: constant properties | 317 Representation::Tagged(), // JSFunction |
78 // x0: object literal flags | 318 Representation::Integer32(), // actual number of arguments |
79 Register registers[] = {cp, x3, x2, x1, x0}; | 319 Representation::Integer32(), // expected number of arguments |
80 descriptor->Initialize(arraysize(registers), registers, NULL); | 320 }; |
81 } | 321 InitializeData(isolate, key(), arraysize(registers), registers, |
82 { | 322 representations); |
83 CallInterfaceDescriptor* descriptor = | 323 } |
84 isolate->call_descriptor(CallDescriptorKey::CreateAllocationSiteCall); | 324 |
85 // cp: context | 325 |
86 // x2: feedback vector | 326 void ApiFunctionDescriptor::Initialize(Isolate* isolate) { |
87 // x3: call feedback slot | 327 Register registers[] = { |
88 Register registers[] = {cp, x2, x3}; | 328 cp, // context |
89 descriptor->Initialize(arraysize(registers), registers, NULL); | 329 x0, // callee |
90 } | 330 x4, // call_data |
91 { | 331 x2, // holder |
92 CallInterfaceDescriptor* descriptor = | 332 x1, // api_function_address |
93 isolate->call_descriptor(CallDescriptorKey::CallFunctionCall); | 333 }; |
94 // x1 function the function to call | 334 Representation representations[] = { |
95 Register registers[] = {cp, x1}; | 335 Representation::Tagged(), // context |
96 descriptor->Initialize(arraysize(registers), registers, NULL); | 336 Representation::Tagged(), // callee |
97 } | 337 Representation::Tagged(), // call_data |
98 { | 338 Representation::Tagged(), // holder |
99 CallInterfaceDescriptor* descriptor = | 339 Representation::External(), // api_function_address |
100 isolate->call_descriptor(CallDescriptorKey::CallConstructCall); | 340 }; |
101 // x0 : number of arguments | 341 InitializeData(isolate, key(), arraysize(registers), registers, |
102 // x1 : the function to call | 342 representations); |
103 // x2 : feedback vector | |
104 // x3 : slot in feedback vector (smi) (if r2 is not the megamorphic symbol) | |
105 // TODO(turbofan): So far we don't gather type feedback and hence skip the | |
106 // slot parameter, but ArrayConstructStub needs the vector to be undefined. | |
107 Register registers[] = {cp, x0, x1, x2}; | |
108 descriptor->Initialize(arraysize(registers), registers, NULL); | |
109 } | |
110 { | |
111 CallInterfaceDescriptor* descriptor = | |
112 isolate->call_descriptor(CallDescriptorKey::RegExpConstructResultCall); | |
113 // cp: context | |
114 // x2: length | |
115 // x1: index (of last match) | |
116 // x0: string | |
117 Register registers[] = {cp, x2, x1, x0}; | |
118 descriptor->Initialize(arraysize(registers), registers, NULL); | |
119 } | |
120 { | |
121 CallInterfaceDescriptor* descriptor = | |
122 isolate->call_descriptor(CallDescriptorKey::TransitionElementsKindCall); | |
123 // cp: context | |
124 // x0: value (js_array) | |
125 // x1: to_map | |
126 Register registers[] = {cp, x0, x1}; | |
127 descriptor->Initialize(arraysize(registers), registers, NULL); | |
128 } | |
129 { | |
130 CallInterfaceDescriptor* descriptor = isolate->call_descriptor( | |
131 CallDescriptorKey::ArrayConstructorConstantArgCountCall); | |
132 // cp: context | |
133 // x1: function | |
134 // x2: allocation site with elements kind | |
135 // x0: number of arguments to the constructor function | |
136 Register registers[] = {cp, x1, x2}; | |
137 descriptor->Initialize(arraysize(registers), registers, NULL); | |
138 } | |
139 { | |
140 CallInterfaceDescriptor* descriptor = | |
141 isolate->call_descriptor(CallDescriptorKey::ArrayConstructorCall); | |
142 // stack param count needs (constructor pointer, and single argument) | |
143 Register registers[] = {cp, x1, x2, x0}; | |
144 Representation representations[] = { | |
145 Representation::Tagged(), Representation::Tagged(), | |
146 Representation::Tagged(), Representation::Integer32()}; | |
147 descriptor->Initialize(arraysize(registers), registers, representations); | |
148 } | |
149 { | |
150 CallInterfaceDescriptor* descriptor = isolate->call_descriptor( | |
151 CallDescriptorKey::InternalArrayConstructorConstantArgCountCall); | |
152 // cp: context | |
153 // x1: constructor function | |
154 // x0: number of arguments to the constructor function | |
155 Register registers[] = {cp, x1}; | |
156 descriptor->Initialize(arraysize(registers), registers, NULL); | |
157 } | |
158 { | |
159 CallInterfaceDescriptor* descriptor = isolate->call_descriptor( | |
160 CallDescriptorKey::InternalArrayConstructorCall); | |
161 // stack param count needs (constructor pointer, and single argument) | |
162 Register registers[] = {cp, x1, x0}; | |
163 Representation representations[] = {Representation::Tagged(), | |
164 Representation::Tagged(), | |
165 Representation::Integer32()}; | |
166 descriptor->Initialize(arraysize(registers), registers, representations); | |
167 } | |
168 { | |
169 CallInterfaceDescriptor* descriptor = | |
170 isolate->call_descriptor(CallDescriptorKey::CompareNilCall); | |
171 // cp: context | |
172 // x0: value to compare | |
173 Register registers[] = {cp, x0}; | |
174 descriptor->Initialize(arraysize(registers), registers, NULL); | |
175 } | |
176 { | |
177 CallInterfaceDescriptor* descriptor = | |
178 isolate->call_descriptor(CallDescriptorKey::ToBooleanCall); | |
179 // cp: context | |
180 // x0: value | |
181 Register registers[] = {cp, x0}; | |
182 descriptor->Initialize(arraysize(registers), registers, NULL); | |
183 } | |
184 { | |
185 CallInterfaceDescriptor* descriptor = | |
186 isolate->call_descriptor(CallDescriptorKey::BinaryOpCall); | |
187 // cp: context | |
188 // x1: left operand | |
189 // x0: right operand | |
190 Register registers[] = {cp, x1, x0}; | |
191 descriptor->Initialize(arraysize(registers), registers, NULL); | |
192 } | |
193 { | |
194 CallInterfaceDescriptor* descriptor = isolate->call_descriptor( | |
195 CallDescriptorKey::BinaryOpWithAllocationSiteCall); | |
196 // cp: context | |
197 // x2: allocation site | |
198 // x1: left operand | |
199 // x0: right operand | |
200 Register registers[] = {cp, x2, x1, x0}; | |
201 descriptor->Initialize(arraysize(registers), registers, NULL); | |
202 } | |
203 { | |
204 CallInterfaceDescriptor* descriptor = | |
205 isolate->call_descriptor(CallDescriptorKey::StringAddCall); | |
206 // cp: context | |
207 // x1: left operand | |
208 // x0: right operand | |
209 Register registers[] = {cp, x1, x0}; | |
210 descriptor->Initialize(arraysize(registers), registers, NULL); | |
211 } | |
212 | |
213 { | |
214 CallInterfaceDescriptor* descriptor = | |
215 isolate->call_descriptor(CallDescriptorKey::ArgumentAdaptorCall); | |
216 Register registers[] = { | |
217 cp, // context | |
218 x1, // JSFunction | |
219 x0, // actual number of arguments | |
220 x2, // expected number of arguments | |
221 }; | |
222 Representation representations[] = { | |
223 Representation::Tagged(), // context | |
224 Representation::Tagged(), // JSFunction | |
225 Representation::Integer32(), // actual number of arguments | |
226 Representation::Integer32(), // expected number of arguments | |
227 }; | |
228 descriptor->Initialize(arraysize(registers), registers, representations, | |
229 &default_descriptor); | |
230 } | |
231 { | |
232 CallInterfaceDescriptor* descriptor = | |
233 isolate->call_descriptor(CallDescriptorKey::KeyedCall); | |
234 Register registers[] = { | |
235 cp, // context | |
236 x2, // key | |
237 }; | |
238 Representation representations[] = { | |
239 Representation::Tagged(), // context | |
240 Representation::Tagged(), // key | |
241 }; | |
242 descriptor->Initialize(arraysize(registers), registers, representations, | |
243 &noInlineDescriptor); | |
244 } | |
245 { | |
246 CallInterfaceDescriptor* descriptor = | |
247 isolate->call_descriptor(CallDescriptorKey::NamedCall); | |
248 Register registers[] = { | |
249 cp, // context | |
250 x2, // name | |
251 }; | |
252 Representation representations[] = { | |
253 Representation::Tagged(), // context | |
254 Representation::Tagged(), // name | |
255 }; | |
256 descriptor->Initialize(arraysize(registers), registers, representations, | |
257 &noInlineDescriptor); | |
258 } | |
259 { | |
260 CallInterfaceDescriptor* descriptor = | |
261 isolate->call_descriptor(CallDescriptorKey::CallHandler); | |
262 Register registers[] = { | |
263 cp, // context | |
264 x0, // receiver | |
265 }; | |
266 Representation representations[] = { | |
267 Representation::Tagged(), // context | |
268 Representation::Tagged(), // receiver | |
269 }; | |
270 descriptor->Initialize(arraysize(registers), registers, representations, | |
271 &default_descriptor); | |
272 } | |
273 { | |
274 CallInterfaceDescriptor* descriptor = | |
275 isolate->call_descriptor(CallDescriptorKey::ApiFunctionCall); | |
276 Register registers[] = { | |
277 cp, // context | |
278 x0, // callee | |
279 x4, // call_data | |
280 x2, // holder | |
281 x1, // api_function_address | |
282 }; | |
283 Representation representations[] = { | |
284 Representation::Tagged(), // context | |
285 Representation::Tagged(), // callee | |
286 Representation::Tagged(), // call_data | |
287 Representation::Tagged(), // holder | |
288 Representation::External(), // api_function_address | |
289 }; | |
290 descriptor->Initialize(arraysize(registers), registers, representations, | |
291 &default_descriptor); | |
292 } | |
293 } | 343 } |
294 } | 344 } |
295 } // namespace v8::internal | 345 } // namespace v8::internal |
296 | 346 |
297 #endif // V8_TARGET_ARCH_ARM64 | 347 #endif // V8_TARGET_ARCH_ARM64 |
OLD | NEW |