• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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