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