1 // Copyright 2014 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 #if V8_TARGET_ARCH_PPC
6
7 #include "src/interface-descriptors.h"
8
9 namespace v8 {
10 namespace internal {
11
ContextRegister()12 const Register CallInterfaceDescriptor::ContextRegister() { return cp; }
13
DefaultInitializePlatformSpecific(CallInterfaceDescriptorData * data,int register_parameter_count)14 void CallInterfaceDescriptor::DefaultInitializePlatformSpecific(
15 CallInterfaceDescriptorData* data, int register_parameter_count) {
16 const Register default_stub_registers[] = {r3, r4, r5, r6, r7};
17 CHECK_LE(static_cast<size_t>(register_parameter_count),
18 arraysize(default_stub_registers));
19 data->InitializePlatformSpecific(register_parameter_count,
20 default_stub_registers);
21 }
22
ReceiverRegister()23 const Register LoadDescriptor::ReceiverRegister() { return r4; }
NameRegister()24 const Register LoadDescriptor::NameRegister() { return r5; }
SlotRegister()25 const Register LoadDescriptor::SlotRegister() { return r3; }
26
27
VectorRegister()28 const Register LoadWithVectorDescriptor::VectorRegister() { return r6; }
29
30
ReceiverRegister()31 const Register StoreDescriptor::ReceiverRegister() { return r4; }
NameRegister()32 const Register StoreDescriptor::NameRegister() { return r5; }
ValueRegister()33 const Register StoreDescriptor::ValueRegister() { return r3; }
34
35
SlotRegister()36 const Register VectorStoreICTrampolineDescriptor::SlotRegister() { return r7; }
37
38
VectorRegister()39 const Register VectorStoreICDescriptor::VectorRegister() { return r6; }
40
41
SlotRegister()42 const Register VectorStoreTransitionDescriptor::SlotRegister() { return r7; }
VectorRegister()43 const Register VectorStoreTransitionDescriptor::VectorRegister() { return r6; }
MapRegister()44 const Register VectorStoreTransitionDescriptor::MapRegister() { return r8; }
45
46
MapRegister()47 const Register StoreTransitionDescriptor::MapRegister() { return r6; }
48
49
SlotRegister()50 const Register StoreGlobalViaContextDescriptor::SlotRegister() { return r5; }
ValueRegister()51 const Register StoreGlobalViaContextDescriptor::ValueRegister() { return r3; }
52
53
LeftRegister()54 const Register StringCompareDescriptor::LeftRegister() { return r4; }
RightRegister()55 const Register StringCompareDescriptor::RightRegister() { return r3; }
56
HolderRegister()57 const Register ApiGetterDescriptor::HolderRegister() { return r3; }
CallbackRegister()58 const Register ApiGetterDescriptor::CallbackRegister() { return r6; }
59
exponent()60 const Register MathPowTaggedDescriptor::exponent() { return r5; }
61
62
exponent()63 const Register MathPowIntegerDescriptor::exponent() {
64 return MathPowTaggedDescriptor::exponent();
65 }
66
67
ObjectRegister()68 const Register GrowArrayElementsDescriptor::ObjectRegister() { return r3; }
KeyRegister()69 const Register GrowArrayElementsDescriptor::KeyRegister() { return r6; }
70
InitializePlatformSpecific(CallInterfaceDescriptorData * data)71 void FastNewClosureDescriptor::InitializePlatformSpecific(
72 CallInterfaceDescriptorData* data) {
73 Register registers[] = {r5};
74 data->InitializePlatformSpecific(arraysize(registers), registers);
75 }
76
77
InitializePlatformSpecific(CallInterfaceDescriptorData * data)78 void FastNewContextDescriptor::InitializePlatformSpecific(
79 CallInterfaceDescriptorData* data) {
80 Register registers[] = {r4};
81 data->InitializePlatformSpecific(arraysize(registers), registers);
82 }
83
InitializePlatformSpecific(CallInterfaceDescriptorData * data)84 void FastNewObjectDescriptor::InitializePlatformSpecific(
85 CallInterfaceDescriptorData* data) {
86 Register registers[] = {r4, r6};
87 data->InitializePlatformSpecific(arraysize(registers), registers);
88 }
89
InitializePlatformSpecific(CallInterfaceDescriptorData * data)90 void FastNewRestParameterDescriptor::InitializePlatformSpecific(
91 CallInterfaceDescriptorData* data) {
92 Register registers[] = {r4};
93 data->InitializePlatformSpecific(arraysize(registers), registers);
94 }
95
InitializePlatformSpecific(CallInterfaceDescriptorData * data)96 void FastNewSloppyArgumentsDescriptor::InitializePlatformSpecific(
97 CallInterfaceDescriptorData* data) {
98 Register registers[] = {r4};
99 data->InitializePlatformSpecific(arraysize(registers), registers);
100 }
101
InitializePlatformSpecific(CallInterfaceDescriptorData * data)102 void FastNewStrictArgumentsDescriptor::InitializePlatformSpecific(
103 CallInterfaceDescriptorData* data) {
104 Register registers[] = {r4};
105 data->InitializePlatformSpecific(arraysize(registers), registers);
106 }
107
108
109 // static
ArgumentRegister()110 const Register TypeConversionDescriptor::ArgumentRegister() { return r3; }
111
InitializePlatformSpecific(CallInterfaceDescriptorData * data)112 void TypeofDescriptor::InitializePlatformSpecific(
113 CallInterfaceDescriptorData* data) {
114 Register registers[] = {r6};
115 data->InitializePlatformSpecific(arraysize(registers), registers);
116 }
117
118
InitializePlatformSpecific(CallInterfaceDescriptorData * data)119 void FastCloneRegExpDescriptor::InitializePlatformSpecific(
120 CallInterfaceDescriptorData* data) {
121 Register registers[] = {r6, r5, r4, r3};
122 data->InitializePlatformSpecific(arraysize(registers), registers);
123 }
124
125
InitializePlatformSpecific(CallInterfaceDescriptorData * data)126 void FastCloneShallowArrayDescriptor::InitializePlatformSpecific(
127 CallInterfaceDescriptorData* data) {
128 Register registers[] = {r6, r5, r4};
129 data->InitializePlatformSpecific(arraysize(registers), registers);
130 }
131
132
InitializePlatformSpecific(CallInterfaceDescriptorData * data)133 void FastCloneShallowObjectDescriptor::InitializePlatformSpecific(
134 CallInterfaceDescriptorData* data) {
135 Register registers[] = {r6, r5, r4, r3};
136 data->InitializePlatformSpecific(arraysize(registers), registers);
137 }
138
139
InitializePlatformSpecific(CallInterfaceDescriptorData * data)140 void CreateAllocationSiteDescriptor::InitializePlatformSpecific(
141 CallInterfaceDescriptorData* data) {
142 Register registers[] = {r5, r6};
143 data->InitializePlatformSpecific(arraysize(registers), registers);
144 }
145
146
InitializePlatformSpecific(CallInterfaceDescriptorData * data)147 void CreateWeakCellDescriptor::InitializePlatformSpecific(
148 CallInterfaceDescriptorData* data) {
149 Register registers[] = {r5, r6, r4};
150 data->InitializePlatformSpecific(arraysize(registers), registers);
151 }
152
153
InitializePlatformSpecific(CallInterfaceDescriptorData * data)154 void CallFunctionDescriptor::InitializePlatformSpecific(
155 CallInterfaceDescriptorData* data) {
156 Register registers[] = {r4};
157 data->InitializePlatformSpecific(arraysize(registers), registers);
158 }
159
160
InitializePlatformSpecific(CallInterfaceDescriptorData * data)161 void CallFunctionWithFeedbackDescriptor::InitializePlatformSpecific(
162 CallInterfaceDescriptorData* data) {
163 Register registers[] = {r4, r6};
164 data->InitializePlatformSpecific(arraysize(registers), registers);
165 }
166
167
InitializePlatformSpecific(CallInterfaceDescriptorData * data)168 void CallFunctionWithFeedbackAndVectorDescriptor::InitializePlatformSpecific(
169 CallInterfaceDescriptorData* data) {
170 Register registers[] = {r4, r6, r5};
171 data->InitializePlatformSpecific(arraysize(registers), registers);
172 }
173
174
InitializePlatformSpecific(CallInterfaceDescriptorData * data)175 void CallConstructDescriptor::InitializePlatformSpecific(
176 CallInterfaceDescriptorData* data) {
177 // r3 : number of arguments
178 // r4 : the function to call
179 // r5 : feedback vector
180 // r6 : slot in feedback vector (Smi, for RecordCallTarget)
181 // r7 : new target (for IsSuperConstructorCall)
182 // TODO(turbofan): So far we don't gather type feedback and hence skip the
183 // slot parameter, but ArrayConstructStub needs the vector to be undefined.
184 Register registers[] = {r3, r4, r7, r5};
185 data->InitializePlatformSpecific(arraysize(registers), registers);
186 }
187
188
InitializePlatformSpecific(CallInterfaceDescriptorData * data)189 void CallTrampolineDescriptor::InitializePlatformSpecific(
190 CallInterfaceDescriptorData* data) {
191 // r3 : number of arguments
192 // r4 : the target to call
193 Register registers[] = {r4, r3};
194 data->InitializePlatformSpecific(arraysize(registers), registers);
195 }
196
197
InitializePlatformSpecific(CallInterfaceDescriptorData * data)198 void ConstructStubDescriptor::InitializePlatformSpecific(
199 CallInterfaceDescriptorData* data) {
200 // r3 : number of arguments
201 // r4 : the target to call
202 // r6 : the new target
203 // r5 : allocation site or undefined
204 Register registers[] = {r4, r6, r3, r5};
205 data->InitializePlatformSpecific(arraysize(registers), registers);
206 }
207
208
InitializePlatformSpecific(CallInterfaceDescriptorData * data)209 void ConstructTrampolineDescriptor::InitializePlatformSpecific(
210 CallInterfaceDescriptorData* data) {
211 // r3 : number of arguments
212 // r4 : the target to call
213 // r6 : the new target
214 Register registers[] = {r4, r6, r3};
215 data->InitializePlatformSpecific(arraysize(registers), registers);
216 }
217
218
InitializePlatformSpecific(CallInterfaceDescriptorData * data)219 void RegExpConstructResultDescriptor::InitializePlatformSpecific(
220 CallInterfaceDescriptorData* data) {
221 Register registers[] = {r5, r4, r3};
222 data->InitializePlatformSpecific(arraysize(registers), registers);
223 }
224
225
InitializePlatformSpecific(CallInterfaceDescriptorData * data)226 void TransitionElementsKindDescriptor::InitializePlatformSpecific(
227 CallInterfaceDescriptorData* data) {
228 Register registers[] = {r3, r4};
229 data->InitializePlatformSpecific(arraysize(registers), registers);
230 }
231
232
InitializePlatformSpecific(CallInterfaceDescriptorData * data)233 void AllocateHeapNumberDescriptor::InitializePlatformSpecific(
234 CallInterfaceDescriptorData* data) {
235 data->InitializePlatformSpecific(0, nullptr, nullptr);
236 }
237
238 #define SIMD128_ALLOC_DESC(TYPE, Type, type, lane_count, lane_type) \
239 void Allocate##Type##Descriptor::InitializePlatformSpecific( \
240 CallInterfaceDescriptorData* data) { \
241 data->InitializePlatformSpecific(0, nullptr, nullptr); \
242 }
SIMD128_TYPES(SIMD128_ALLOC_DESC)243 SIMD128_TYPES(SIMD128_ALLOC_DESC)
244 #undef SIMD128_ALLOC_DESC
245
246 void ArrayNoArgumentConstructorDescriptor::InitializePlatformSpecific(
247 CallInterfaceDescriptorData* data) {
248 // register state
249 // r3 -- number of arguments
250 // r4 -- function
251 // r5 -- allocation site with elements kind
252 Register registers[] = {r4, r5, r3};
253 data->InitializePlatformSpecific(arraysize(registers), registers);
254 }
255
InitializePlatformSpecific(CallInterfaceDescriptorData * data)256 void ArraySingleArgumentConstructorDescriptor::InitializePlatformSpecific(
257 CallInterfaceDescriptorData* data) {
258 // register state
259 // r3 -- number of arguments
260 // r4 -- function
261 // r5 -- allocation site with elements kind
262 Register registers[] = {r4, r5, r3};
263 data->InitializePlatformSpecific(arraysize(registers), registers, NULL);
264 }
265
266
InitializePlatformSpecific(CallInterfaceDescriptorData * data)267 void ArrayNArgumentsConstructorDescriptor::InitializePlatformSpecific(
268 CallInterfaceDescriptorData* data) {
269 // stack param count needs (constructor pointer, and single argument)
270 Register registers[] = {r4, r5, r3};
271 data->InitializePlatformSpecific(arraysize(registers), registers);
272 }
273
274
InitializePlatformSpecific(CallInterfaceDescriptorData * data)275 void VarArgFunctionDescriptor::InitializePlatformSpecific(
276 CallInterfaceDescriptorData* data) {
277 // stack param count needs (arg count)
278 Register registers[] = {r3};
279 data->InitializePlatformSpecific(arraysize(registers), registers);
280 }
281
InitializePlatformSpecific(CallInterfaceDescriptorData * data)282 void CompareDescriptor::InitializePlatformSpecific(
283 CallInterfaceDescriptorData* data) {
284 Register registers[] = {r4, r3};
285 data->InitializePlatformSpecific(arraysize(registers), registers);
286 }
287
288
InitializePlatformSpecific(CallInterfaceDescriptorData * data)289 void BinaryOpDescriptor::InitializePlatformSpecific(
290 CallInterfaceDescriptorData* data) {
291 Register registers[] = {r4, r3};
292 data->InitializePlatformSpecific(arraysize(registers), registers);
293 }
294
295
InitializePlatformSpecific(CallInterfaceDescriptorData * data)296 void BinaryOpWithAllocationSiteDescriptor::InitializePlatformSpecific(
297 CallInterfaceDescriptorData* data) {
298 Register registers[] = {r5, r4, r3};
299 data->InitializePlatformSpecific(arraysize(registers), registers);
300 }
301
InitializePlatformSpecific(CallInterfaceDescriptorData * data)302 void CountOpDescriptor::InitializePlatformSpecific(
303 CallInterfaceDescriptorData* data) {
304 Register registers[] = {r4};
305 data->InitializePlatformSpecific(arraysize(registers), registers);
306 }
307
InitializePlatformSpecific(CallInterfaceDescriptorData * data)308 void StringAddDescriptor::InitializePlatformSpecific(
309 CallInterfaceDescriptorData* data) {
310 Register registers[] = {r4, r3};
311 data->InitializePlatformSpecific(arraysize(registers), registers);
312 }
313
314
InitializePlatformSpecific(CallInterfaceDescriptorData * data)315 void KeyedDescriptor::InitializePlatformSpecific(
316 CallInterfaceDescriptorData* data) {
317 Register registers[] = {
318 r5, // key
319 };
320 data->InitializePlatformSpecific(arraysize(registers), registers);
321 }
322
323
InitializePlatformSpecific(CallInterfaceDescriptorData * data)324 void NamedDescriptor::InitializePlatformSpecific(
325 CallInterfaceDescriptorData* data) {
326 Register registers[] = {
327 r5, // name
328 };
329 data->InitializePlatformSpecific(arraysize(registers), registers);
330 }
331
332
InitializePlatformSpecific(CallInterfaceDescriptorData * data)333 void CallHandlerDescriptor::InitializePlatformSpecific(
334 CallInterfaceDescriptorData* data) {
335 Register registers[] = {
336 r3, // receiver
337 };
338 data->InitializePlatformSpecific(arraysize(registers), registers);
339 }
340
341
InitializePlatformSpecific(CallInterfaceDescriptorData * data)342 void ArgumentAdaptorDescriptor::InitializePlatformSpecific(
343 CallInterfaceDescriptorData* data) {
344 Register registers[] = {
345 r4, // JSFunction
346 r6, // the new target
347 r3, // actual number of arguments
348 r5, // expected number of arguments
349 };
350 data->InitializePlatformSpecific(arraysize(registers), registers);
351 }
352
InitializePlatformSpecific(CallInterfaceDescriptorData * data)353 void ApiCallbackDescriptorBase::InitializePlatformSpecific(
354 CallInterfaceDescriptorData* data) {
355 Register registers[] = {
356 r3, // callee
357 r7, // call_data
358 r5, // holder
359 r4, // api_function_address
360 };
361 data->InitializePlatformSpecific(arraysize(registers), registers);
362 }
363
InitializePlatformSpecific(CallInterfaceDescriptorData * data)364 void InterpreterDispatchDescriptor::InitializePlatformSpecific(
365 CallInterfaceDescriptorData* data) {
366 Register registers[] = {
367 kInterpreterAccumulatorRegister, kInterpreterBytecodeOffsetRegister,
368 kInterpreterBytecodeArrayRegister, kInterpreterDispatchTableRegister};
369 data->InitializePlatformSpecific(arraysize(registers), registers);
370 }
371
InitializePlatformSpecific(CallInterfaceDescriptorData * data)372 void InterpreterPushArgsAndCallDescriptor::InitializePlatformSpecific(
373 CallInterfaceDescriptorData* data) {
374 Register registers[] = {
375 r3, // argument count (not including receiver)
376 r5, // address of first argument
377 r4 // the target callable to be call
378 };
379 data->InitializePlatformSpecific(arraysize(registers), registers);
380 }
381
InitializePlatformSpecific(CallInterfaceDescriptorData * data)382 void InterpreterPushArgsAndConstructDescriptor::InitializePlatformSpecific(
383 CallInterfaceDescriptorData* data) {
384 Register registers[] = {
385 r3, // argument count (not including receiver)
386 r6, // new target
387 r4, // constructor to call
388 r5 // address of the first argument
389 };
390 data->InitializePlatformSpecific(arraysize(registers), registers);
391 }
392
InitializePlatformSpecific(CallInterfaceDescriptorData * data)393 void InterpreterCEntryDescriptor::InitializePlatformSpecific(
394 CallInterfaceDescriptorData* data) {
395 Register registers[] = {
396 r3, // argument count (argc)
397 r5, // address of first argument (argv)
398 r4 // the runtime function to call
399 };
400 data->InitializePlatformSpecific(arraysize(registers), registers);
401 }
402
InitializePlatformSpecific(CallInterfaceDescriptorData * data)403 void ResumeGeneratorDescriptor::InitializePlatformSpecific(
404 CallInterfaceDescriptorData* data) {
405 Register registers[] = {
406 r3, // the value to pass to the generator
407 r4, // the JSGeneratorObject to resume
408 r5 // the resume mode (tagged)
409 };
410 data->InitializePlatformSpecific(arraysize(registers), registers);
411 }
412 } // namespace internal
413 } // namespace v8
414
415 #endif // V8_TARGET_ARCH_PPC
416