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