1 : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 : * vim: set ts=8 sw=4 et tw=79:
3 : *
4 : * ***** BEGIN LICENSE BLOCK *****
5 : * Copyright (C) 2008 Apple Inc. All rights reserved.
6 : *
7 : * Redistribution and use in source and binary forms, with or without
8 : * modification, are permitted provided that the following conditions
9 : * are met:
10 : * 1. Redistributions of source code must retain the above copyright
11 : * notice, this list of conditions and the following disclaimer.
12 : * 2. Redistributions in binary form must reproduce the above copyright
13 : * notice, this list of conditions and the following disclaimer in the
14 : * documentation and/or other materials provided with the distribution.
15 : *
16 : * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
17 : * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
20 : * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21 : * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22 : * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23 : * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
24 : * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 : * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 : * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 : *
28 : * ***** END LICENSE BLOCK ***** */
29 :
30 : #ifndef MacroAssembler_h
31 : #define MacroAssembler_h
32 :
33 : #include "assembler/wtf/Platform.h"
34 :
35 : #if ENABLE_ASSEMBLER
36 :
37 : #if WTF_CPU_ARM_THUMB2
38 : #include "MacroAssemblerARMv7.h"
39 : namespace JSC { typedef MacroAssemblerARMv7 MacroAssemblerBase; }
40 :
41 : #elif WTF_CPU_ARM_TRADITIONAL
42 : #include "MacroAssemblerARM.h"
43 : namespace JSC { typedef MacroAssemblerARM MacroAssemblerBase; }
44 :
45 : #elif WTF_CPU_MIPS
46 : #include "MacroAssemblerMIPS.h"
47 : namespace JSC { typedef MacroAssemblerMIPS MacroAssemblerBase; }
48 :
49 : #elif WTF_CPU_X86
50 : #include "MacroAssemblerX86.h"
51 : namespace JSC { typedef MacroAssemblerX86 MacroAssemblerBase; }
52 :
53 : #elif WTF_CPU_X86_64
54 : #include "MacroAssemblerX86_64.h"
55 : namespace JSC { typedef MacroAssemblerX86_64 MacroAssemblerBase; }
56 :
57 : #elif WTF_CPU_SPARC
58 : #include "MacroAssemblerSparc.h"
59 : namespace JSC { typedef MacroAssemblerSparc MacroAssemblerBase; }
60 :
61 : #else
62 : #error "The MacroAssembler is not supported on this platform."
63 : #endif
64 :
65 :
66 : namespace JSC {
67 :
68 1526632 : class MacroAssembler : public MacroAssemblerBase {
69 : public:
70 :
71 : using MacroAssemblerBase::pop;
72 : using MacroAssemblerBase::jump;
73 : using MacroAssemblerBase::branch32;
74 : using MacroAssemblerBase::branch16;
75 : #if WTF_CPU_X86_64
76 : using MacroAssemblerBase::branchPtr;
77 : using MacroAssemblerBase::branchTestPtr;
78 : #endif
79 :
80 :
81 : // Platform agnostic onvenience functions,
82 : // described in terms of other macro assembly methods.
83 : void pop()
84 : {
85 : addPtr(Imm32(sizeof(void*)), stackPointerRegister);
86 : }
87 :
88 35313 : void peek(RegisterID dest, int index = 0)
89 : {
90 35313 : loadPtr(Address(stackPointerRegister, (index * sizeof(void*))), dest);
91 35313 : }
92 :
93 44954 : void poke(RegisterID src, int index = 0)
94 : {
95 44954 : storePtr(src, Address(stackPointerRegister, (index * sizeof(void*))));
96 44954 : }
97 :
98 6924 : void poke(TrustedImm32 value, int index = 0)
99 : {
100 6924 : store32(value, Address(stackPointerRegister, (index * sizeof(void*))));
101 6924 : }
102 :
103 : void poke(TrustedImmPtr imm, int index = 0)
104 : {
105 : storePtr(imm, Address(stackPointerRegister, (index * sizeof(void*))));
106 : }
107 :
108 :
109 : // Backwards banches, these are currently all implemented using existing forwards branch mechanisms.
110 : void branchPtr(Condition cond, RegisterID op1, ImmPtr imm, Label target)
111 : {
112 : branchPtr(cond, op1, imm).linkTo(target, this);
113 : }
114 :
115 : void branch32(Condition cond, RegisterID op1, RegisterID op2, Label target)
116 : {
117 : branch32(cond, op1, op2).linkTo(target, this);
118 : }
119 :
120 : void branch32(Condition cond, RegisterID op1, TrustedImm32 imm, Label target)
121 : {
122 : branch32(cond, op1, imm).linkTo(target, this);
123 : }
124 :
125 2717 : void branch32(Condition cond, RegisterID left, Address right, Label target)
126 : {
127 2717 : branch32(cond, left, right).linkTo(target, this);
128 2717 : }
129 :
130 : void branch16(Condition cond, BaseIndex left, RegisterID right, Label target)
131 : {
132 : branch16(cond, left, right).linkTo(target, this);
133 : }
134 :
135 : void branchTestPtr(Condition cond, RegisterID reg, Label target)
136 : {
137 : branchTestPtr(cond, reg).linkTo(target, this);
138 : }
139 :
140 144521 : void jump(Label target)
141 : {
142 144521 : jump().linkTo(target, this);
143 144521 : }
144 :
145 :
146 : // Ptr methods
147 : // On 32-bit platforms (i.e. x86), these methods directly map onto their 32-bit equivalents.
148 : // FIXME: should this use a test for 32-bitness instead of this specific exception?
149 : #if !WTF_CPU_X86_64
150 1073 : void addPtr(RegisterID src, RegisterID dest)
151 : {
152 1073 : add32(src, dest);
153 1073 : }
154 :
155 : void addPtr(Imm32 imm32, Address address)
156 : {
157 : add32(imm32, address);
158 : }
159 :
160 5108276 : void addPtr(Imm32 imm, RegisterID srcDest)
161 : {
162 5108276 : add32(imm, srcDest);
163 5108276 : }
164 :
165 94 : void addPtr(ImmPtr imm, RegisterID dest)
166 : {
167 94 : add32(Imm32(imm), dest);
168 94 : }
169 :
170 5028715 : void addPtr(Imm32 imm, RegisterID src, RegisterID dest)
171 : {
172 5028715 : add32(imm, src, dest);
173 5028715 : }
174 :
175 : void andPtr(RegisterID src, RegisterID dest)
176 : {
177 : and32(src, dest);
178 : }
179 :
180 : void andPtr(Imm32 imm, RegisterID srcDest)
181 : {
182 : and32(imm, srcDest);
183 : }
184 :
185 105 : void andPtr(ImmPtr ptr, RegisterID srcDest)
186 : {
187 105 : and32(Imm32(ptr), srcDest);
188 105 : }
189 :
190 536 : void negPtr(RegisterID srcDest)
191 : {
192 536 : neg32(srcDest);
193 536 : }
194 :
195 : void notPtr(RegisterID srcDest)
196 : {
197 : not32(srcDest);
198 : }
199 :
200 : void orPtr(RegisterID src, RegisterID dest)
201 : {
202 : or32(src, dest);
203 : }
204 :
205 : void orPtr(ImmPtr imm, RegisterID dest)
206 : {
207 : or32(Imm32(imm), dest);
208 : }
209 :
210 : void orPtr(Imm32 imm, RegisterID dest)
211 : {
212 : or32(imm, dest);
213 : }
214 :
215 864 : void subPtr(RegisterID src, RegisterID dest)
216 : {
217 864 : sub32(src, dest);
218 864 : }
219 :
220 62997 : void subPtr(Imm32 imm, RegisterID dest)
221 : {
222 62997 : sub32(imm, dest);
223 62997 : }
224 :
225 : void subPtr(ImmPtr imm, RegisterID dest)
226 : {
227 : sub32(Imm32(imm), dest);
228 : }
229 :
230 : void subPtr(ImmPtr imm, Address address)
231 : {
232 : sub32(Imm32(imm), address);
233 : }
234 :
235 : void xorPtr(RegisterID src, RegisterID dest)
236 : {
237 : xor32(src, dest);
238 : }
239 :
240 : void xorPtr(Imm32 imm, RegisterID srcDest)
241 : {
242 : xor32(imm, srcDest);
243 : }
244 :
245 :
246 8108903 : void loadPtr(ImplicitAddress address, RegisterID dest)
247 : {
248 8108903 : load32(address, dest);
249 8108903 : }
250 :
251 : void loadPtr(BaseIndex address, RegisterID dest)
252 : {
253 : load32(address, dest);
254 : }
255 :
256 431088 : void loadPtr(void* address, RegisterID dest)
257 : {
258 431088 : load32(address, dest);
259 431088 : }
260 :
261 : DataLabel32 loadPtrWithAddressOffsetPatch(Address address, RegisterID dest)
262 : {
263 : return load32WithAddressOffsetPatch(address, dest);
264 : }
265 :
266 156 : void setPtr(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
267 : {
268 156 : set32(cond, left, right, dest);
269 156 : }
270 :
271 10075537 : void storePtr(RegisterID src, ImplicitAddress address)
272 : {
273 10075537 : store32(src, address);
274 10075537 : }
275 :
276 19127 : void storePtr(RegisterID src, void* address)
277 : {
278 19127 : store32(src, address);
279 19127 : }
280 :
281 5289399 : void storePtr(TrustedImmPtr imm, ImplicitAddress address)
282 : {
283 5289399 : store32(Imm32(imm), address);
284 5289399 : }
285 :
286 : void storePtr(TrustedImmPtr imm, BaseIndex address)
287 : {
288 : store32(Imm32(imm), address);
289 : }
290 :
291 : void storePtr(TrustedImmPtr imm, void* address)
292 : {
293 : store32(Imm32(imm), address);
294 : }
295 :
296 : DataLabel32 storePtrWithAddressOffsetPatch(RegisterID src, Address address)
297 : {
298 : return store32WithAddressOffsetPatch(src, address);
299 : }
300 :
301 :
302 16916 : Jump branchPtr(Condition cond, RegisterID left, RegisterID right)
303 : {
304 16916 : return branch32(cond, left, right);
305 : }
306 :
307 515276 : Jump branchPtr(Condition cond, RegisterID left, ImmPtr right)
308 : {
309 515276 : return branch32(cond, left, Imm32(right));
310 : }
311 :
312 10714 : Jump branchPtr(Condition cond, RegisterID left, Imm32 right)
313 : {
314 10714 : return branch32(cond, left, right);
315 : }
316 :
317 84053 : Jump branchPtr(Condition cond, RegisterID left, Address right)
318 : {
319 84053 : return branch32(cond, left, right);
320 : }
321 :
322 10 : Jump branchPtr(Condition cond, Address left, RegisterID right)
323 : {
324 10 : return branch32(cond, left, right);
325 : }
326 :
327 19127 : Jump branchPtr(Condition cond, AbsoluteAddress left, RegisterID right)
328 : {
329 19127 : return branch32(cond, left, right);
330 : }
331 :
332 318864 : Jump branchPtr(Condition cond, Address left, ImmPtr right)
333 : {
334 318864 : return branch32(cond, left, Imm32(right));
335 : }
336 :
337 6271 : Jump branchPtr(Condition cond, AbsoluteAddress left, ImmPtr right, RegisterID scratch)
338 : {
339 6271 : return branch32(cond, left, Imm32(right));
340 : }
341 :
342 486838 : Jump branchTestPtr(Condition cond, RegisterID reg, RegisterID mask)
343 : {
344 486838 : return branchTest32(cond, reg, mask);
345 : }
346 :
347 105 : Jump branchTestPtr(Condition cond, RegisterID reg, Imm32 mask = Imm32(-1))
348 : {
349 105 : return branchTest32(cond, reg, mask);
350 : }
351 :
352 : Jump branchTestPtr(Condition cond, Address address, Imm32 mask = Imm32(-1))
353 : {
354 : return branchTest32(cond, address, mask);
355 : }
356 :
357 : Jump branchTestPtr(Condition cond, BaseIndex address, Imm32 mask = Imm32(-1))
358 : {
359 : return branchTest32(cond, address, mask);
360 : }
361 :
362 :
363 : Jump branchAddPtr(Condition cond, RegisterID src, RegisterID dest)
364 : {
365 : return branchAdd32(cond, src, dest);
366 : }
367 :
368 : Jump branchSubPtr(Condition cond, Imm32 imm, RegisterID dest)
369 : {
370 : return branchSub32(cond, imm, dest);
371 : }
372 :
373 : using MacroAssemblerBase::branchTest8;
374 3435 : Jump branchTest8(Condition cond, ExtendedAddress address, Imm32 mask = Imm32(-1))
375 : {
376 3435 : return MacroAssemblerBase::branchTest8(cond, Address(address.base, address.offset), mask);
377 : }
378 :
379 105 : void rshiftPtr(Imm32 imm, RegisterID dest)
380 : {
381 105 : rshift32(imm, dest);
382 105 : }
383 :
384 1323 : void lshiftPtr(Imm32 imm, RegisterID dest)
385 : {
386 1323 : lshift32(imm, dest);
387 1323 : }
388 : #endif
389 :
390 : };
391 :
392 : } // namespace JSC
393 :
394 : #endif // ENABLE(ASSEMBLER)
395 :
396 : #endif // MacroAssembler_h
|