da128e74bfcf8d7184f6bbab47f0f8c40813a55d
[WebKit-https.git] / JavaScriptCore / assembler / ARMAssembler.h
1 /*
2  * Copyright (C) 2009, 2010 University of Szeged
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY UNIVERSITY OF SZEGED ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL UNIVERSITY OF SZEGED OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #ifndef ARMAssembler_h
28 #define ARMAssembler_h
29
30 #if ENABLE(ASSEMBLER) && CPU(ARM_TRADITIONAL)
31
32 #include "AssemblerBufferWithConstantPool.h"
33 #include <wtf/Assertions.h>
34 namespace JSC {
35
36     typedef uint32_t ARMWord;
37
38     namespace ARMRegisters {
39         typedef enum {
40             r0 = 0,
41             r1,
42             r2,
43             r3, S0 = r3,
44             r4,
45             r5,
46             r6,
47             r7,
48             r8, S1 = r8,
49             r9,
50             r10,
51             r11,
52             r12,
53             r13, sp = r13,
54             r14, lr = r14,
55             r15, pc = r15
56         } RegisterID;
57
58         typedef enum {
59             d0,
60             d1,
61             d2,
62             d3, SD0 = d3,
63             d4,
64             d5,
65             d6,
66             d7,
67             d8,
68             d9,
69             d10,
70             d11,
71             d12,
72             d13,
73             d14,
74             d15,
75             d16,
76             d17,
77             d18,
78             d19,
79             d20,
80             d21,
81             d22,
82             d23,
83             d24,
84             d25,
85             d26,
86             d27,
87             d28,
88             d29,
89             d30,
90             d31
91         } FPRegisterID;
92
93     } // namespace ARMRegisters
94
95     class ARMAssembler {
96     public:
97         typedef ARMRegisters::RegisterID RegisterID;
98         typedef ARMRegisters::FPRegisterID FPRegisterID;
99         typedef AssemblerBufferWithConstantPool<2048, 4, 4, ARMAssembler> ARMBuffer;
100         typedef SegmentedVector<int, 64> Jumps;
101
102         ARMAssembler() { }
103
104         // ARM conditional constants
105         typedef enum {
106             EQ = 0x00000000, // Zero
107             NE = 0x10000000, // Non-zero
108             CS = 0x20000000,
109             CC = 0x30000000,
110             MI = 0x40000000,
111             PL = 0x50000000,
112             VS = 0x60000000,
113             VC = 0x70000000,
114             HI = 0x80000000,
115             LS = 0x90000000,
116             GE = 0xa0000000,
117             LT = 0xb0000000,
118             GT = 0xc0000000,
119             LE = 0xd0000000,
120             AL = 0xe0000000
121         } Condition;
122
123         // ARM instruction constants
124         enum {
125             AND = (0x0 << 21),
126             EOR = (0x1 << 21),
127             SUB = (0x2 << 21),
128             RSB = (0x3 << 21),
129             ADD = (0x4 << 21),
130             ADC = (0x5 << 21),
131             SBC = (0x6 << 21),
132             RSC = (0x7 << 21),
133             TST = (0x8 << 21),
134             TEQ = (0x9 << 21),
135             CMP = (0xa << 21),
136             CMN = (0xb << 21),
137             ORR = (0xc << 21),
138             MOV = (0xd << 21),
139             BIC = (0xe << 21),
140             MVN = (0xf << 21),
141             MUL = 0x00000090,
142             MULL = 0x00c00090,
143             VADD_F64 = 0x0e300b00,
144             VDIV_F64 = 0x0e800b00,
145             VSUB_F64 = 0x0e300b40,
146             VMUL_F64 = 0x0e200b00,
147             VCMP_F64 = 0x0eb40b40,
148             VSQRT_F64 = 0x0eb10bc0,
149             DTR = 0x05000000,
150             LDRH = 0x00100090,
151             STRH = 0x00000090,
152             STMDB = 0x09200000,
153             LDMIA = 0x08b00000,
154             FDTR = 0x0d000b00,
155             B = 0x0a000000,
156             BL = 0x0b000000,
157 #if WTF_ARM_ARCH_AT_LEAST(5) || defined(__ARM_ARCH_4T__)
158             BX = 0x012fff10,
159 #endif
160             VMOV_VFP = 0x0e000a10,
161             VMOV_ARM = 0x0e100a10,
162             VCVT_F64_S32 = 0x0eb80bc0,
163             VCVT_S32_F64 = 0x0ebd0b40,
164             VMRS_APSR = 0x0ef1fa10,
165 #if WTF_ARM_ARCH_AT_LEAST(5)
166             CLZ = 0x016f0f10,
167             BKPT = 0xe120070,
168             BLX = 0x012fff30,
169 #endif
170 #if WTF_ARM_ARCH_AT_LEAST(7)
171             MOVW = 0x03000000,
172             MOVT = 0x03400000,
173 #endif
174         };
175
176         enum {
177             OP2_IMM = (1 << 25),
178             OP2_IMMh = (1 << 22),
179             OP2_INV_IMM = (1 << 26),
180             SET_CC = (1 << 20),
181             OP2_OFSREG = (1 << 25),
182             DT_UP = (1 << 23),
183             DT_BYTE = (1 << 22),
184             DT_WB = (1 << 21),
185             // This flag is inlcuded in LDR and STR
186             DT_PRE = (1 << 24),
187             HDT_UH = (1 << 5),
188             DT_LOAD = (1 << 20),
189         };
190
191         // Masks of ARM instructions
192         enum {
193             BRANCH_MASK = 0x00ffffff,
194             NONARM = 0xf0000000,
195             SDT_MASK = 0x0c000000,
196             SDT_OFFSET_MASK = 0xfff,
197         };
198
199         enum {
200             BOFFSET_MIN = -0x00800000,
201             BOFFSET_MAX = 0x007fffff,
202             SDT = 0x04000000,
203         };
204
205         enum {
206             padForAlign8  = 0x00,
207             padForAlign16 = 0x0000,
208             padForAlign32 = 0xee120070,
209         };
210
211         static const ARMWord INVALID_IMM = 0xf0000000;
212         static const ARMWord InvalidBranchTarget = 0xffffffff;
213         static const int DefaultPrefetching = 2;
214
215         class JmpSrc {
216             friend class ARMAssembler;
217         public:
218             JmpSrc()
219                 : m_offset(-1)
220             {
221             }
222
223         private:
224             JmpSrc(int offset)
225                 : m_offset(offset)
226             {
227             }
228
229             int m_offset;
230         };
231
232         class JmpDst {
233             friend class ARMAssembler;
234         public:
235             JmpDst()
236                 : m_offset(-1)
237                 , m_used(false)
238             {
239             }
240
241             bool isUsed() const { return m_used; }
242             void used() { m_used = true; }
243         private:
244             JmpDst(int offset)
245                 : m_offset(offset)
246                 , m_used(false)
247             {
248                 ASSERT(m_offset == offset);
249             }
250
251             int m_offset : 31;
252             int m_used : 1;
253         };
254
255         // Instruction formating
256
257         void emitInst(ARMWord op, int rd, int rn, ARMWord op2)
258         {
259             ASSERT(((op2 & ~OP2_IMM) <= 0xfff) || (((op2 & ~OP2_IMMh) <= 0xfff)));
260             m_buffer.putInt(op | RN(rn) | RD(rd) | op2);
261         }
262
263         void emitDoublePrecisionInst(ARMWord op, int dd, int dn, int dm)
264         {
265             ASSERT((dd >= 0 && dd <= 31) && (dn >= 0 && dn <= 31) && (dm >= 0 && dm <= 31));
266             m_buffer.putInt(op | ((dd & 0xf) << 12) | ((dd & 0x10) << (22 - 4))
267                                | ((dn & 0xf) << 16) | ((dn & 0x10) << (7 - 4))
268                                | (dm & 0xf) | ((dm & 0x10) << (5 - 4)));
269         }
270
271         void emitSinglePrecisionInst(ARMWord op, int sd, int sn, int sm)
272         {
273             ASSERT((sd >= 0 && sd <= 31) && (sn >= 0 && sn <= 31) && (sm >= 0 && sm <= 31));
274             m_buffer.putInt(op | ((sd >> 1) << 12) | ((sd & 0x1) << 22)
275                                | ((sn >> 1) << 16) | ((sn & 0x1) << 7)
276                                | (sm >> 1) | ((sm & 0x1) << 5));
277         }
278
279         void and_r(int rd, int rn, ARMWord op2, Condition cc = AL)
280         {
281             emitInst(static_cast<ARMWord>(cc) | AND, rd, rn, op2);
282         }
283
284         void ands_r(int rd, int rn, ARMWord op2, Condition cc = AL)
285         {
286             emitInst(static_cast<ARMWord>(cc) | AND | SET_CC, rd, rn, op2);
287         }
288
289         void eor_r(int rd, int rn, ARMWord op2, Condition cc = AL)
290         {
291             emitInst(static_cast<ARMWord>(cc) | EOR, rd, rn, op2);
292         }
293
294         void eors_r(int rd, int rn, ARMWord op2, Condition cc = AL)
295         {
296             emitInst(static_cast<ARMWord>(cc) | EOR | SET_CC, rd, rn, op2);
297         }
298
299         void sub_r(int rd, int rn, ARMWord op2, Condition cc = AL)
300         {
301             emitInst(static_cast<ARMWord>(cc) | SUB, rd, rn, op2);
302         }
303
304         void subs_r(int rd, int rn, ARMWord op2, Condition cc = AL)
305         {
306             emitInst(static_cast<ARMWord>(cc) | SUB | SET_CC, rd, rn, op2);
307         }
308
309         void rsb_r(int rd, int rn, ARMWord op2, Condition cc = AL)
310         {
311             emitInst(static_cast<ARMWord>(cc) | RSB, rd, rn, op2);
312         }
313
314         void rsbs_r(int rd, int rn, ARMWord op2, Condition cc = AL)
315         {
316             emitInst(static_cast<ARMWord>(cc) | RSB | SET_CC, rd, rn, op2);
317         }
318
319         void add_r(int rd, int rn, ARMWord op2, Condition cc = AL)
320         {
321             emitInst(static_cast<ARMWord>(cc) | ADD, rd, rn, op2);
322         }
323
324         void adds_r(int rd, int rn, ARMWord op2, Condition cc = AL)
325         {
326             emitInst(static_cast<ARMWord>(cc) | ADD | SET_CC, rd, rn, op2);
327         }
328
329         void adc_r(int rd, int rn, ARMWord op2, Condition cc = AL)
330         {
331             emitInst(static_cast<ARMWord>(cc) | ADC, rd, rn, op2);
332         }
333
334         void adcs_r(int rd, int rn, ARMWord op2, Condition cc = AL)
335         {
336             emitInst(static_cast<ARMWord>(cc) | ADC | SET_CC, rd, rn, op2);
337         }
338
339         void sbc_r(int rd, int rn, ARMWord op2, Condition cc = AL)
340         {
341             emitInst(static_cast<ARMWord>(cc) | SBC, rd, rn, op2);
342         }
343
344         void sbcs_r(int rd, int rn, ARMWord op2, Condition cc = AL)
345         {
346             emitInst(static_cast<ARMWord>(cc) | SBC | SET_CC, rd, rn, op2);
347         }
348
349         void rsc_r(int rd, int rn, ARMWord op2, Condition cc = AL)
350         {
351             emitInst(static_cast<ARMWord>(cc) | RSC, rd, rn, op2);
352         }
353
354         void rscs_r(int rd, int rn, ARMWord op2, Condition cc = AL)
355         {
356             emitInst(static_cast<ARMWord>(cc) | RSC | SET_CC, rd, rn, op2);
357         }
358
359         void tst_r(int rn, ARMWord op2, Condition cc = AL)
360         {
361             emitInst(static_cast<ARMWord>(cc) | TST | SET_CC, 0, rn, op2);
362         }
363
364         void teq_r(int rn, ARMWord op2, Condition cc = AL)
365         {
366             emitInst(static_cast<ARMWord>(cc) | TEQ | SET_CC, 0, rn, op2);
367         }
368
369         void cmp_r(int rn, ARMWord op2, Condition cc = AL)
370         {
371             emitInst(static_cast<ARMWord>(cc) | CMP | SET_CC, 0, rn, op2);
372         }
373
374         void orr_r(int rd, int rn, ARMWord op2, Condition cc = AL)
375         {
376             emitInst(static_cast<ARMWord>(cc) | ORR, rd, rn, op2);
377         }
378
379         void orrs_r(int rd, int rn, ARMWord op2, Condition cc = AL)
380         {
381             emitInst(static_cast<ARMWord>(cc) | ORR | SET_CC, rd, rn, op2);
382         }
383
384         void mov_r(int rd, ARMWord op2, Condition cc = AL)
385         {
386             emitInst(static_cast<ARMWord>(cc) | MOV, rd, ARMRegisters::r0, op2);
387         }
388
389 #if WTF_ARM_ARCH_AT_LEAST(7)
390         void movw_r(int rd, ARMWord op2, Condition cc = AL)
391         {
392             ASSERT((op2 | 0xf0fff) == 0xf0fff);
393             m_buffer.putInt(static_cast<ARMWord>(cc) | MOVW | RD(rd) | op2);
394         }
395
396         void movt_r(int rd, ARMWord op2, Condition cc = AL)
397         {
398             ASSERT((op2 | 0xf0fff) == 0xf0fff);
399             m_buffer.putInt(static_cast<ARMWord>(cc) | MOVT | RD(rd) | op2);
400         }
401 #endif
402
403         void movs_r(int rd, ARMWord op2, Condition cc = AL)
404         {
405             emitInst(static_cast<ARMWord>(cc) | MOV | SET_CC, rd, ARMRegisters::r0, op2);
406         }
407
408         void bic_r(int rd, int rn, ARMWord op2, Condition cc = AL)
409         {
410             emitInst(static_cast<ARMWord>(cc) | BIC, rd, rn, op2);
411         }
412
413         void bics_r(int rd, int rn, ARMWord op2, Condition cc = AL)
414         {
415             emitInst(static_cast<ARMWord>(cc) | BIC | SET_CC, rd, rn, op2);
416         }
417
418         void mvn_r(int rd, ARMWord op2, Condition cc = AL)
419         {
420             emitInst(static_cast<ARMWord>(cc) | MVN, rd, ARMRegisters::r0, op2);
421         }
422
423         void mvns_r(int rd, ARMWord op2, Condition cc = AL)
424         {
425             emitInst(static_cast<ARMWord>(cc) | MVN | SET_CC, rd, ARMRegisters::r0, op2);
426         }
427
428         void mul_r(int rd, int rn, int rm, Condition cc = AL)
429         {
430             m_buffer.putInt(static_cast<ARMWord>(cc) | MUL | RN(rd) | RS(rn) | RM(rm));
431         }
432
433         void muls_r(int rd, int rn, int rm, Condition cc = AL)
434         {
435             m_buffer.putInt(static_cast<ARMWord>(cc) | MUL | SET_CC | RN(rd) | RS(rn) | RM(rm));
436         }
437
438         void mull_r(int rdhi, int rdlo, int rn, int rm, Condition cc = AL)
439         {
440             m_buffer.putInt(static_cast<ARMWord>(cc) | MULL | RN(rdhi) | RD(rdlo) | RS(rn) | RM(rm));
441         }
442
443         void vadd_f64_r(int dd, int dn, int dm, Condition cc = AL)
444         {
445             emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VADD_F64, dd, dn, dm);
446         }
447
448         void vdiv_f64_r(int dd, int dn, int dm, Condition cc = AL)
449         {
450             emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VDIV_F64, dd, dn, dm);
451         }
452
453         void vsub_f64_r(int dd, int dn, int dm, Condition cc = AL)
454         {
455             emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VSUB_F64, dd, dn, dm);
456         }
457
458         void vmul_f64_r(int dd, int dn, int dm, Condition cc = AL)
459         {
460             emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VMUL_F64, dd, dn, dm);
461         }
462
463         void vcmp_f64_r(int dd, int dm, Condition cc = AL)
464         {
465             emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VCMP_F64, dd, 0, dm);
466         }
467
468         void vsqrt_f64_r(int dd, int dm, Condition cc = AL)
469         {
470             emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VSQRT_F64, dd, 0, dm);
471         }
472
473         void ldr_imm(int rd, ARMWord imm, Condition cc = AL)
474         {
475             m_buffer.putIntWithConstantInt(static_cast<ARMWord>(cc) | DTR | DT_LOAD | DT_UP | RN(ARMRegisters::pc) | RD(rd), imm, true);
476         }
477
478         void ldr_un_imm(int rd, ARMWord imm, Condition cc = AL)
479         {
480             m_buffer.putIntWithConstantInt(static_cast<ARMWord>(cc) | DTR | DT_LOAD | DT_UP | RN(ARMRegisters::pc) | RD(rd), imm);
481         }
482
483         void dtr_u(bool isLoad, int rd, int rb, ARMWord op2, Condition cc = AL)
484         {
485             emitInst(static_cast<ARMWord>(cc) | DTR | (isLoad ? DT_LOAD : 0) | DT_UP, rd, rb, op2);
486         }
487
488         void dtr_ur(bool isLoad, int rd, int rb, int rm, Condition cc = AL)
489         {
490             emitInst(static_cast<ARMWord>(cc) | DTR | (isLoad ? DT_LOAD : 0) | DT_UP | OP2_OFSREG, rd, rb, rm);
491         }
492
493         void dtr_d(bool isLoad, int rd, int rb, ARMWord op2, Condition cc = AL)
494         {
495             emitInst(static_cast<ARMWord>(cc) | DTR | (isLoad ? DT_LOAD : 0), rd, rb, op2);
496         }
497
498         void dtr_dr(bool isLoad, int rd, int rb, int rm, Condition cc = AL)
499         {
500             emitInst(static_cast<ARMWord>(cc) | DTR | (isLoad ? DT_LOAD : 0) | OP2_OFSREG, rd, rb, rm);
501         }
502
503         void ldrh_r(int rd, int rn, int rm, Condition cc = AL)
504         {
505             emitInst(static_cast<ARMWord>(cc) | LDRH | HDT_UH | DT_UP | DT_PRE, rd, rn, rm);
506         }
507
508         void ldrh_d(int rd, int rb, ARMWord op2, Condition cc = AL)
509         {
510             emitInst(static_cast<ARMWord>(cc) | LDRH | HDT_UH | DT_PRE, rd, rb, op2);
511         }
512
513         void ldrh_u(int rd, int rb, ARMWord op2, Condition cc = AL)
514         {
515             emitInst(static_cast<ARMWord>(cc) | LDRH | HDT_UH | DT_UP | DT_PRE, rd, rb, op2);
516         }
517
518         void strh_r(int rn, int rm, int rd, Condition cc = AL)
519         {
520             emitInst(static_cast<ARMWord>(cc) | STRH | HDT_UH | DT_UP | DT_PRE, rd, rn, rm);
521         }
522
523         void fdtr_u(bool isLoad, int rd, int rb, ARMWord op2, Condition cc = AL)
524         {
525             ASSERT(op2 <= 0xff);
526             emitInst(static_cast<ARMWord>(cc) | FDTR | DT_UP | (isLoad ? DT_LOAD : 0), rd, rb, op2);
527         }
528
529         void fdtr_d(bool isLoad, int rd, int rb, ARMWord op2, Condition cc = AL)
530         {
531             ASSERT(op2 <= 0xff);
532             emitInst(static_cast<ARMWord>(cc) | FDTR | (isLoad ? DT_LOAD : 0), rd, rb, op2);
533         }
534
535         void push_r(int reg, Condition cc = AL)
536         {
537             ASSERT(ARMWord(reg) <= 0xf);
538             m_buffer.putInt(cc | DTR | DT_WB | RN(ARMRegisters::sp) | RD(reg) | 0x4);
539         }
540
541         void pop_r(int reg, Condition cc = AL)
542         {
543             ASSERT(ARMWord(reg) <= 0xf);
544             m_buffer.putInt(cc | (DTR ^ DT_PRE) | DT_LOAD | DT_UP | RN(ARMRegisters::sp) | RD(reg) | 0x4);
545         }
546
547         inline void poke_r(int reg, Condition cc = AL)
548         {
549             dtr_d(false, ARMRegisters::sp, 0, reg, cc);
550         }
551
552         inline void peek_r(int reg, Condition cc = AL)
553         {
554             dtr_u(true, reg, ARMRegisters::sp, 0, cc);
555         }
556
557         void vmov_vfp_r(int sn, int rt, Condition cc = AL)
558         {
559             ASSERT(rt <= 15);
560             emitSinglePrecisionInst(static_cast<ARMWord>(cc) | VMOV_VFP, rt << 1, sn, 0);
561         }
562
563         void vmov_arm_r(int rt, int sn, Condition cc = AL)
564         {
565             ASSERT(rt <= 15);
566             emitSinglePrecisionInst(static_cast<ARMWord>(cc) | VMOV_ARM, rt << 1, sn, 0);
567         }
568
569         void vcvt_f64_s32_r(int dd, int sm, Condition cc = AL)
570         {
571             ASSERT(!(sm & 0x1)); // sm must be divisible by 2
572             emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VCVT_F64_S32, dd, 0, (sm >> 1));
573         }
574
575         void vcvt_s32_f64_r(int sd, int dm, Condition cc = AL)
576         {
577             ASSERT(!(sd & 0x1)); // sd must be divisible by 2
578             emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VCVT_S32_F64, (sd >> 1), 0, dm);
579         }
580
581         void vmrs_apsr(Condition cc = AL)
582         {
583             m_buffer.putInt(static_cast<ARMWord>(cc) | VMRS_APSR);
584         }
585
586 #if WTF_ARM_ARCH_AT_LEAST(5)
587         void clz_r(int rd, int rm, Condition cc = AL)
588         {
589             m_buffer.putInt(static_cast<ARMWord>(cc) | CLZ | RD(rd) | RM(rm));
590         }
591 #endif
592
593         void bkpt(ARMWord value)
594         {
595 #if WTF_ARM_ARCH_AT_LEAST(5)
596             m_buffer.putInt(BKPT | ((value & 0xff0) << 4) | (value & 0xf));
597 #else
598             // Cannot access to Zero memory address
599             dtr_dr(true, ARMRegisters::S0, ARMRegisters::S0, ARMRegisters::S0);
600 #endif
601         }
602
603         void bx(int rm, Condition cc = AL)
604         {
605 #if WTF_ARM_ARCH_AT_LEAST(5) || defined(__ARM_ARCH_4T__)
606             emitInst(static_cast<ARMWord>(cc) | BX, 0, 0, RM(rm));
607 #else
608             mov_r(ARMRegisters::pc, RM(rm), cc);
609 #endif
610         }
611
612         JmpSrc blx(int rm, Condition cc = AL)
613         {
614 #if WTF_ARM_ARCH_AT_LEAST(5)
615             int s = m_buffer.uncheckedSize();
616             emitInst(static_cast<ARMWord>(cc) | BLX, 0, 0, RM(rm));
617 #else
618             ASSERT(rm != 14);
619             ensureSpace(2 * sizeof(ARMWord), 0);
620             mov_r(ARMRegisters::lr, ARMRegisters::pc, cc);
621             int s = m_buffer.uncheckedSize();
622             bx(rm, cc);
623 #endif
624             return JmpSrc(s);
625         }
626
627         static ARMWord lsl(int reg, ARMWord value)
628         {
629             ASSERT(reg <= ARMRegisters::pc);
630             ASSERT(value <= 0x1f);
631             return reg | (value << 7) | 0x00;
632         }
633
634         static ARMWord lsr(int reg, ARMWord value)
635         {
636             ASSERT(reg <= ARMRegisters::pc);
637             ASSERT(value <= 0x1f);
638             return reg | (value << 7) | 0x20;
639         }
640
641         static ARMWord asr(int reg, ARMWord value)
642         {
643             ASSERT(reg <= ARMRegisters::pc);
644             ASSERT(value <= 0x1f);
645             return reg | (value << 7) | 0x40;
646         }
647
648         static ARMWord lsl_r(int reg, int shiftReg)
649         {
650             ASSERT(reg <= ARMRegisters::pc);
651             ASSERT(shiftReg <= ARMRegisters::pc);
652             return reg | (shiftReg << 8) | 0x10;
653         }
654
655         static ARMWord lsr_r(int reg, int shiftReg)
656         {
657             ASSERT(reg <= ARMRegisters::pc);
658             ASSERT(shiftReg <= ARMRegisters::pc);
659             return reg | (shiftReg << 8) | 0x30;
660         }
661
662         static ARMWord asr_r(int reg, int shiftReg)
663         {
664             ASSERT(reg <= ARMRegisters::pc);
665             ASSERT(shiftReg <= ARMRegisters::pc);
666             return reg | (shiftReg << 8) | 0x50;
667         }
668
669         // General helpers
670
671         int size()
672         {
673             return m_buffer.size();
674         }
675
676         void ensureSpace(int insnSpace, int constSpace)
677         {
678             m_buffer.ensureSpace(insnSpace, constSpace);
679         }
680
681         int sizeOfConstantPool()
682         {
683             return m_buffer.sizeOfConstantPool();
684         }
685
686         JmpDst label()
687         {
688             return JmpDst(m_buffer.size());
689         }
690
691         JmpDst align(int alignment)
692         {
693             while (!m_buffer.isAligned(alignment))
694                 mov_r(ARMRegisters::r0, ARMRegisters::r0);
695
696             return label();
697         }
698
699         JmpSrc loadBranchTarget(int rd, Condition cc = AL, int useConstantPool = 0)
700         {
701             ensureSpace(sizeof(ARMWord), sizeof(ARMWord));
702             int s = m_buffer.uncheckedSize();
703             ldr_un_imm(rd, InvalidBranchTarget, cc);
704             m_jumps.append(s | (useConstantPool & 0x1));
705             return JmpSrc(s);
706         }
707
708         JmpSrc jmp(Condition cc = AL, int useConstantPool = 0)
709         {
710             return loadBranchTarget(ARMRegisters::pc, cc, useConstantPool);
711         }
712
713         void* executableCopy(ExecutablePool* allocator);
714
715         // Patching helpers
716
717         static ARMWord* getLdrImmAddress(ARMWord* insn)
718         {
719 #if WTF_ARM_ARCH_AT_LEAST(5)
720             // Check for call
721             if ((*insn & 0x0f7f0000) != 0x051f0000) {
722                 // Must be BLX
723                 ASSERT((*insn & 0x012fff30) == 0x012fff30);
724                 insn--;
725             }
726 #endif
727             // Must be an ldr ..., [pc +/- imm]
728             ASSERT((*insn & 0x0f7f0000) == 0x051f0000);
729
730             ARMWord addr = reinterpret_cast<ARMWord>(insn) + DefaultPrefetching * sizeof(ARMWord);
731             if (*insn & DT_UP)
732                 return reinterpret_cast<ARMWord*>(addr + (*insn & SDT_OFFSET_MASK));
733             return reinterpret_cast<ARMWord*>(addr - (*insn & SDT_OFFSET_MASK));
734         }
735
736         static ARMWord* getLdrImmAddressOnPool(ARMWord* insn, uint32_t* constPool)
737         {
738             // Must be an ldr ..., [pc +/- imm]
739             ASSERT((*insn & 0x0f7f0000) == 0x051f0000);
740
741             if (*insn & 0x1)
742                 return reinterpret_cast<ARMWord*>(constPool + ((*insn & SDT_OFFSET_MASK) >> 1));
743             return getLdrImmAddress(insn);
744         }
745
746         static void patchPointerInternal(intptr_t from, void* to)
747         {
748             ARMWord* insn = reinterpret_cast<ARMWord*>(from);
749             ARMWord* addr = getLdrImmAddress(insn);
750             *addr = reinterpret_cast<ARMWord>(to);
751         }
752
753         static ARMWord patchConstantPoolLoad(ARMWord load, ARMWord value)
754         {
755             value = (value << 1) + 1;
756             ASSERT(!(value & ~0xfff));
757             return (load & ~0xfff) | value;
758         }
759
760         static void patchConstantPoolLoad(void* loadAddr, void* constPoolAddr);
761
762         // Patch pointers
763
764         static void linkPointer(void* code, JmpDst from, void* to)
765         {
766             patchPointerInternal(reinterpret_cast<intptr_t>(code) + from.m_offset, to);
767         }
768
769         static void repatchInt32(void* from, int32_t to)
770         {
771             patchPointerInternal(reinterpret_cast<intptr_t>(from), reinterpret_cast<void*>(to));
772         }
773
774         static void repatchPointer(void* from, void* to)
775         {
776             patchPointerInternal(reinterpret_cast<intptr_t>(from), to);
777         }
778
779         static void repatchLoadPtrToLEA(void* from)
780         {
781             // On arm, this is a patch from LDR to ADD. It is restricted conversion,
782             // from special case to special case, altough enough for its purpose
783             ARMWord* insn = reinterpret_cast<ARMWord*>(from);
784             ASSERT((*insn & 0x0ff00f00) == 0x05900000);
785
786             *insn = (*insn & 0xf00ff0ff) | 0x02800000;
787             ExecutableAllocator::cacheFlush(insn, sizeof(ARMWord));
788         }
789
790         // Linkers
791
792         void linkJump(JmpSrc from, JmpDst to)
793         {
794             ARMWord* insn = reinterpret_cast<ARMWord*>(m_buffer.data()) + (from.m_offset / sizeof(ARMWord));
795             ARMWord* addr = getLdrImmAddressOnPool(insn, m_buffer.poolAddress());
796             *addr = static_cast<ARMWord>(to.m_offset);
797         }
798
799         static void linkJump(void* code, JmpSrc from, void* to)
800         {
801             patchPointerInternal(reinterpret_cast<intptr_t>(code) + from.m_offset, to);
802         }
803
804         static void relinkJump(void* from, void* to)
805         {
806             patchPointerInternal(reinterpret_cast<intptr_t>(from) - sizeof(ARMWord), to);
807         }
808
809         static void linkCall(void* code, JmpSrc from, void* to)
810         {
811             patchPointerInternal(reinterpret_cast<intptr_t>(code) + from.m_offset, to);
812         }
813
814         static void relinkCall(void* from, void* to)
815         {
816             patchPointerInternal(reinterpret_cast<intptr_t>(from) - sizeof(ARMWord), to);
817         }
818
819         // Address operations
820
821         static void* getRelocatedAddress(void* code, JmpSrc jump)
822         {
823             return reinterpret_cast<void*>(reinterpret_cast<ARMWord*>(code) + jump.m_offset / sizeof(ARMWord) + 1);
824         }
825
826         static void* getRelocatedAddress(void* code, JmpDst label)
827         {
828             return reinterpret_cast<void*>(reinterpret_cast<ARMWord*>(code) + label.m_offset / sizeof(ARMWord));
829         }
830
831         // Address differences
832
833         static int getDifferenceBetweenLabels(JmpDst from, JmpSrc to)
834         {
835             return (to.m_offset + sizeof(ARMWord)) - from.m_offset;
836         }
837
838         static int getDifferenceBetweenLabels(JmpDst from, JmpDst to)
839         {
840             return to.m_offset - from.m_offset;
841         }
842
843         static unsigned getCallReturnOffset(JmpSrc call)
844         {
845             return call.m_offset + sizeof(ARMWord);
846         }
847
848         // Handle immediates
849
850         static ARMWord getOp2Byte(ARMWord imm)
851         {
852             ASSERT(imm <= 0xff);
853             return OP2_IMMh | (imm & 0x0f) | ((imm & 0xf0) << 4) ;
854         }
855
856         static ARMWord getOp2(ARMWord imm);
857
858 #if WTF_ARM_ARCH_AT_LEAST(7)
859         static ARMWord getImm16Op2(ARMWord imm)
860         {
861             if (imm <= 0xffff)
862                 return (imm & 0xf000) << 4 | (imm & 0xfff);
863             return INVALID_IMM;
864         }
865 #endif
866         ARMWord getImm(ARMWord imm, int tmpReg, bool invert = false);
867         void moveImm(ARMWord imm, int dest);
868         ARMWord encodeComplexImm(ARMWord imm, int dest);
869
870         ARMWord getOffsetForHalfwordDataTransfer(ARMWord imm, int tmpReg)
871         {
872             // Encode immediate data in the instruction if it is possible
873             if (imm <= 0xff)
874                 return getOp2Byte(imm);
875             // Otherwise, store the data in a temporary register
876             return encodeComplexImm(imm, tmpReg);
877         }
878
879         // Memory load/store helpers
880
881         void dataTransfer32(bool isLoad, RegisterID srcDst, RegisterID base, int32_t offset, bool bytes = false);
882         void baseIndexTransfer32(bool isLoad, RegisterID srcDst, RegisterID base, RegisterID index, int scale, int32_t offset);
883         void doubleTransfer(bool isLoad, FPRegisterID srcDst, RegisterID base, int32_t offset);
884
885         // Constant pool hnadlers
886
887         static ARMWord placeConstantPoolBarrier(int offset)
888         {
889             offset = (offset - sizeof(ARMWord)) >> 2;
890             ASSERT((offset <= BOFFSET_MAX && offset >= BOFFSET_MIN));
891             return AL | B | (offset & BRANCH_MASK);
892         }
893
894     private:
895         ARMWord RM(int reg)
896         {
897             ASSERT(reg <= ARMRegisters::pc);
898             return reg;
899         }
900
901         ARMWord RS(int reg)
902         {
903             ASSERT(reg <= ARMRegisters::pc);
904             return reg << 8;
905         }
906
907         ARMWord RD(int reg)
908         {
909             ASSERT(reg <= ARMRegisters::pc);
910             return reg << 12;
911         }
912
913         ARMWord RN(int reg)
914         {
915             ASSERT(reg <= ARMRegisters::pc);
916             return reg << 16;
917         }
918
919         static ARMWord getConditionalField(ARMWord i)
920         {
921             return i & 0xf0000000;
922         }
923
924         int genInt(int reg, ARMWord imm, bool positive);
925
926         ARMBuffer m_buffer;
927         Jumps m_jumps;
928     };
929
930 } // namespace JSC
931
932 #endif // ENABLE(ASSEMBLER) && CPU(ARM_TRADITIONAL)
933
934 #endif // ARMAssembler_h