Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(4)

Side by Side Diff: src/ppc/interface-descriptors-ppc.cc

Issue 571173003: PowerPC specific sub-directories (Closed) Base URL: http://v8.googlecode.com/svn/branches/bleeding_edge
Patch Set: Updated ppc sub-dirs to current V8 code levels Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698