OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
| 2 // |
| 3 // Copyright IBM Corp. 2012, 2013. All rights reserved. |
| 4 // |
2 // Use of this source code is governed by a BSD-style license that can be | 5 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 6 // found in the LICENSE file. |
4 | 7 |
5 #include "src/v8.h" | 8 #include "src/v8.h" |
6 | 9 |
7 #if V8_TARGET_ARCH_MIPS | 10 #if V8_TARGET_ARCH_PPC |
8 | 11 |
9 #include "src/interface-descriptors.h" | 12 #include "src/interface-descriptors.h" |
10 | 13 |
11 namespace v8 { | 14 namespace v8 { |
12 namespace internal { | 15 namespace internal { |
13 | 16 |
14 const Register CallInterfaceDescriptor::ContextRegister() { return cp; } | 17 const Register CallInterfaceDescriptor::ContextRegister() { return cp; } |
15 | 18 |
16 | 19 |
17 const Register LoadDescriptor::ReceiverRegister() { return a1; } | 20 const Register LoadDescriptor::ReceiverRegister() { return r4; } |
18 const Register LoadDescriptor::NameRegister() { return a2; } | 21 const Register LoadDescriptor::NameRegister() { return r5; } |
19 | 22 |
20 | 23 |
21 const Register VectorLoadICTrampolineDescriptor::SlotRegister() { return a0; } | 24 const Register VectorLoadICTrampolineDescriptor::SlotRegister() { return r3; } |
22 | 25 |
23 | 26 |
24 const Register VectorLoadICDescriptor::VectorRegister() { return a3; } | 27 const Register VectorLoadICDescriptor::VectorRegister() { return r6; } |
25 | 28 |
26 | 29 |
27 const Register StoreDescriptor::ReceiverRegister() { return a1; } | 30 const Register StoreDescriptor::ReceiverRegister() { return r4; } |
28 const Register StoreDescriptor::NameRegister() { return a2; } | 31 const Register StoreDescriptor::NameRegister() { return r5; } |
29 const Register StoreDescriptor::ValueRegister() { return a0; } | 32 const Register StoreDescriptor::ValueRegister() { return r3; } |
30 | 33 |
31 | 34 |
32 const Register ElementTransitionAndStoreDescriptor::MapRegister() { return a3; } | 35 const Register ElementTransitionAndStoreDescriptor::MapRegister() { return r6; } |
33 | 36 |
34 | 37 |
35 const Register InstanceofDescriptor::left() { return a0; } | 38 const Register InstanceofDescriptor::left() { return r3; } |
36 const Register InstanceofDescriptor::right() { return a1; } | 39 const Register InstanceofDescriptor::right() { return r4; } |
37 | 40 |
38 | 41 |
39 const Register ArgumentsAccessReadDescriptor::index() { return a1; } | 42 const Register ArgumentsAccessReadDescriptor::index() { return r4; } |
40 const Register ArgumentsAccessReadDescriptor::parameter_count() { return a0; } | 43 const Register ArgumentsAccessReadDescriptor::parameter_count() { return r3; } |
41 | 44 |
42 | 45 |
43 const Register ApiGetterDescriptor::function_address() { return a2; } | 46 const Register ApiGetterDescriptor::function_address() { return r5; } |
44 | 47 |
45 | 48 const Register MathPowTaggedDescriptor::exponent() { return r5; } |
46 const Register MathPowTaggedDescriptor::exponent() { return a2; } | |
47 | 49 |
48 | 50 |
49 const Register MathPowIntegerDescriptor::exponent() { | 51 const Register MathPowIntegerDescriptor::exponent() { |
50 return MathPowTaggedDescriptor::exponent(); | 52 return MathPowTaggedDescriptor::exponent(); |
51 } | 53 } |
52 | 54 |
53 | 55 |
54 void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 56 void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
55 Register registers[] = {cp, a2}; | 57 Register registers[] = {cp, r5}; |
56 data->Initialize(arraysize(registers), registers, NULL); | 58 data->Initialize(arraysize(registers), registers, NULL); |
57 } | 59 } |
58 | 60 |
59 | 61 |
60 void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 62 void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
61 Register registers[] = {cp, a1}; | 63 Register registers[] = {cp, r4}; |
62 data->Initialize(arraysize(registers), registers, NULL); | 64 data->Initialize(arraysize(registers), registers, NULL); |
63 } | 65 } |
64 | 66 |
65 | 67 |
66 void ToNumberDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 68 void ToNumberDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
67 Register registers[] = {cp, a0}; | 69 Register registers[] = {cp, r3}; |
68 data->Initialize(arraysize(registers), registers, NULL); | 70 data->Initialize(arraysize(registers), registers, NULL); |
69 } | 71 } |
70 | 72 |
71 | 73 |
72 void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 74 void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
73 Register registers[] = {cp, a0}; | 75 Register registers[] = {cp, r3}; |
74 data->Initialize(arraysize(registers), registers, NULL); | 76 data->Initialize(arraysize(registers), registers, NULL); |
75 } | 77 } |
76 | 78 |
77 | 79 |
78 void FastCloneShallowArrayDescriptor::Initialize( | 80 void FastCloneShallowArrayDescriptor::Initialize( |
79 CallInterfaceDescriptorData* data) { | 81 CallInterfaceDescriptorData* data) { |
80 Register registers[] = {cp, a3, a2, a1}; | 82 Register registers[] = {cp, r6, r5, r4}; |
81 Representation representations[] = { | 83 Representation representations[] = { |
82 Representation::Tagged(), Representation::Tagged(), Representation::Smi(), | 84 Representation::Tagged(), Representation::Tagged(), Representation::Smi(), |
83 Representation::Tagged()}; | 85 Representation::Tagged()}; |
84 data->Initialize(arraysize(registers), registers, representations); | 86 data->Initialize(arraysize(registers), registers, representations); |
85 } | 87 } |
86 | 88 |
87 | 89 |
88 void FastCloneShallowObjectDescriptor::Initialize( | 90 void FastCloneShallowObjectDescriptor::Initialize( |
89 CallInterfaceDescriptorData* data) { | 91 CallInterfaceDescriptorData* data) { |
90 Register registers[] = {cp, a3, a2, a1, a0}; | 92 Register registers[] = {cp, r6, r5, r4, r3}; |
91 data->Initialize(arraysize(registers), registers, NULL); | 93 data->Initialize(arraysize(registers), registers, NULL); |
92 } | 94 } |
93 | 95 |
94 | 96 |
95 void CreateAllocationSiteDescriptor::Initialize( | 97 void CreateAllocationSiteDescriptor::Initialize( |
96 CallInterfaceDescriptorData* data) { | 98 CallInterfaceDescriptorData* data) { |
97 Register registers[] = {cp, a2, a3}; | 99 Register registers[] = {cp, r5, r6}; |
98 data->Initialize(arraysize(registers), registers, NULL); | 100 data->Initialize(arraysize(registers), registers, NULL); |
99 } | 101 } |
100 | 102 |
101 | 103 |
102 void StoreArrayLiteralElementDescriptor::Initialize( | 104 void StoreArrayLiteralElementDescriptor::Initialize( |
103 CallInterfaceDescriptorData* data) { | 105 CallInterfaceDescriptorData* data) { |
104 Register registers[] = {cp, a3, a0}; | 106 Register registers[] = {cp, r6, r3}; |
105 data->Initialize(arraysize(registers), registers, NULL); | 107 data->Initialize(arraysize(registers), registers, NULL); |
106 } | 108 } |
107 | 109 |
108 | 110 |
109 void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 111 void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
110 Register registers[] = {cp, a1}; | 112 Register registers[] = {cp, r4}; |
111 data->Initialize(arraysize(registers), registers, NULL); | 113 data->Initialize(arraysize(registers), registers, NULL); |
112 } | 114 } |
113 | 115 |
114 | 116 |
115 void CallFunctionWithFeedbackDescriptor::Initialize( | 117 void CallFunctionWithFeedbackDescriptor::Initialize( |
116 CallInterfaceDescriptorData* data) { | 118 CallInterfaceDescriptorData* data) { |
117 Register registers[] = {cp, a1, a3}; | 119 Register registers[] = {cp, r4, r6}; |
118 Representation representations[] = {Representation::Tagged(), | 120 Representation representations[] = {Representation::Tagged(), |
119 Representation::Tagged(), | 121 Representation::Tagged(), |
120 Representation::Smi()}; | 122 Representation::Smi()}; |
121 data->Initialize(arraysize(registers), registers, representations); | 123 data->Initialize(arraysize(registers), registers, representations); |
122 } | 124 } |
123 | 125 |
124 | 126 |
125 void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 127 void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
126 // a0 : number of arguments | 128 // r3 : number of arguments |
127 // a1 : the function to call | 129 // r4 : the function to call |
128 // a2 : feedback vector | 130 // r5 : feedback vector |
129 // a3 : (only if a2 is not the megamorphic symbol) slot in feedback | 131 // r6 : (only if r5 is not the megamorphic symbol) slot in feedback |
130 // vector (Smi) | 132 // vector (Smi) |
131 // TODO(turbofan): So far we don't gather type feedback and hence skip the | 133 // TODO(turbofan): So far we don't gather type feedback and hence skip the |
132 // slot parameter, but ArrayConstructStub needs the vector to be undefined. | 134 // slot parameter, but ArrayConstructStub needs the vector to be undefined. |
133 Register registers[] = {cp, a0, a1, a2}; | 135 Register registers[] = {cp, r3, r4, r5}; |
134 data->Initialize(arraysize(registers), registers, NULL); | 136 data->Initialize(arraysize(registers), registers, NULL); |
135 } | 137 } |
136 | 138 |
137 | 139 |
138 void RegExpConstructResultDescriptor::Initialize( | 140 void RegExpConstructResultDescriptor::Initialize( |
139 CallInterfaceDescriptorData* data) { | 141 CallInterfaceDescriptorData* data) { |
140 Register registers[] = {cp, a2, a1, a0}; | 142 Register registers[] = {cp, r5, r4, r3}; |
141 data->Initialize(arraysize(registers), registers, NULL); | 143 data->Initialize(arraysize(registers), registers, NULL); |
142 } | 144 } |
143 | 145 |
144 | 146 |
145 void TransitionElementsKindDescriptor::Initialize( | 147 void TransitionElementsKindDescriptor::Initialize( |
146 CallInterfaceDescriptorData* data) { | 148 CallInterfaceDescriptorData* data) { |
147 Register registers[] = {cp, a0, a1}; | 149 Register registers[] = {cp, r3, r4}; |
148 data->Initialize(arraysize(registers), registers, NULL); | 150 data->Initialize(arraysize(registers), registers, NULL); |
149 } | 151 } |
150 | 152 |
151 | 153 |
152 void ArrayConstructorConstantArgCountDescriptor::Initialize( | 154 void ArrayConstructorConstantArgCountDescriptor::Initialize( |
153 CallInterfaceDescriptorData* data) { | 155 CallInterfaceDescriptorData* data) { |
154 // register state | 156 // register state |
155 // cp -- context | 157 // cp -- context |
156 // a0 -- number of arguments | 158 // r3 -- number of arguments |
157 // a1 -- function | 159 // r4 -- function |
158 // a2 -- allocation site with elements kind | 160 // r5 -- allocation site with elements kind |
159 Register registers[] = {cp, a1, a2}; | 161 Register registers[] = {cp, r4, r5}; |
160 data->Initialize(arraysize(registers), registers, NULL); | 162 data->Initialize(arraysize(registers), registers, NULL); |
161 } | 163 } |
162 | 164 |
163 | 165 |
164 void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 166 void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
165 // stack param count needs (constructor pointer, and single argument) | 167 // stack param count needs (constructor pointer, and single argument) |
166 Register registers[] = {cp, a1, a2, a0}; | 168 Register registers[] = {cp, r4, r5, r3}; |
167 Representation representations[] = { | 169 Representation representations[] = { |
168 Representation::Tagged(), Representation::Tagged(), | 170 Representation::Tagged(), Representation::Tagged(), |
169 Representation::Tagged(), Representation::Integer32()}; | 171 Representation::Tagged(), Representation::Integer32()}; |
170 data->Initialize(arraysize(registers), registers, representations); | 172 data->Initialize(arraysize(registers), registers, representations); |
171 } | 173 } |
172 | 174 |
173 | 175 |
174 void InternalArrayConstructorConstantArgCountDescriptor::Initialize( | 176 void InternalArrayConstructorConstantArgCountDescriptor::Initialize( |
175 CallInterfaceDescriptorData* data) { | 177 CallInterfaceDescriptorData* data) { |
176 // register state | 178 // register state |
177 // cp -- context | 179 // cp -- context |
178 // a0 -- number of arguments | 180 // r3 -- number of arguments |
179 // a1 -- constructor function | 181 // r4 -- constructor function |
180 Register registers[] = {cp, a1}; | 182 Register registers[] = {cp, r4}; |
181 data->Initialize(arraysize(registers), registers, NULL); | 183 data->Initialize(arraysize(registers), registers, NULL); |
182 } | 184 } |
183 | 185 |
184 | 186 |
185 void InternalArrayConstructorDescriptor::Initialize( | 187 void InternalArrayConstructorDescriptor::Initialize( |
186 CallInterfaceDescriptorData* data) { | 188 CallInterfaceDescriptorData* data) { |
187 // stack param count needs (constructor pointer, and single argument) | 189 // stack param count needs (constructor pointer, and single argument) |
188 Register registers[] = {cp, a1, a0}; | 190 Register registers[] = {cp, r4, r3}; |
189 Representation representations[] = {Representation::Tagged(), | 191 Representation representations[] = {Representation::Tagged(), |
190 Representation::Tagged(), | 192 Representation::Tagged(), |
191 Representation::Integer32()}; | 193 Representation::Integer32()}; |
192 data->Initialize(arraysize(registers), registers, representations); | 194 data->Initialize(arraysize(registers), registers, representations); |
193 } | 195 } |
194 | 196 |
195 | 197 |
196 void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 198 void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
197 Register registers[] = {cp, a0}; | 199 Register registers[] = {cp, r3}; |
198 data->Initialize(arraysize(registers), registers, NULL); | 200 data->Initialize(arraysize(registers), registers, NULL); |
199 } | 201 } |
200 | 202 |
201 | 203 |
202 void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 204 void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
203 Register registers[] = {cp, a0}; | 205 Register registers[] = {cp, r3}; |
204 data->Initialize(arraysize(registers), registers, NULL); | 206 data->Initialize(arraysize(registers), registers, NULL); |
205 } | 207 } |
206 | 208 |
207 | 209 |
208 void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 210 void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
209 Register registers[] = {cp, a1, a0}; | 211 Register registers[] = {cp, r4, r3}; |
210 data->Initialize(arraysize(registers), registers, NULL); | 212 data->Initialize(arraysize(registers), registers, NULL); |
211 } | 213 } |
212 | 214 |
213 | 215 |
214 void BinaryOpWithAllocationSiteDescriptor::Initialize( | 216 void BinaryOpWithAllocationSiteDescriptor::Initialize( |
215 CallInterfaceDescriptorData* data) { | 217 CallInterfaceDescriptorData* data) { |
216 Register registers[] = {cp, a2, a1, a0}; | 218 Register registers[] = {cp, r5, r4, r3}; |
217 data->Initialize(arraysize(registers), registers, NULL); | 219 data->Initialize(arraysize(registers), registers, NULL); |
218 } | 220 } |
219 | 221 |
220 | 222 |
221 void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 223 void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
222 Register registers[] = {cp, a1, a0}; | 224 Register registers[] = {cp, r4, r3}; |
223 data->Initialize(arraysize(registers), registers, NULL); | 225 data->Initialize(arraysize(registers), registers, NULL); |
224 } | 226 } |
225 | 227 |
226 | 228 |
227 void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 229 void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
228 Register registers[] = { | 230 Register registers[] = { |
229 cp, // context | 231 cp, // context |
230 a2, // key | 232 r5, // key |
231 }; | 233 }; |
232 Representation representations[] = { | 234 Representation representations[] = { |
233 Representation::Tagged(), // context | 235 Representation::Tagged(), // context |
234 Representation::Tagged(), // key | 236 Representation::Tagged(), // key |
235 }; | 237 }; |
236 data->Initialize(arraysize(registers), registers, representations); | 238 data->Initialize(arraysize(registers), registers, representations); |
237 } | 239 } |
238 | 240 |
239 | 241 |
240 void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 242 void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
241 Register registers[] = { | 243 Register registers[] = { |
242 cp, // context | 244 cp, // context |
243 a2, // name | 245 r5, // name |
244 }; | 246 }; |
245 Representation representations[] = { | 247 Representation representations[] = { |
246 Representation::Tagged(), // context | 248 Representation::Tagged(), // context |
247 Representation::Tagged(), // name | 249 Representation::Tagged(), // name |
248 }; | 250 }; |
249 data->Initialize(arraysize(registers), registers, representations); | 251 data->Initialize(arraysize(registers), registers, representations); |
250 } | 252 } |
251 | 253 |
252 | 254 |
253 void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 255 void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
254 Register registers[] = { | 256 Register registers[] = { |
255 cp, // context | 257 cp, // context |
256 a0, // receiver | 258 r3, // receiver |
257 }; | 259 }; |
258 Representation representations[] = { | 260 Representation representations[] = { |
259 Representation::Tagged(), // context | 261 Representation::Tagged(), // context |
260 Representation::Tagged(), // receiver | 262 Representation::Tagged(), // receiver |
261 }; | 263 }; |
262 data->Initialize(arraysize(registers), registers, representations); | 264 data->Initialize(arraysize(registers), registers, representations); |
263 } | 265 } |
264 | 266 |
265 | 267 |
266 void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 268 void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
267 Register registers[] = { | 269 Register registers[] = { |
268 cp, // context | 270 cp, // context |
269 a1, // JSFunction | 271 r4, // JSFunction |
270 a0, // actual number of arguments | 272 r3, // actual number of arguments |
271 a2, // expected number of arguments | 273 r5, // expected number of arguments |
272 }; | 274 }; |
273 Representation representations[] = { | 275 Representation representations[] = { |
274 Representation::Tagged(), // context | 276 Representation::Tagged(), // context |
275 Representation::Tagged(), // JSFunction | 277 Representation::Tagged(), // JSFunction |
276 Representation::Integer32(), // actual number of arguments | 278 Representation::Integer32(), // actual number of arguments |
277 Representation::Integer32(), // expected number of arguments | 279 Representation::Integer32(), // expected number of arguments |
278 }; | 280 }; |
279 data->Initialize(arraysize(registers), registers, representations); | 281 data->Initialize(arraysize(registers), registers, representations); |
280 } | 282 } |
281 | 283 |
282 | 284 |
283 void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) { | 285 void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
284 Register registers[] = { | 286 Register registers[] = { |
285 cp, // context | 287 cp, // context |
286 a0, // callee | 288 r3, // callee |
287 t0, // call_data | 289 r7, // call_data |
288 a2, // holder | 290 r5, // holder |
289 a1, // api_function_address | 291 r4, // api_function_address |
290 }; | 292 }; |
291 Representation representations[] = { | 293 Representation representations[] = { |
292 Representation::Tagged(), // context | 294 Representation::Tagged(), // context |
293 Representation::Tagged(), // callee | 295 Representation::Tagged(), // callee |
294 Representation::Tagged(), // call_data | 296 Representation::Tagged(), // call_data |
295 Representation::Tagged(), // holder | 297 Representation::Tagged(), // holder |
296 Representation::External(), // api_function_address | 298 Representation::External(), // api_function_address |
297 }; | 299 }; |
298 data->Initialize(arraysize(registers), registers, representations); | 300 data->Initialize(arraysize(registers), registers, representations); |
299 } | 301 } |
300 } | 302 } |
301 } // namespace v8::internal | 303 } // namespace v8::internal |
302 | 304 |
303 #endif // V8_TARGET_ARCH_MIPS | 305 #endif // V8_TARGET_ARCH_PPC |
OLD | NEW |