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