?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tcg/arm: fix branch target change during code retranslation
[qemu.git] / tcg / arm / tcg-target.c
blob9def2e58fbc27295da6b34d7d3158df056abc21e
1 /*
2 * Tiny Code Generator for QEMU
3 *
4 * Copyright (c) 2008 Andrzej Zaborowski
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 #if defined(__ARM_ARCH_7__) || \
26 defined(__ARM_ARCH_7A__) || \
27 defined(__ARM_ARCH_7EM__) || \
28 defined(__ARM_ARCH_7M__) || \
29 defined(__ARM_ARCH_7R__)
30 #define USE_ARMV7_INSTRUCTIONS
31 #endif
32
33 #if defined(USE_ARMV7_INSTRUCTIONS) || \
34 defined(__ARM_ARCH_6J__) || \
35 defined(__ARM_ARCH_6K__) || \
36 defined(__ARM_ARCH_6T2__) || \
37 defined(__ARM_ARCH_6Z__) || \
38 defined(__ARM_ARCH_6ZK__)
39 #define USE_ARMV6_INSTRUCTIONS
40 #endif
41
42 #if defined(USE_ARMV6_INSTRUCTIONS) || \
43 defined(__ARM_ARCH_5T__) || \
44 defined(__ARM_ARCH_5TE__) || \
45 defined(__ARM_ARCH_5TEJ__)
46 #define USE_ARMV5_INSTRUCTIONS
47 #endif
48
49 #ifdef USE_ARMV5_INSTRUCTIONS
50 static const int use_armv5_instructions = 1;
51 #else
52 static const int use_armv5_instructions = 0;
53 #endif
54 #undef USE_ARMV5_INSTRUCTIONS
55
56 #ifdef USE_ARMV6_INSTRUCTIONS
57 static const int use_armv6_instructions = 1;
58 #else
59 static const int use_armv6_instructions = 0;
60 #endif
61 #undef USE_ARMV6_INSTRUCTIONS
62
63 #ifdef USE_ARMV7_INSTRUCTIONS
64 static const int use_armv7_instructions = 1;
65 #else
66 static const int use_armv7_instructions = 0;
67 #endif
68 #undef USE_ARMV7_INSTRUCTIONS
69
70 #ifndef NDEBUG
71 static const char * const tcg_target_reg_names[TCG_TARGET_NB_REGS] = {
72 "%r0",
73 "%r1",
74 "%r2",
75 "%r3",
76 "%r4",
77 "%r5",
78 "%r6",
79 "%r7",
80 "%r8",
81 "%r9",
82 "%r10",
83 "%r11",
84 "%r12",
85 "%r13",
86 "%r14",
87 "%pc",
88 };
89 #endif
90
91 static const int tcg_target_reg_alloc_order[] = {
92 TCG_REG_R4,
93 TCG_REG_R5,
94 TCG_REG_R6,
95 TCG_REG_R7,
96 TCG_REG_R8,
97 TCG_REG_R9,
98 TCG_REG_R10,
99 TCG_REG_R11,
100 TCG_REG_R13,
101 TCG_REG_R0,
102 TCG_REG_R1,
103 TCG_REG_R2,
104 TCG_REG_R3,
105 TCG_REG_R12,
106 TCG_REG_R14,
107 };
108
109 static const int tcg_target_call_iarg_regs[4] = {
110 TCG_REG_R0, TCG_REG_R1, TCG_REG_R2, TCG_REG_R3
111 };
112 static const int tcg_target_call_oarg_regs[2] = {
113 TCG_REG_R0, TCG_REG_R1
114 };
115
116 static inline void reloc_abs32(void *code_ptr, tcg_target_long target)
117 {
118 *(uint32_t *) code_ptr = target;
119 }
120
121 static inline void reloc_pc24(void *code_ptr, tcg_target_long target)
122 {
123 uint32_t offset = ((target - ((tcg_target_long) code_ptr + 8)) >> 2);
124
125 *(uint32_t *) code_ptr = ((*(uint32_t *) code_ptr) & ~0xffffff)
126 | (offset & 0xffffff);
127 }
128
129 static void patch_reloc(uint8_t *code_ptr, int type,
130 tcg_target_long value, tcg_target_long addend)
131 {
132 switch (type) {
133 case R_ARM_ABS32:
134 reloc_abs32(code_ptr, value);
135 break;
136
137 case R_ARM_CALL:
138 case R_ARM_JUMP24:
139 default:
140 tcg_abort();
141
142 case R_ARM_PC24:
143 reloc_pc24(code_ptr, value);
144 break;
145 }
146 }
147
148 /* maximum number of register used for input function arguments */
149 static inline int tcg_target_get_call_iarg_regs_count(int flags)
150 {
151 return 4;
152 }
153
154 /* parse target specific constraints */
155 static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
156 {
157 const char *ct_str;
158
159 ct_str = *pct_str;
160 switch (ct_str[0]) {
161 case 'I':
162 ct->ct |= TCG_CT_CONST_ARM;
163 break;
164
165 case 'r':
166 ct->ct |= TCG_CT_REG;
167 tcg_regset_set32(ct->u.regs, 0, (1 << TCG_TARGET_NB_REGS) - 1);
168 break;
169
170 /* qemu_ld address */
171 case 'l':
172 ct->ct |= TCG_CT_REG;
173 tcg_regset_set32(ct->u.regs, 0, (1 << TCG_TARGET_NB_REGS) - 1);
174 #ifdef CONFIG_SOFTMMU
175 /* r0 and r1 will be overwritten when reading the tlb entry,
176 so don't use these. */
177 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R0);
178 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R1);
179 #endif
180 break;
181 case 'L':
182 ct->ct |= TCG_CT_REG;
183 tcg_regset_set32(ct->u.regs, 0, (1 << TCG_TARGET_NB_REGS) - 1);
184 #ifdef CONFIG_SOFTMMU
185 /* r1 is still needed to load data_reg or data_reg2,
186 so don't use it. */
187 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R1);
188 #endif
189 break;
190
191 /* qemu_st address & data_reg */
192 case 's':
193 ct->ct |= TCG_CT_REG;
194 tcg_regset_set32(ct->u.regs, 0, (1 << TCG_TARGET_NB_REGS) - 1);
195 /* r0 and r1 will be overwritten when reading the tlb entry
196 (softmmu only) and doing the byte swapping, so don't
197 use these. */
198 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R0);
199 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R1);
200 break;
201 /* qemu_st64 data_reg2 */
202 case 'S':
203 ct->ct |= TCG_CT_REG;
204 tcg_regset_set32(ct->u.regs, 0, (1 << TCG_TARGET_NB_REGS) - 1);
205 /* r0 and r1 will be overwritten when reading the tlb entry
206 (softmmu only) and doing the byte swapping, so don't
207 use these. */
208 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R0);
209 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R1);
210 #ifdef CONFIG_SOFTMMU
211 /* r2 is still needed to load data_reg, so don't use it. */
212 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R2);
213 #endif
214 break;
215
216 default:
217 return -1;
218 }
219 ct_str++;
220 *pct_str = ct_str;
221
222 return 0;
223 }
224
225 static inline uint32_t rotl(uint32_t val, int n)
226 {
227 return (val << n) | (val >> (32 - n));
228 }
229
230 /* ARM immediates for ALU instructions are made of an unsigned 8-bit
231 right-rotated by an even amount between 0 and 30. */
232 static inline int encode_imm(uint32_t imm)
233 {
234 int shift;
235
236 /* simple case, only lower bits */
237 if ((imm & ~0xff) == 0)
238 return 0;
239 /* then try a simple even shift */
240 shift = ctz32(imm) & ~1;
241 if (((imm >> shift) & ~0xff) == 0)
242 return 32 - shift;
243 /* now try harder with rotations */
244 if ((rotl(imm, 2) & ~0xff) == 0)
245 return 2;
246 if ((rotl(imm, 4) & ~0xff) == 0)
247 return 4;
248 if ((rotl(imm, 6) & ~0xff) == 0)
249 return 6;
250 /* imm can't be encoded */
251 return -1;
252 }
253
254 static inline int check_fit_imm(uint32_t imm)
255 {
256 return encode_imm(imm) >= 0;
257 }
258
259 /* Test if a constant matches the constraint.
260 * TODO: define constraints for:
261 *
262 * ldr/str offset: between -0xfff and 0xfff
263 * ldrh/strh offset: between -0xff and 0xff
264 * mov operand2: values represented with x << (2 * y), x < 0x100
265 * add, sub, eor...: ditto
266 */
267 static inline int tcg_target_const_match(tcg_target_long val,
268 const TCGArgConstraint *arg_ct)
269 {
270 int ct;
271 ct = arg_ct->ct;
272 if (ct & TCG_CT_CONST)
273 return 1;
274 else if ((ct & TCG_CT_CONST_ARM) && check_fit_imm(val))
275 return 1;
276 else
277 return 0;
278 }
279
280 enum arm_data_opc_e {
281 ARITH_AND = 0x0,
282 ARITH_EOR = 0x1,
283 ARITH_SUB = 0x2,
284 ARITH_RSB = 0x3,
285 ARITH_ADD = 0x4,
286 ARITH_ADC = 0x5,
287 ARITH_SBC = 0x6,
288 ARITH_RSC = 0x7,
289 ARITH_TST = 0x8,
290 ARITH_CMP = 0xa,
291 ARITH_CMN = 0xb,
292 ARITH_ORR = 0xc,
293 ARITH_MOV = 0xd,
294 ARITH_BIC = 0xe,
295 ARITH_MVN = 0xf,
296 };
297
298 #define TO_CPSR(opc) \
299 ((opc == ARITH_CMP || opc == ARITH_CMN || opc == ARITH_TST) << 20)
300
301 #define SHIFT_IMM_LSL(im) (((im) << 7) | 0x00)
302 #define SHIFT_IMM_LSR(im) (((im) << 7) | 0x20)
303 #define SHIFT_IMM_ASR(im) (((im) << 7) | 0x40)
304 #define SHIFT_IMM_ROR(im) (((im) << 7) | 0x60)
305 #define SHIFT_REG_LSL(rs) (((rs) << 8) | 0x10)
306 #define SHIFT_REG_LSR(rs) (((rs) << 8) | 0x30)
307 #define SHIFT_REG_ASR(rs) (((rs) << 8) | 0x50)
308 #define SHIFT_REG_ROR(rs) (((rs) << 8) | 0x70)
309
310 enum arm_cond_code_e {
311 COND_EQ = 0x0,
312 COND_NE = 0x1,
313 COND_CS = 0x2, /* Unsigned greater or equal */
314 COND_CC = 0x3, /* Unsigned less than */
315 COND_MI = 0x4, /* Negative */
316 COND_PL = 0x5, /* Zero or greater */
317 COND_VS = 0x6, /* Overflow */
318 COND_VC = 0x7, /* No overflow */
319 COND_HI = 0x8, /* Unsigned greater than */
320 COND_LS = 0x9, /* Unsigned less or equal */
321 COND_GE = 0xa,
322 COND_LT = 0xb,
323 COND_GT = 0xc,
324 COND_LE = 0xd,
325 COND_AL = 0xe,
326 };
327
328 static const uint8_t tcg_cond_to_arm_cond[10] = {
329 [TCG_COND_EQ] = COND_EQ,
330 [TCG_COND_NE] = COND_NE,
331 [TCG_COND_LT] = COND_LT,
332 [TCG_COND_GE] = COND_GE,
333 [TCG_COND_LE] = COND_LE,
334 [TCG_COND_GT] = COND_GT,
335 /* unsigned */
336 [TCG_COND_LTU] = COND_CC,
337 [TCG_COND_GEU] = COND_CS,
338 [TCG_COND_LEU] = COND_LS,
339 [TCG_COND_GTU] = COND_HI,
340 };
341
342 static inline void tcg_out_bx(TCGContext *s, int cond, int rn)
343 {
344 tcg_out32(s, (cond << 28) | 0x012fff10 | rn);
345 }
346
347 static inline void tcg_out_b(TCGContext *s, int cond, int32_t offset)
348 {
349 tcg_out32(s, (cond << 28) | 0x0a000000 |
350 (((offset - 8) >> 2) & 0x00ffffff));
351 }
352
353 static inline void tcg_out_b_noaddr(TCGContext *s, int cond)
354 {
355 #ifdef HOST_WORDS_BIGENDIAN
356 tcg_out8(s, (cond << 4) | 0x0a);
357 s->code_ptr += 3;
358 #else
359 s->code_ptr += 3;
360 tcg_out8(s, (cond << 4) | 0x0a);
361 #endif
362 }
363
364 static inline void tcg_out_bl(TCGContext *s, int cond, int32_t offset)
365 {
366 tcg_out32(s, (cond << 28) | 0x0b000000 |
367 (((offset - 8) >> 2) & 0x00ffffff));
368 }
369
370 static inline void tcg_out_blx(TCGContext *s, int cond, int rn)
371 {
372 tcg_out32(s, (cond << 28) | 0x012fff30 | rn);
373 }
374
375 static inline void tcg_out_dat_reg(TCGContext *s,
376 int cond, int opc, int rd, int rn, int rm, int shift)
377 {
378 tcg_out32(s, (cond << 28) | (0 << 25) | (opc << 21) | TO_CPSR(opc) |
379 (rn << 16) | (rd << 12) | shift | rm);
380 }
381
382 static inline void tcg_out_dat_reg2(TCGContext *s,
383 int cond, int opc0, int opc1, int rd0, int rd1,
384 int rn0, int rn1, int rm0, int rm1, int shift)
385 {
386 if (rd0 == rn1 || rd0 == rm1) {
387 tcg_out32(s, (cond << 28) | (0 << 25) | (opc0 << 21) | (1 << 20) |
388 (rn0 << 16) | (8 << 12) | shift | rm0);
389 tcg_out32(s, (cond << 28) | (0 << 25) | (opc1 << 21) |
390 (rn1 << 16) | (rd1 << 12) | shift | rm1);
391 tcg_out_dat_reg(s, cond, ARITH_MOV,
392 rd0, 0, TCG_REG_R8, SHIFT_IMM_LSL(0));
393 } else {
394 tcg_out32(s, (cond << 28) | (0 << 25) | (opc0 << 21) | (1 << 20) |
395 (rn0 << 16) | (rd0 << 12) | shift | rm0);
396 tcg_out32(s, (cond << 28) | (0 << 25) | (opc1 << 21) |
397 (rn1 << 16) | (rd1 << 12) | shift | rm1);
398 }
399 }
400
401 static inline void tcg_out_dat_imm(TCGContext *s,
402 int cond, int opc, int rd, int rn, int im)
403 {
404 tcg_out32(s, (cond << 28) | (1 << 25) | (opc << 21) | TO_CPSR(opc) |
405 (rn << 16) | (rd << 12) | im);
406 }
407
408 static inline void tcg_out_movi32(TCGContext *s,
409 int cond, int rd, int32_t arg)
410 {
411 /* TODO: This is very suboptimal, we can easily have a constant
412 * pool somewhere after all the instructions. */
413
414 if (arg < 0 && arg > -0x100)
415 return tcg_out_dat_imm(s, cond, ARITH_MVN, rd, 0, (~arg) & 0xff);
416
417 if (use_armv7_instructions) {
418 /* use movw/movt */
419 /* movw */
420 tcg_out32(s, (cond << 28) | 0x03000000 | (rd << 12)
421 | ((arg << 4) & 0x000f0000) | (arg & 0xfff));
422 if (arg & 0xffff0000)
423 /* movt */
424 tcg_out32(s, (cond << 28) | 0x03400000 | (rd << 12)
425 | ((arg >> 12) & 0x000f0000) | ((arg >> 16) & 0xfff));
426 } else {
427 tcg_out_dat_imm(s, cond, ARITH_MOV, rd, 0, arg & 0xff);
428 if (arg & 0x0000ff00)
429 tcg_out_dat_imm(s, cond, ARITH_ORR, rd, rd,
430 ((arg >> 8) & 0xff) | 0xc00);
431 if (arg & 0x00ff0000)
432 tcg_out_dat_imm(s, cond, ARITH_ORR, rd, rd,
433 ((arg >> 16) & 0xff) | 0x800);
434 if (arg & 0xff000000)
435 tcg_out_dat_imm(s, cond, ARITH_ORR, rd, rd,
436 ((arg >> 24) & 0xff) | 0x400);
437 }
438 }
439
440 static inline void tcg_out_mul32(TCGContext *s,
441 int cond, int rd, int rs, int rm)
442 {
443 if (rd != rm)
444 tcg_out32(s, (cond << 28) | (rd << 16) | (0 << 12) |
445 (rs << 8) | 0x90 | rm);
446 else if (rd != rs)
447 tcg_out32(s, (cond << 28) | (rd << 16) | (0 << 12) |
448 (rm << 8) | 0x90 | rs);
449 else {
450 tcg_out32(s, (cond << 28) | ( 8 << 16) | (0 << 12) |
451 (rs << 8) | 0x90 | rm);
452 tcg_out_dat_reg(s, cond, ARITH_MOV,
453 rd, 0, TCG_REG_R8, SHIFT_IMM_LSL(0));
454 }
455 }
456
457 static inline void tcg_out_umull32(TCGContext *s,
458 int cond, int rd0, int rd1, int rs, int rm)
459 {
460 if (rd0 != rm && rd1 != rm)
461 tcg_out32(s, (cond << 28) | 0x800090 |
462 (rd1 << 16) | (rd0 << 12) | (rs << 8) | rm);
463 else if (rd0 != rs && rd1 != rs)
464 tcg_out32(s, (cond << 28) | 0x800090 |
465 (rd1 << 16) | (rd0 << 12) | (rm << 8) | rs);
466 else {
467 tcg_out_dat_reg(s, cond, ARITH_MOV,
468 TCG_REG_R8, 0, rm, SHIFT_IMM_LSL(0));
469 tcg_out32(s, (cond << 28) | 0x800098 |
470 (rd1 << 16) | (rd0 << 12) | (rs << 8));
471 }
472 }
473
474 static inline void tcg_out_smull32(TCGContext *s,
475 int cond, int rd0, int rd1, int rs, int rm)
476 {
477 if (rd0 != rm && rd1 != rm)
478 tcg_out32(s, (cond << 28) | 0xc00090 |
479 (rd1 << 16) | (rd0 << 12) | (rs << 8) | rm);
480 else if (rd0 != rs && rd1 != rs)
481 tcg_out32(s, (cond << 28) | 0xc00090 |
482 (rd1 << 16) | (rd0 << 12) | (rm << 8) | rs);
483 else {
484 tcg_out_dat_reg(s, cond, ARITH_MOV,
485 TCG_REG_R8, 0, rm, SHIFT_IMM_LSL(0));
486 tcg_out32(s, (cond << 28) | 0xc00098 |
487 (rd1 << 16) | (rd0 << 12) | (rs << 8));
488 }
489 }
490
491 static inline void tcg_out_ext8s(TCGContext *s, int cond,
492 int rd, int rn)
493 {
494 if (use_armv6_instructions) {
495 /* sxtb */
496 tcg_out32(s, 0x06af0070 | (cond << 28) | (rd << 12) | rn);
497 } else {
498 tcg_out_dat_reg(s, cond, ARITH_MOV,
499 rd, 0, rn, SHIFT_IMM_LSL(24));
500 tcg_out_dat_reg(s, cond, ARITH_MOV,
501 rd, 0, rd, SHIFT_IMM_ASR(24));
502 }
503 }
504
505 static inline void tcg_out_ext8u(TCGContext *s, int cond,
506 int rd, int rn)
507 {
508 tcg_out_dat_imm(s, cond, ARITH_AND, rd, rn, 0xff);
509 }
510
511 static inline void tcg_out_ext16s(TCGContext *s, int cond,
512 int rd, int rn)
513 {
514 if (use_armv6_instructions) {
515 /* sxth */
516 tcg_out32(s, 0x06bf0070 | (cond << 28) | (rd << 12) | rn);
517 } else {
518 tcg_out_dat_reg(s, cond, ARITH_MOV,
519 rd, 0, rn, SHIFT_IMM_LSL(16));
520 tcg_out_dat_reg(s, cond, ARITH_MOV,
521 rd, 0, rd, SHIFT_IMM_ASR(16));
522 }
523 }
524
525 static inline void tcg_out_ext16u(TCGContext *s, int cond,
526 int rd, int rn)
527 {
528 if (use_armv6_instructions) {
529 /* uxth */
530 tcg_out32(s, 0x06ff0070 | (cond << 28) | (rd << 12) | rn);
531 } else {
532 tcg_out_dat_reg(s, cond, ARITH_MOV,
533 rd, 0, rn, SHIFT_IMM_LSL(16));
534 tcg_out_dat_reg(s, cond, ARITH_MOV,
535 rd, 0, rd, SHIFT_IMM_LSR(16));
536 }
537 }
538
539 static inline void tcg_out_bswap16s(TCGContext *s, int cond, int rd, int rn)
540 {
541 if (use_armv6_instructions) {
542 /* revsh */
543 tcg_out32(s, 0x06ff0fb0 | (cond << 28) | (rd << 12) | rn);
544 } else {
545 tcg_out_dat_reg(s, cond, ARITH_MOV,
546 TCG_REG_R8, 0, rn, SHIFT_IMM_LSL(24));
547 tcg_out_dat_reg(s, cond, ARITH_MOV,
548 TCG_REG_R8, 0, TCG_REG_R8, SHIFT_IMM_ASR(16));
549 tcg_out_dat_reg(s, cond, ARITH_ORR,
550 rd, TCG_REG_R8, rn, SHIFT_IMM_LSR(8));
551 }
552 }
553
554 static inline void tcg_out_bswap16(TCGContext *s, int cond, int rd, int rn)
555 {
556 if (use_armv6_instructions) {
557 /* rev16 */
558 tcg_out32(s, 0x06bf0fb0 | (cond << 28) | (rd << 12) | rn);
559 } else {
560 tcg_out_dat_reg(s, cond, ARITH_MOV,
561 TCG_REG_R8, 0, rn, SHIFT_IMM_LSL(24));
562 tcg_out_dat_reg(s, cond, ARITH_MOV,
563 TCG_REG_R8, 0, TCG_REG_R8, SHIFT_IMM_LSR(16));
564 tcg_out_dat_reg(s, cond, ARITH_ORR,
565 rd, TCG_REG_R8, rn, SHIFT_IMM_LSR(8));
566 }
567 }
568
569 static inline void tcg_out_bswap32(TCGContext *s, int cond, int rd, int rn)
570 {
571 if (use_armv6_instructions) {
572 /* rev */
573 tcg_out32(s, 0x06bf0f30 | (cond << 28) | (rd << 12) | rn);
574 } else {
575 tcg_out_dat_reg(s, cond, ARITH_EOR,
576 TCG_REG_R8, rn, rn, SHIFT_IMM_ROR(16));
577 tcg_out_dat_imm(s, cond, ARITH_BIC,
578 TCG_REG_R8, TCG_REG_R8, 0xff | 0x800);
579 tcg_out_dat_reg(s, cond, ARITH_MOV,
580 rd, 0, rn, SHIFT_IMM_ROR(8));
581 tcg_out_dat_reg(s, cond, ARITH_EOR,
582 rd, rd, TCG_REG_R8, SHIFT_IMM_LSR(8));
583 }
584 }
585
586 static inline void tcg_out_ld32_12(TCGContext *s, int cond,
587 int rd, int rn, tcg_target_long im)
588 {
589 if (im >= 0)
590 tcg_out32(s, (cond << 28) | 0x05900000 |
591 (rn << 16) | (rd << 12) | (im & 0xfff));
592 else
593 tcg_out32(s, (cond << 28) | 0x05100000 |
594 (rn << 16) | (rd << 12) | ((-im) & 0xfff));
595 }
596
597 static inline void tcg_out_st32_12(TCGContext *s, int cond,
598 int rd, int rn, tcg_target_long im)
599 {
600 if (im >= 0)
601 tcg_out32(s, (cond << 28) | 0x05800000 |
602 (rn << 16) | (rd << 12) | (im & 0xfff));
603 else
604 tcg_out32(s, (cond << 28) | 0x05000000 |
605 (rn << 16) | (rd << 12) | ((-im) & 0xfff));
606 }
607
608 static inline void tcg_out_ld32_r(TCGContext *s, int cond,
609 int rd, int rn, int rm)
610 {
611 tcg_out32(s, (cond << 28) | 0x07900000 |
612 (rn << 16) | (rd << 12) | rm);
613 }
614
615 static inline void tcg_out_st32_r(TCGContext *s, int cond,
616 int rd, int rn, int rm)
617 {
618 tcg_out32(s, (cond << 28) | 0x07800000 |
619 (rn << 16) | (rd << 12) | rm);
620 }
621
622 /* Register pre-increment with base writeback. */
623 static inline void tcg_out_ld32_rwb(TCGContext *s, int cond,
624 int rd, int rn, int rm)
625 {
626 tcg_out32(s, (cond << 28) | 0x07b00000 |
627 (rn << 16) | (rd << 12) | rm);
628 }
629
630 static inline void tcg_out_st32_rwb(TCGContext *s, int cond,
631 int rd, int rn, int rm)
632 {
633 tcg_out32(s, (cond << 28) | 0x07a00000 |
634 (rn << 16) | (rd << 12) | rm);
635 }
636
637 static inline void tcg_out_ld16u_8(TCGContext *s, int cond,
638 int rd, int rn, tcg_target_long im)
639 {
640 if (im >= 0)
641 tcg_out32(s, (cond << 28) | 0x01d000b0 |
642 (rn << 16) | (rd << 12) |
643 ((im & 0xf0) << 4) | (im & 0xf));
644 else
645 tcg_out32(s, (cond << 28) | 0x015000b0 |
646 (rn << 16) | (rd << 12) |
647 (((-im) & 0xf0) << 4) | ((-im) & 0xf));
648 }
649
650 static inline void tcg_out_st16_8(TCGContext *s, int cond,
651 int rd, int rn, tcg_target_long im)
652 {
653 if (im >= 0)
654 tcg_out32(s, (cond << 28) | 0x01c000b0 |
655 (rn << 16) | (rd << 12) |
656 ((im & 0xf0) << 4) | (im & 0xf));
657 else
658 tcg_out32(s, (cond << 28) | 0x014000b0 |
659 (rn << 16) | (rd << 12) |
660 (((-im) & 0xf0) << 4) | ((-im) & 0xf));
661 }
662
663 static inline void tcg_out_ld16u_r(TCGContext *s, int cond,
664 int rd, int rn, int rm)
665 {
666 tcg_out32(s, (cond << 28) | 0x019000b0 |
667 (rn << 16) | (rd << 12) | rm);
668 }
669
670 static inline void tcg_out_st16_r(TCGContext *s, int cond,
671 int rd, int rn, int rm)
672 {
673 tcg_out32(s, (cond << 28) | 0x018000b0 |
674 (rn << 16) | (rd << 12) | rm);
675 }
676
677 static inline void tcg_out_ld16s_8(TCGContext *s, int cond,
678 int rd, int rn, tcg_target_long im)
679 {
680 if (im >= 0)
681 tcg_out32(s, (cond << 28) | 0x01d000f0 |
682 (rn << 16) | (rd << 12) |
683 ((im & 0xf0) << 4) | (im & 0xf));
684 else
685 tcg_out32(s, (cond << 28) | 0x015000f0 |
686 (rn << 16) | (rd << 12) |
687 (((-im) & 0xf0) << 4) | ((-im) & 0xf));
688 }
689
690 static inline void tcg_out_ld16s_r(TCGContext *s, int cond,
691 int rd, int rn, int rm)
692 {
693 tcg_out32(s, (cond << 28) | 0x019000f0 |
694 (rn << 16) | (rd << 12) | rm);
695 }
696
697 static inline void tcg_out_ld8_12(TCGContext *s, int cond,
698 int rd, int rn, tcg_target_long im)
699 {
700 if (im >= 0)
701 tcg_out32(s, (cond << 28) | 0x05d00000 |
702 (rn << 16) | (rd << 12) | (im & 0xfff));
703 else
704 tcg_out32(s, (cond << 28) | 0x05500000 |
705 (rn << 16) | (rd << 12) | ((-im) & 0xfff));
706 }
707
708 static inline void tcg_out_st8_12(TCGContext *s, int cond,
709 int rd, int rn, tcg_target_long im)
710 {
711 if (im >= 0)
712 tcg_out32(s, (cond << 28) | 0x05c00000 |
713 (rn << 16) | (rd << 12) | (im & 0xfff));
714 else
715 tcg_out32(s, (cond << 28) | 0x05400000 |
716 (rn << 16) | (rd << 12) | ((-im) & 0xfff));
717 }
718
719 static inline void tcg_out_ld8_r(TCGContext *s, int cond,
720 int rd, int rn, int rm)
721 {
722 tcg_out32(s, (cond << 28) | 0x07d00000 |
723 (rn << 16) | (rd << 12) | rm);
724 }
725
726 static inline void tcg_out_st8_r(TCGContext *s, int cond,
727 int rd, int rn, int rm)
728 {
729 tcg_out32(s, (cond << 28) | 0x07c00000 |
730 (rn << 16) | (rd << 12) | rm);
731 }
732
733 static inline void tcg_out_ld8s_8(TCGContext *s, int cond,
734 int rd, int rn, tcg_target_long im)
735 {
736 if (im >= 0)
737 tcg_out32(s, (cond << 28) | 0x01d000d0 |
738 (rn << 16) | (rd << 12) |
739 ((im & 0xf0) << 4) | (im & 0xf));
740 else
741 tcg_out32(s, (cond << 28) | 0x015000d0 |
742 (rn << 16) | (rd << 12) |
743 (((-im) & 0xf0) << 4) | ((-im) & 0xf));
744 }
745
746 static inline void tcg_out_ld8s_r(TCGContext *s, int cond,
747 int rd, int rn, int rm)
748 {
749 tcg_out32(s, (cond << 28) | 0x019000d0 |
750 (rn << 16) | (rd << 12) | rm);
751 }
752
753 static inline void tcg_out_ld32u(TCGContext *s, int cond,
754 int rd, int rn, int32_t offset)
755 {
756 if (offset > 0xfff || offset < -0xfff) {
757 tcg_out_movi32(s, cond, TCG_REG_R8, offset);
758 tcg_out_ld32_r(s, cond, rd, rn, TCG_REG_R8);
759 } else
760 tcg_out_ld32_12(s, cond, rd, rn, offset);
761 }
762
763 static inline void tcg_out_st32(TCGContext *s, int cond,
764 int rd, int rn, int32_t offset)
765 {
766 if (offset > 0xfff || offset < -0xfff) {
767 tcg_out_movi32(s, cond, TCG_REG_R8, offset);
768 tcg_out_st32_r(s, cond, rd, rn, TCG_REG_R8);
769 } else
770 tcg_out_st32_12(s, cond, rd, rn, offset);
771 }
772
773 static inline void tcg_out_ld16u(TCGContext *s, int cond,
774 int rd, int rn, int32_t offset)
775 {
776 if (offset > 0xff || offset < -0xff) {
777 tcg_out_movi32(s, cond, TCG_REG_R8, offset);
778 tcg_out_ld16u_r(s, cond, rd, rn, TCG_REG_R8);
779 } else
780 tcg_out_ld16u_8(s, cond, rd, rn, offset);
781 }
782
783 static inline void tcg_out_ld16s(TCGContext *s, int cond,
784 int rd, int rn, int32_t offset)
785 {
786 if (offset > 0xff || offset < -0xff) {
787 tcg_out_movi32(s, cond, TCG_REG_R8, offset);
788 tcg_out_ld16s_r(s, cond, rd, rn, TCG_REG_R8);
789 } else
790 tcg_out_ld16s_8(s, cond, rd, rn, offset);
791 }
792
793 static inline void tcg_out_st16(TCGContext *s, int cond,
794 int rd, int rn, int32_t offset)
795 {
796 if (offset > 0xff || offset < -0xff) {
797 tcg_out_movi32(s, cond, TCG_REG_R8, offset);
798 tcg_out_st16_r(s, cond, rd, rn, TCG_REG_R8);
799 } else
800 tcg_out_st16_8(s, cond, rd, rn, offset);
801 }
802
803 static inline void tcg_out_ld8u(TCGContext *s, int cond,
804 int rd, int rn, int32_t offset)
805 {
806 if (offset > 0xfff || offset < -0xfff) {
807 tcg_out_movi32(s, cond, TCG_REG_R8, offset);
808 tcg_out_ld8_r(s, cond, rd, rn, TCG_REG_R8);
809 } else
810 tcg_out_ld8_12(s, cond, rd, rn, offset);
811 }
812
813 static inline void tcg_out_ld8s(TCGContext *s, int cond,
814 int rd, int rn, int32_t offset)
815 {
816 if (offset > 0xff || offset < -0xff) {
817 tcg_out_movi32(s, cond, TCG_REG_R8, offset);
818 tcg_out_ld8s_r(s, cond, rd, rn, TCG_REG_R8);
819 } else
820 tcg_out_ld8s_8(s, cond, rd, rn, offset);
821 }
822
823 static inline void tcg_out_st8(TCGContext *s, int cond,
824 int rd, int rn, int32_t offset)
825 {
826 if (offset > 0xfff || offset < -0xfff) {
827 tcg_out_movi32(s, cond, TCG_REG_R8, offset);
828 tcg_out_st8_r(s, cond, rd, rn, TCG_REG_R8);
829 } else
830 tcg_out_st8_12(s, cond, rd, rn, offset);
831 }
832
833 static inline void tcg_out_goto(TCGContext *s, int cond, uint32_t addr)
834 {
835 int32_t val;
836
837 val = addr - (tcg_target_long) s->code_ptr;
838 if (val - 8 < 0x01fffffd && val - 8 > -0x01fffffd)
839 tcg_out_b(s, cond, val);
840 else {
841 #if 1
842 tcg_abort();
843 #else
844 if (cond == COND_AL) {
845 tcg_out_ld32_12(s, COND_AL, TCG_REG_PC, TCG_REG_PC, -4);
846 tcg_out32(s, addr); /* XXX: This is l->u.value, can we use it? */
847 } else {
848 tcg_out_movi32(s, cond, TCG_REG_R8, val - 8);
849 tcg_out_dat_reg(s, cond, ARITH_ADD,
850 TCG_REG_PC, TCG_REG_PC,
851 TCG_REG_R8, SHIFT_IMM_LSL(0));
852 }
853 #endif
854 }
855 }
856
857 static inline void tcg_out_call(TCGContext *s, int cond, uint32_t addr)
858 {
859 int32_t val;
860
861 val = addr - (tcg_target_long) s->code_ptr;
862 if (val < 0x01fffffd && val > -0x01fffffd)
863 tcg_out_bl(s, cond, val);
864 else {
865 #if 1
866 tcg_abort();
867 #else
868 if (cond == COND_AL) {
869 tcg_out_dat_imm(s, cond, ARITH_ADD, TCG_REG_R14, TCG_REG_PC, 4);
870 tcg_out_ld32_12(s, COND_AL, TCG_REG_PC, TCG_REG_PC, -4);
871 tcg_out32(s, addr); /* XXX: This is l->u.value, can we use it? */
872 } else {
873 tcg_out_movi32(s, cond, TCG_REG_R9, addr);
874 tcg_out_dat_reg(s, cond, ARITH_MOV, TCG_REG_R14, 0,
875 TCG_REG_PC, SHIFT_IMM_LSL(0));
876 tcg_out_bx(s, cond, TCG_REG_R9);
877 }
878 #endif
879 }
880 }
881
882 static inline void tcg_out_callr(TCGContext *s, int cond, int arg)
883 {
884 if (use_armv5_instructions) {
885 tcg_out_blx(s, cond, arg);
886 } else {
887 tcg_out_dat_reg(s, cond, ARITH_MOV, TCG_REG_R14, 0,
888 TCG_REG_PC, SHIFT_IMM_LSL(0));
889 tcg_out_bx(s, cond, arg);
890 }
891 }
892
893 static inline void tcg_out_goto_label(TCGContext *s, int cond, int label_index)
894 {
895 TCGLabel *l = &s->labels[label_index];
896
897 if (l->has_value)
898 tcg_out_goto(s, cond, l->u.value);
899 else if (cond == COND_AL) {
900 tcg_out_ld32_12(s, COND_AL, TCG_REG_PC, TCG_REG_PC, -4);
901 tcg_out_reloc(s, s->code_ptr, R_ARM_ABS32, label_index, 31337);
902 s->code_ptr += 4;
903 } else {
904 /* Probably this should be preferred even for COND_AL... */
905 tcg_out_reloc(s, s->code_ptr, R_ARM_PC24, label_index, 31337);
906 tcg_out_b_noaddr(s, cond);
907 }
908 }
909
910 #ifdef CONFIG_SOFTMMU
911
912 #include "../../softmmu_defs.h"
913
914 static void *qemu_ld_helpers[4] = {
915 __ldb_mmu,
916 __ldw_mmu,
917 __ldl_mmu,
918 __ldq_mmu,
919 };
920
921 static void *qemu_st_helpers[4] = {
922 __stb_mmu,
923 __stw_mmu,
924 __stl_mmu,
925 __stq_mmu,
926 };
927 #endif
928
929 #define TLB_SHIFT (CPU_TLB_ENTRY_BITS + CPU_TLB_BITS)
930
931 static inline void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args, int opc)
932 {
933 int addr_reg, data_reg, data_reg2, bswap;
934 #ifdef CONFIG_SOFTMMU
935 int mem_index, s_bits;
936 # if TARGET_LONG_BITS == 64
937 int addr_reg2;
938 # endif
939 uint32_t *label_ptr;
940 #endif
941
942 #ifdef TARGET_WORDS_BIGENDIAN
943 bswap = 1;
944 #else
945 bswap = 0;
946 #endif
947 data_reg = *args++;
948 if (opc == 3)
949 data_reg2 = *args++;
950 else
951 data_reg2 = 0; /* suppress warning */
952 addr_reg = *args++;
953 #ifdef CONFIG_SOFTMMU
954 # if TARGET_LONG_BITS == 64
955 addr_reg2 = *args++;
956 # endif
957 mem_index = *args;
958 s_bits = opc & 3;
959
960 /* Should generate something like the following:
961 * shr r8, addr_reg, #TARGET_PAGE_BITS
962 * and r0, r8, #(CPU_TLB_SIZE - 1) @ Assumption: CPU_TLB_BITS <= 8
963 * add r0, env, r0 lsl #CPU_TLB_ENTRY_BITS
964 */
965 # if CPU_TLB_BITS > 8
966 # error
967 # endif
968 tcg_out_dat_reg(s, COND_AL, ARITH_MOV, TCG_REG_R8,
969 0, addr_reg, SHIFT_IMM_LSR(TARGET_PAGE_BITS));
970 tcg_out_dat_imm(s, COND_AL, ARITH_AND,
971 TCG_REG_R0, TCG_REG_R8, CPU_TLB_SIZE - 1);
972 tcg_out_dat_reg(s, COND_AL, ARITH_ADD, TCG_REG_R0, TCG_AREG0,
973 TCG_REG_R0, SHIFT_IMM_LSL(CPU_TLB_ENTRY_BITS));
974 /* In the
975 * ldr r1 [r0, #(offsetof(CPUState, tlb_table[mem_index][0].addr_read))]
976 * below, the offset is likely to exceed 12 bits if mem_index != 0 and
977 * not exceed otherwise, so use an
978 * add r0, r0, #(mem_index * sizeof *CPUState.tlb_table)
979 * before.
980 */
981 if (mem_index)
982 tcg_out_dat_imm(s, COND_AL, ARITH_ADD, TCG_REG_R0, TCG_REG_R0,
983 (mem_index << (TLB_SHIFT & 1)) |
984 ((16 - (TLB_SHIFT >> 1)) << 8));
985 tcg_out_ld32_12(s, COND_AL, TCG_REG_R1, TCG_REG_R0,
986 offsetof(CPUState, tlb_table[0][0].addr_read));
987 tcg_out_dat_reg(s, COND_AL, ARITH_CMP, 0, TCG_REG_R1,
988 TCG_REG_R8, SHIFT_IMM_LSL(TARGET_PAGE_BITS));
989 /* Check alignment. */
990 if (s_bits)
991 tcg_out_dat_imm(s, COND_EQ, ARITH_TST,
992 0, addr_reg, (1 << s_bits) - 1);
993 # if TARGET_LONG_BITS == 64
994 /* XXX: possibly we could use a block data load or writeback in
995 * the first access. */
996 tcg_out_ld32_12(s, COND_EQ, TCG_REG_R1, TCG_REG_R0,
997 offsetof(CPUState, tlb_table[0][0].addr_read) + 4);
998 tcg_out_dat_reg(s, COND_EQ, ARITH_CMP, 0,
999 TCG_REG_R1, addr_reg2, SHIFT_IMM_LSL(0));
1000 # endif
1001 tcg_out_ld32_12(s, COND_EQ, TCG_REG_R1, TCG_REG_R0,
1002 offsetof(CPUState, tlb_table[0][0].addend));
1003
1004 switch (opc) {
1005 case 0:
1006 tcg_out_ld8_r(s, COND_EQ, data_reg, addr_reg, TCG_REG_R1);
1007 break;
1008 case 0 | 4:
1009 tcg_out_ld8s_r(s, COND_EQ, data_reg, addr_reg, TCG_REG_R1);
1010 break;
1011 case 1:
1012 tcg_out_ld16u_r(s, COND_EQ, data_reg, addr_reg, TCG_REG_R1);
1013 if (bswap) {
1014 tcg_out_bswap16(s, COND_EQ, data_reg, data_reg);
1015 }
1016 break;
1017 case 1 | 4:
1018 if (bswap) {
1019 tcg_out_ld16u_r(s, COND_EQ, data_reg, addr_reg, TCG_REG_R1);
1020 tcg_out_bswap16s(s, COND_EQ, data_reg, data_reg);
1021 } else {
1022 tcg_out_ld16s_r(s, COND_EQ, data_reg, addr_reg, TCG_REG_R1);
1023 }
1024 break;
1025 case 2:
1026 default:
1027 tcg_out_ld32_r(s, COND_EQ, data_reg, addr_reg, TCG_REG_R1);
1028 if (bswap) {
1029 tcg_out_bswap32(s, COND_EQ, data_reg, data_reg);
1030 }
1031 break;
1032 case 3:
1033 if (bswap) {
1034 tcg_out_ld32_rwb(s, COND_EQ, data_reg2, TCG_REG_R1, addr_reg);
1035 tcg_out_ld32_12(s, COND_EQ, data_reg, TCG_REG_R1, 4);
1036 tcg_out_bswap32(s, COND_EQ, data_reg2, data_reg2);
1037 tcg_out_bswap32(s, COND_EQ, data_reg, data_reg);
1038 } else {
1039 tcg_out_ld32_rwb(s, COND_EQ, data_reg, TCG_REG_R1, addr_reg);
1040 tcg_out_ld32_12(s, COND_EQ, data_reg2, TCG_REG_R1, 4);
1041 }
1042 break;
1043 }
1044
1045 label_ptr = (void *) s->code_ptr;
1046 tcg_out_b_noaddr(s, COND_EQ);
1047
1048 /* TODO: move this code to where the constants pool will be */
1049 if (addr_reg != TCG_REG_R0) {
1050 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1051 TCG_REG_R0, 0, addr_reg, SHIFT_IMM_LSL(0));
1052 }
1053 # if TARGET_LONG_BITS == 32
1054 tcg_out_dat_imm(s, COND_AL, ARITH_MOV, TCG_REG_R1, 0, mem_index);
1055 # else
1056 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1057 TCG_REG_R1, 0, addr_reg2, SHIFT_IMM_LSL(0));
1058 tcg_out_dat_imm(s, COND_AL, ARITH_MOV, TCG_REG_R2, 0, mem_index);
1059 # endif
1060 tcg_out_bl(s, COND_AL, (tcg_target_long) qemu_ld_helpers[s_bits] -
1061 (tcg_target_long) s->code_ptr);
1062
1063 switch (opc) {
1064 case 0 | 4:
1065 tcg_out_ext8s(s, COND_AL, data_reg, TCG_REG_R0);
1066 break;
1067 case 1 | 4:
1068 tcg_out_ext16s(s, COND_AL, data_reg, TCG_REG_R0);
1069 break;
1070 case 0:
1071 case 1:
1072 case 2:
1073 default:
1074 if (data_reg != TCG_REG_R0) {
1075 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1076 data_reg, 0, TCG_REG_R0, SHIFT_IMM_LSL(0));
1077 }
1078 break;
1079 case 3:
1080 if (data_reg != TCG_REG_R0) {
1081 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1082 data_reg, 0, TCG_REG_R0, SHIFT_IMM_LSL(0));
1083 }
1084 if (data_reg2 != TCG_REG_R1) {
1085 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1086 data_reg2, 0, TCG_REG_R1, SHIFT_IMM_LSL(0));
1087 }
1088 break;
1089 }
1090
1091 reloc_pc24(label_ptr, (tcg_target_long)s->code_ptr);
1092 #else /* !CONFIG_SOFTMMU */
1093 if (GUEST_BASE) {
1094 uint32_t offset = GUEST_BASE;
1095 int i;
1096 int rot;
1097
1098 while (offset) {
1099 i = ctz32(offset) & ~1;
1100 rot = ((32 - i) << 7) & 0xf00;
1101
1102 tcg_out_dat_imm(s, COND_AL, ARITH_ADD, TCG_REG_R8, addr_reg,
1103 ((offset >> i) & 0xff) | rot);
1104 addr_reg = TCG_REG_R8;
1105 offset &= ~(0xff << i);
1106 }
1107 }
1108 switch (opc) {
1109 case 0:
1110 tcg_out_ld8_12(s, COND_AL, data_reg, addr_reg, 0);
1111 break;
1112 case 0 | 4:
1113 tcg_out_ld8s_8(s, COND_AL, data_reg, addr_reg, 0);
1114 break;
1115 case 1:
1116 tcg_out_ld16u_8(s, COND_AL, data_reg, addr_reg, 0);
1117 if (bswap) {
1118 tcg_out_bswap16(s, COND_AL, data_reg, data_reg);
1119 }
1120 break;
1121 case 1 | 4:
1122 if (bswap) {
1123 tcg_out_ld16u_8(s, COND_AL, data_reg, addr_reg, 0);
1124 tcg_out_bswap16s(s, COND_AL, data_reg, data_reg);
1125 } else {
1126 tcg_out_ld16s_8(s, COND_AL, data_reg, addr_reg, 0);
1127 }
1128 break;
1129 case 2:
1130 default:
1131 tcg_out_ld32_12(s, COND_AL, data_reg, addr_reg, 0);
1132 if (bswap) {
1133 tcg_out_bswap32(s, COND_AL, data_reg, data_reg);
1134 }
1135 break;
1136 case 3:
1137 /* TODO: use block load -
1138 * check that data_reg2 > data_reg or the other way */
1139 if (data_reg == addr_reg) {
1140 tcg_out_ld32_12(s, COND_AL, data_reg2, addr_reg, bswap ? 0 : 4);
1141 tcg_out_ld32_12(s, COND_AL, data_reg, addr_reg, bswap ? 4 : 0);
1142 } else {
1143 tcg_out_ld32_12(s, COND_AL, data_reg, addr_reg, bswap ? 4 : 0);
1144 tcg_out_ld32_12(s, COND_AL, data_reg2, addr_reg, bswap ? 0 : 4);
1145 }
1146 if (bswap) {
1147 tcg_out_bswap32(s, COND_AL, data_reg, data_reg);
1148 tcg_out_bswap32(s, COND_AL, data_reg2, data_reg2);
1149 }
1150 break;
1151 }
1152 #endif
1153 }
1154
1155 static inline void tcg_out_qemu_st(TCGContext *s, const TCGArg *args, int opc)
1156 {
1157 int addr_reg, data_reg, data_reg2, bswap;
1158 #ifdef CONFIG_SOFTMMU
1159 int mem_index, s_bits;
1160 # if TARGET_LONG_BITS == 64
1161 int addr_reg2;
1162 # endif
1163 uint32_t *label_ptr;
1164 #endif
1165
1166 #ifdef TARGET_WORDS_BIGENDIAN
1167 bswap = 1;
1168 #else
1169 bswap = 0;
1170 #endif
1171 data_reg = *args++;
1172 if (opc == 3)
1173 data_reg2 = *args++;
1174 else
1175 data_reg2 = 0; /* suppress warning */
1176 addr_reg = *args++;
1177 #ifdef CONFIG_SOFTMMU
1178 # if TARGET_LONG_BITS == 64
1179 addr_reg2 = *args++;
1180 # endif
1181 mem_index = *args;
1182 s_bits = opc & 3;
1183
1184 /* Should generate something like the following:
1185 * shr r8, addr_reg, #TARGET_PAGE_BITS
1186 * and r0, r8, #(CPU_TLB_SIZE - 1) @ Assumption: CPU_TLB_BITS <= 8
1187 * add r0, env, r0 lsl #CPU_TLB_ENTRY_BITS
1188 */
1189 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1190 TCG_REG_R8, 0, addr_reg, SHIFT_IMM_LSR(TARGET_PAGE_BITS));
1191 tcg_out_dat_imm(s, COND_AL, ARITH_AND,
1192 TCG_REG_R0, TCG_REG_R8, CPU_TLB_SIZE - 1);
1193 tcg_out_dat_reg(s, COND_AL, ARITH_ADD, TCG_REG_R0,
1194 TCG_AREG0, TCG_REG_R0, SHIFT_IMM_LSL(CPU_TLB_ENTRY_BITS));
1195 /* In the
1196 * ldr r1 [r0, #(offsetof(CPUState, tlb_table[mem_index][0].addr_write))]
1197 * below, the offset is likely to exceed 12 bits if mem_index != 0 and
1198 * not exceed otherwise, so use an
1199 * add r0, r0, #(mem_index * sizeof *CPUState.tlb_table)
1200 * before.
1201 */
1202 if (mem_index)
1203 tcg_out_dat_imm(s, COND_AL, ARITH_ADD, TCG_REG_R0, TCG_REG_R0,
1204 (mem_index << (TLB_SHIFT & 1)) |
1205 ((16 - (TLB_SHIFT >> 1)) << 8));
1206 tcg_out_ld32_12(s, COND_AL, TCG_REG_R1, TCG_REG_R0,
1207 offsetof(CPUState, tlb_table[0][0].addr_write));
1208 tcg_out_dat_reg(s, COND_AL, ARITH_CMP, 0, TCG_REG_R1,
1209 TCG_REG_R8, SHIFT_IMM_LSL(TARGET_PAGE_BITS));
1210 /* Check alignment. */
1211 if (s_bits)
1212 tcg_out_dat_imm(s, COND_EQ, ARITH_TST,
1213 0, addr_reg, (1 << s_bits) - 1);
1214 # if TARGET_LONG_BITS == 64
1215 /* XXX: possibly we could use a block data load or writeback in
1216 * the first access. */
1217 tcg_out_ld32_12(s, COND_EQ, TCG_REG_R1, TCG_REG_R0,
1218 offsetof(CPUState, tlb_table[0][0].addr_write) + 4);
1219 tcg_out_dat_reg(s, COND_EQ, ARITH_CMP, 0,
1220 TCG_REG_R1, addr_reg2, SHIFT_IMM_LSL(0));
1221 # endif
1222 tcg_out_ld32_12(s, COND_EQ, TCG_REG_R1, TCG_REG_R0,
1223 offsetof(CPUState, tlb_table[0][0].addend));
1224
1225 switch (opc) {
1226 case 0:
1227 tcg_out_st8_r(s, COND_EQ, data_reg, addr_reg, TCG_REG_R1);
1228 break;
1229 case 1:
1230 if (bswap) {
1231 tcg_out_bswap16(s, COND_EQ, TCG_REG_R0, data_reg);
1232 tcg_out_st16_r(s, COND_EQ, TCG_REG_R0, addr_reg, TCG_REG_R1);
1233 } else {
1234 tcg_out_st16_r(s, COND_EQ, data_reg, addr_reg, TCG_REG_R1);
1235 }
1236 break;
1237 case 2:
1238 default:
1239 if (bswap) {
1240 tcg_out_bswap32(s, COND_EQ, TCG_REG_R0, data_reg);
1241 tcg_out_st32_r(s, COND_EQ, TCG_REG_R0, addr_reg, TCG_REG_R1);
1242 } else {
1243 tcg_out_st32_r(s, COND_EQ, data_reg, addr_reg, TCG_REG_R1);
1244 }
1245 break;
1246 case 3:
1247 if (bswap) {
1248 tcg_out_bswap32(s, COND_EQ, TCG_REG_R0, data_reg2);
1249 tcg_out_st32_rwb(s, COND_EQ, TCG_REG_R0, TCG_REG_R1, addr_reg);
1250 tcg_out_bswap32(s, COND_EQ, TCG_REG_R0, data_reg);
1251 tcg_out_st32_12(s, COND_EQ, data_reg, TCG_REG_R1, 4);
1252 } else {
1253 tcg_out_st32_rwb(s, COND_EQ, data_reg, TCG_REG_R1, addr_reg);
1254 tcg_out_st32_12(s, COND_EQ, data_reg2, TCG_REG_R1, 4);
1255 }
1256 break;
1257 }
1258
1259 label_ptr = (void *) s->code_ptr;
1260 tcg_out_b_noaddr(s, COND_EQ);
1261
1262 /* TODO: move this code to where the constants pool will be */
1263 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1264 TCG_REG_R0, 0, addr_reg, SHIFT_IMM_LSL(0));
1265 # if TARGET_LONG_BITS == 32
1266 switch (opc) {
1267 case 0:
1268 tcg_out_ext8u(s, COND_AL, TCG_REG_R1, data_reg);
1269 tcg_out_dat_imm(s, COND_AL, ARITH_MOV, TCG_REG_R2, 0, mem_index);
1270 break;
1271 case 1:
1272 tcg_out_ext16u(s, COND_AL, TCG_REG_R1, data_reg);
1273 tcg_out_dat_imm(s, COND_AL, ARITH_MOV, TCG_REG_R2, 0, mem_index);
1274 break;
1275 case 2:
1276 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1277 TCG_REG_R1, 0, data_reg, SHIFT_IMM_LSL(0));
1278 tcg_out_dat_imm(s, COND_AL, ARITH_MOV, TCG_REG_R2, 0, mem_index);
1279 break;
1280 case 3:
1281 tcg_out_dat_imm(s, COND_AL, ARITH_MOV, TCG_REG_R8, 0, mem_index);
1282 tcg_out32(s, (COND_AL << 28) | 0x052d8010); /* str r8, [sp, #-0x10]! */
1283 if (data_reg != TCG_REG_R2) {
1284 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1285 TCG_REG_R2, 0, data_reg, SHIFT_IMM_LSL(0));
1286 }
1287 if (data_reg2 != TCG_REG_R3) {
1288 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1289 TCG_REG_R3, 0, data_reg2, SHIFT_IMM_LSL(0));
1290 }
1291 break;
1292 }
1293 # else
1294 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1295 TCG_REG_R1, 0, addr_reg2, SHIFT_IMM_LSL(0));
1296 switch (opc) {
1297 case 0:
1298 tcg_out_ext8u(s, COND_AL, TCG_REG_R2, data_reg);
1299 tcg_out_dat_imm(s, COND_AL, ARITH_MOV, TCG_REG_R3, 0, mem_index);
1300 break;
1301 case 1:
1302 tcg_out_ext16u(s, COND_AL, TCG_REG_R2, data_reg);
1303 tcg_out_dat_imm(s, COND_AL, ARITH_MOV, TCG_REG_R3, 0, mem_index);
1304 break;
1305 case 2:
1306 if (data_reg != TCG_REG_R2) {
1307 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1308 TCG_REG_R2, 0, data_reg, SHIFT_IMM_LSL(0));
1309 }
1310 tcg_out_dat_imm(s, COND_AL, ARITH_MOV, TCG_REG_R3, 0, mem_index);
1311 break;
1312 case 3:
1313 tcg_out_dat_imm(s, COND_AL, ARITH_MOV, TCG_REG_R8, 0, mem_index);
1314 tcg_out32(s, (COND_AL << 28) | 0x052d8010); /* str r8, [sp, #-0x10]! */
1315 if (data_reg != TCG_REG_R2) {
1316 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1317 TCG_REG_R2, 0, data_reg, SHIFT_IMM_LSL(0));
1318 }
1319 if (data_reg2 != TCG_REG_R3) {
1320 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1321 TCG_REG_R3, 0, data_reg2, SHIFT_IMM_LSL(0));
1322 }
1323 break;
1324 }
1325 # endif
1326
1327 tcg_out_bl(s, COND_AL, (tcg_target_long) qemu_st_helpers[s_bits] -
1328 (tcg_target_long) s->code_ptr);
1329 if (opc == 3)
1330 tcg_out_dat_imm(s, COND_AL, ARITH_ADD, TCG_REG_R13, TCG_REG_R13, 0x10);
1331
1332 reloc_pc24(label_ptr, (tcg_target_long)s->code_ptr);
1333 #else /* !CONFIG_SOFTMMU */
1334 if (GUEST_BASE) {
1335 uint32_t offset = GUEST_BASE;
1336 int i;
1337 int rot;
1338
1339 while (offset) {
1340 i = ctz32(offset) & ~1;
1341 rot = ((32 - i) << 7) & 0xf00;
1342
1343 tcg_out_dat_imm(s, COND_AL, ARITH_ADD, TCG_REG_R1, addr_reg,
1344 ((offset >> i) & 0xff) | rot);
1345 addr_reg = TCG_REG_R1;
1346 offset &= ~(0xff << i);
1347 }
1348 }
1349 switch (opc) {
1350 case 0:
1351 tcg_out_st8_12(s, COND_AL, data_reg, addr_reg, 0);
1352 break;
1353 case 1:
1354 if (bswap) {
1355 tcg_out_bswap16(s, COND_AL, TCG_REG_R0, data_reg);
1356 tcg_out_st16_8(s, COND_AL, TCG_REG_R0, addr_reg, 0);
1357 } else {
1358 tcg_out_st16_8(s, COND_AL, data_reg, addr_reg, 0);
1359 }
1360 break;
1361 case 2:
1362 default:
1363 if (bswap) {
1364 tcg_out_bswap32(s, COND_AL, TCG_REG_R0, data_reg);
1365 tcg_out_st32_12(s, COND_AL, TCG_REG_R0, addr_reg, 0);
1366 } else {
1367 tcg_out_st32_12(s, COND_AL, data_reg, addr_reg, 0);
1368 }
1369 break;
1370 case 3:
1371 /* TODO: use block store -
1372 * check that data_reg2 > data_reg or the other way */
1373 if (bswap) {
1374 tcg_out_bswap32(s, COND_AL, TCG_REG_R0, data_reg2);
1375 tcg_out_st32_12(s, COND_AL, TCG_REG_R0, addr_reg, 0);
1376 tcg_out_bswap32(s, COND_AL, TCG_REG_R0, data_reg);
1377 tcg_out_st32_12(s, COND_AL, TCG_REG_R0, addr_reg, 4);
1378 } else {
1379 tcg_out_st32_12(s, COND_AL, data_reg, addr_reg, 0);
1380 tcg_out_st32_12(s, COND_AL, data_reg2, addr_reg, 4);
1381 }
1382 break;
1383 }
1384 #endif
1385 }
1386
1387 static uint8_t *tb_ret_addr;
1388
1389 static inline void tcg_out_op(TCGContext *s, TCGOpcode opc,
1390 const TCGArg *args, const int *const_args)
1391 {
1392 int c;
1393
1394 switch (opc) {
1395 case INDEX_op_exit_tb:
1396 {
1397 uint8_t *ld_ptr = s->code_ptr;
1398 if (args[0] >> 8)
1399 tcg_out_ld32_12(s, COND_AL, TCG_REG_R0, TCG_REG_PC, 0);
1400 else
1401 tcg_out_dat_imm(s, COND_AL, ARITH_MOV, TCG_REG_R0, 0, args[0]);
1402 tcg_out_goto(s, COND_AL, (tcg_target_ulong) tb_ret_addr);
1403 if (args[0] >> 8) {
1404 *ld_ptr = (uint8_t) (s->code_ptr - ld_ptr) - 8;
1405 tcg_out32(s, args[0]);
1406 }
1407 }
1408 break;
1409 case INDEX_op_goto_tb:
1410 if (s->tb_jmp_offset) {
1411 /* Direct jump method */
1412 #if defined(USE_DIRECT_JUMP)
1413 s->tb_jmp_offset[args[0]] = s->code_ptr - s->code_buf;
1414 tcg_out_b_noaddr(s, COND_AL);
1415 #else
1416 tcg_out_ld32_12(s, COND_AL, TCG_REG_PC, TCG_REG_PC, -4);
1417 s->tb_jmp_offset[args[0]] = s->code_ptr - s->code_buf;
1418 tcg_out32(s, 0);
1419 #endif
1420 } else {
1421 /* Indirect jump method */
1422 #if 1
1423 c = (int) (s->tb_next + args[0]) - ((int) s->code_ptr + 8);
1424 if (c > 0xfff || c < -0xfff) {
1425 tcg_out_movi32(s, COND_AL, TCG_REG_R0,
1426 (tcg_target_long) (s->tb_next + args[0]));
1427 tcg_out_ld32_12(s, COND_AL, TCG_REG_PC, TCG_REG_R0, 0);
1428 } else
1429 tcg_out_ld32_12(s, COND_AL, TCG_REG_PC, TCG_REG_PC, c);
1430 #else
1431 tcg_out_ld32_12(s, COND_AL, TCG_REG_R0, TCG_REG_PC, 0);
1432 tcg_out_ld32_12(s, COND_AL, TCG_REG_PC, TCG_REG_R0, 0);
1433 tcg_out32(s, (tcg_target_long) (s->tb_next + args[0]));
1434 #endif
1435 }
1436 s->tb_next_offset[args[0]] = s->code_ptr - s->code_buf;
1437 break;
1438 case INDEX_op_call:
1439 if (const_args[0])
1440 tcg_out_call(s, COND_AL, args[0]);
1441 else
1442 tcg_out_callr(s, COND_AL, args[0]);
1443 break;
1444 case INDEX_op_jmp:
1445 if (const_args[0])
1446 tcg_out_goto(s, COND_AL, args[0]);
1447 else
1448 tcg_out_bx(s, COND_AL, args[0]);
1449 break;
1450 case INDEX_op_br:
1451 tcg_out_goto_label(s, COND_AL, args[0]);
1452 break;
1453
1454 case INDEX_op_ld8u_i32:
1455 tcg_out_ld8u(s, COND_AL, args[0], args[1], args[2]);
1456 break;
1457 case INDEX_op_ld8s_i32:
1458 tcg_out_ld8s(s, COND_AL, args[0], args[1], args[2]);
1459 break;
1460 case INDEX_op_ld16u_i32:
1461 tcg_out_ld16u(s, COND_AL, args[0], args[1], args[2]);
1462 break;
1463 case INDEX_op_ld16s_i32:
1464 tcg_out_ld16s(s, COND_AL, args[0], args[1], args[2]);
1465 break;
1466 case INDEX_op_ld_i32:
1467 tcg_out_ld32u(s, COND_AL, args[0], args[1], args[2]);
1468 break;
1469 case INDEX_op_st8_i32:
1470 tcg_out_st8(s, COND_AL, args[0], args[1], args[2]);
1471 break;
1472 case INDEX_op_st16_i32:
1473 tcg_out_st16(s, COND_AL, args[0], args[1], args[2]);
1474 break;
1475 case INDEX_op_st_i32:
1476 tcg_out_st32(s, COND_AL, args[0], args[1], args[2]);
1477 break;
1478
1479 case INDEX_op_mov_i32:
1480 tcg_out_dat_reg(s, COND_AL, ARITH_MOV,
1481 args[0], 0, args[1], SHIFT_IMM_LSL(0));
1482 break;
1483 case INDEX_op_movi_i32:
1484 tcg_out_movi32(s, COND_AL, args[0], args[1]);
1485 break;
1486 case INDEX_op_add_i32:
1487 c = ARITH_ADD;
1488 goto gen_arith;
1489 case INDEX_op_sub_i32:
1490 c = ARITH_SUB;
1491 goto gen_arith;
1492 case INDEX_op_and_i32:
1493 c = ARITH_AND;
1494 goto gen_arith;
1495 case INDEX_op_andc_i32:
1496 c = ARITH_BIC;
1497 goto gen_arith;
1498 case INDEX_op_or_i32:
1499 c = ARITH_ORR;
1500 goto gen_arith;
1501 case INDEX_op_xor_i32:
1502 c = ARITH_EOR;
1503 /* Fall through. */
1504 gen_arith:
1505 if (const_args[2]) {
1506 int rot;
1507 rot = encode_imm(args[2]);
1508 tcg_out_dat_imm(s, COND_AL, c,
1509 args[0], args[1], rotl(args[2], rot) | (rot << 7));
1510 } else
1511 tcg_out_dat_reg(s, COND_AL, c,
1512 args[0], args[1], args[2], SHIFT_IMM_LSL(0));
1513 break;
1514 case INDEX_op_add2_i32:
1515 tcg_out_dat_reg2(s, COND_AL, ARITH_ADD, ARITH_ADC,
1516 args[0], args[1], args[2], args[3],
1517 args[4], args[5], SHIFT_IMM_LSL(0));
1518 break;
1519 case INDEX_op_sub2_i32:
1520 tcg_out_dat_reg2(s, COND_AL, ARITH_SUB, ARITH_SBC,
1521 args[0], args[1], args[2], args[3],
1522 args[4], args[5], SHIFT_IMM_LSL(0));
1523 break;
1524 case INDEX_op_neg_i32:
1525 tcg_out_dat_imm(s, COND_AL, ARITH_RSB, args[0], args[1], 0);
1526 break;
1527 case INDEX_op_not_i32:
1528 tcg_out_dat_reg(s, COND_AL,
1529 ARITH_MVN, args[0], 0, args[1], SHIFT_IMM_LSL(0));
1530 break;
1531 case INDEX_op_mul_i32:
1532 tcg_out_mul32(s, COND_AL, args[0], args[1], args[2]);
1533 break;
1534 case INDEX_op_mulu2_i32:
1535 tcg_out_umull32(s, COND_AL, args[0], args[1], args[2], args[3]);
1536 break;
1537 /* XXX: Perhaps args[2] & 0x1f is wrong */
1538 case INDEX_op_shl_i32:
1539 c = const_args[2] ?
1540 SHIFT_IMM_LSL(args[2] & 0x1f) : SHIFT_REG_LSL(args[2]);
1541 goto gen_shift32;
1542 case INDEX_op_shr_i32:
1543 c = const_args[2] ? (args[2] & 0x1f) ? SHIFT_IMM_LSR(args[2] & 0x1f) :
1544 SHIFT_IMM_LSL(0) : SHIFT_REG_LSR(args[2]);
1545 goto gen_shift32;
1546 case INDEX_op_sar_i32:
1547 c = const_args[2] ? (args[2] & 0x1f) ? SHIFT_IMM_ASR(args[2] & 0x1f) :
1548 SHIFT_IMM_LSL(0) : SHIFT_REG_ASR(args[2]);
1549 goto gen_shift32;
1550 case INDEX_op_rotr_i32:
1551 c = const_args[2] ? (args[2] & 0x1f) ? SHIFT_IMM_ROR(args[2] & 0x1f) :
1552 SHIFT_IMM_LSL(0) : SHIFT_REG_ROR(args[2]);
1553 /* Fall through. */
1554 gen_shift32:
1555 tcg_out_dat_reg(s, COND_AL, ARITH_MOV, args[0], 0, args[1], c);
1556 break;
1557
1558 case INDEX_op_rotl_i32:
1559 if (const_args[2]) {
1560 tcg_out_dat_reg(s, COND_AL, ARITH_MOV, args[0], 0, args[1],
1561 ((0x20 - args[2]) & 0x1f) ?
1562 SHIFT_IMM_ROR((0x20 - args[2]) & 0x1f) :
1563 SHIFT_IMM_LSL(0));
1564 } else {
1565 tcg_out_dat_imm(s, COND_AL, ARITH_RSB, TCG_REG_R8, args[1], 0x20);
1566 tcg_out_dat_reg(s, COND_AL, ARITH_MOV, args[0], 0, args[1],
1567 SHIFT_REG_ROR(TCG_REG_R8));
1568 }
1569 break;
1570
1571 case INDEX_op_brcond_i32:
1572 if (const_args[1]) {
1573 int rot;
1574 rot = encode_imm(args[1]);
1575 tcg_out_dat_imm(s, COND_AL, ARITH_CMP, 0,
1576 args[0], rotl(args[1], rot) | (rot << 7));
1577 } else {
1578 tcg_out_dat_reg(s, COND_AL, ARITH_CMP, 0,
1579 args[0], args[1], SHIFT_IMM_LSL(0));
1580 }
1581 tcg_out_goto_label(s, tcg_cond_to_arm_cond[args[2]], args[3]);
1582 break;
1583 case INDEX_op_brcond2_i32:
1584 /* The resulting conditions are:
1585 * TCG_COND_EQ --> a0 == a2 && a1 == a3,
1586 * TCG_COND_NE --> (a0 != a2 && a1 == a3) || a1 != a3,
1587 * TCG_COND_LT(U) --> (a0 < a2 && a1 == a3) || a1 < a3,
1588 * TCG_COND_GE(U) --> (a0 >= a2 && a1 == a3) || (a1 >= a3 && a1 != a3),
1589 * TCG_COND_LE(U) --> (a0 <= a2 && a1 == a3) || (a1 <= a3 && a1 != a3),
1590 * TCG_COND_GT(U) --> (a0 > a2 && a1 == a3) || a1 > a3,
1591 */
1592 tcg_out_dat_reg(s, COND_AL, ARITH_CMP, 0,
1593 args[1], args[3], SHIFT_IMM_LSL(0));
1594 tcg_out_dat_reg(s, COND_EQ, ARITH_CMP, 0,
1595 args[0], args[2], SHIFT_IMM_LSL(0));
1596 tcg_out_goto_label(s, tcg_cond_to_arm_cond[args[4]], args[5]);
1597 break;
1598 case INDEX_op_setcond_i32:
1599 if (const_args[2]) {
1600 int rot;
1601 rot = encode_imm(args[2]);
1602 tcg_out_dat_imm(s, COND_AL, ARITH_CMP, 0,
1603 args[1], rotl(args[2], rot) | (rot << 7));
1604 } else {
1605 tcg_out_dat_reg(s, COND_AL, ARITH_CMP, 0,
1606 args[1], args[2], SHIFT_IMM_LSL(0));
1607 }
1608 tcg_out_dat_imm(s, tcg_cond_to_arm_cond[args[3]],
1609 ARITH_MOV, args[0], 0, 1);
1610 tcg_out_dat_imm(s, tcg_cond_to_arm_cond[tcg_invert_cond(args[3])],
1611 ARITH_MOV, args[0], 0, 0);
1612 break;
1613 case INDEX_op_setcond2_i32:
1614 /* See brcond2_i32 comment */
1615 tcg_out_dat_reg(s, COND_AL, ARITH_CMP, 0,
1616 args[2], args[4], SHIFT_IMM_LSL(0));
1617 tcg_out_dat_reg(s, COND_EQ, ARITH_CMP, 0,
1618 args[1], args[3], SHIFT_IMM_LSL(0));
1619 tcg_out_dat_imm(s, tcg_cond_to_arm_cond[args[5]],
1620 ARITH_MOV, args[0], 0, 1);
1621 tcg_out_dat_imm(s, tcg_cond_to_arm_cond[tcg_invert_cond(args[5])],
1622 ARITH_MOV, args[0], 0, 0);
1623 break;
1624
1625 case INDEX_op_qemu_ld8u:
1626 tcg_out_qemu_ld(s, args, 0);
1627 break;
1628 case INDEX_op_qemu_ld8s:
1629 tcg_out_qemu_ld(s, args, 0 | 4);
1630 break;
1631 case INDEX_op_qemu_ld16u:
1632 tcg_out_qemu_ld(s, args, 1);
1633 break;
1634 case INDEX_op_qemu_ld16s:
1635 tcg_out_qemu_ld(s, args, 1 | 4);
1636 break;
1637 case INDEX_op_qemu_ld32:
1638 tcg_out_qemu_ld(s, args, 2);
1639 break;
1640 case INDEX_op_qemu_ld64:
1641 tcg_out_qemu_ld(s, args, 3);
1642 break;
1643
1644 case INDEX_op_qemu_st8:
1645 tcg_out_qemu_st(s, args, 0);
1646 break;
1647 case INDEX_op_qemu_st16:
1648 tcg_out_qemu_st(s, args, 1);
1649 break;
1650 case INDEX_op_qemu_st32:
1651 tcg_out_qemu_st(s, args, 2);
1652 break;
1653 case INDEX_op_qemu_st64:
1654 tcg_out_qemu_st(s, args, 3);
1655 break;
1656
1657 case INDEX_op_bswap16_i32:
1658 tcg_out_bswap16(s, COND_AL, args[0], args[1]);
1659 break;
1660 case INDEX_op_bswap32_i32:
1661 tcg_out_bswap32(s, COND_AL, args[0], args[1]);
1662 break;
1663
1664 case INDEX_op_ext8s_i32:
1665 tcg_out_ext8s(s, COND_AL, args[0], args[1]);
1666 break;
1667 case INDEX_op_ext16s_i32:
1668 tcg_out_ext16s(s, COND_AL, args[0], args[1]);
1669 break;
1670 case INDEX_op_ext16u_i32:
1671 tcg_out_ext16u(s, COND_AL, args[0], args[1]);
1672 break;
1673
1674 default:
1675 tcg_abort();
1676 }
1677 }
1678
1679 static const TCGTargetOpDef arm_op_defs[] = {
1680 { INDEX_op_exit_tb, { } },
1681 { INDEX_op_goto_tb, { } },
1682 { INDEX_op_call, { "ri" } },
1683 { INDEX_op_jmp, { "ri" } },
1684 { INDEX_op_br, { } },
1685
1686 { INDEX_op_mov_i32, { "r", "r" } },
1687 { INDEX_op_movi_i32, { "r" } },
1688
1689 { INDEX_op_ld8u_i32, { "r", "r" } },
1690 { INDEX_op_ld8s_i32, { "r", "r" } },
1691 { INDEX_op_ld16u_i32, { "r", "r" } },
1692 { INDEX_op_ld16s_i32, { "r", "r" } },
1693 { INDEX_op_ld_i32, { "r", "r" } },
1694 { INDEX_op_st8_i32, { "r", "r" } },
1695 { INDEX_op_st16_i32, { "r", "r" } },
1696 { INDEX_op_st_i32, { "r", "r" } },
1697
1698 /* TODO: "r", "r", "ri" */
1699 { INDEX_op_add_i32, { "r", "r", "rI" } },
1700 { INDEX_op_sub_i32, { "r", "r", "rI" } },
1701 { INDEX_op_mul_i32, { "r", "r", "r" } },
1702 { INDEX_op_mulu2_i32, { "r", "r", "r", "r" } },
1703 { INDEX_op_and_i32, { "r", "r", "rI" } },
1704 { INDEX_op_andc_i32, { "r", "r", "rI" } },
1705 { INDEX_op_or_i32, { "r", "r", "rI" } },
1706 { INDEX_op_xor_i32, { "r", "r", "rI" } },
1707 { INDEX_op_neg_i32, { "r", "r" } },
1708 { INDEX_op_not_i32, { "r", "r" } },
1709
1710 { INDEX_op_shl_i32, { "r", "r", "ri" } },
1711 { INDEX_op_shr_i32, { "r", "r", "ri" } },
1712 { INDEX_op_sar_i32, { "r", "r", "ri" } },
1713 { INDEX_op_rotl_i32, { "r", "r", "ri" } },
1714 { INDEX_op_rotr_i32, { "r", "r", "ri" } },
1715
1716 { INDEX_op_brcond_i32, { "r", "rI" } },
1717 { INDEX_op_setcond_i32, { "r", "r", "rI" } },
1718
1719 /* TODO: "r", "r", "r", "r", "ri", "ri" */
1720 { INDEX_op_add2_i32, { "r", "r", "r", "r", "r", "r" } },
1721 { INDEX_op_sub2_i32, { "r", "r", "r", "r", "r", "r" } },
1722 { INDEX_op_brcond2_i32, { "r", "r", "r", "r" } },
1723 { INDEX_op_setcond2_i32, { "r", "r", "r", "r", "r" } },
1724
1725 #if TARGET_LONG_BITS == 32
1726 { INDEX_op_qemu_ld8u, { "r", "l" } },
1727 { INDEX_op_qemu_ld8s, { "r", "l" } },
1728 { INDEX_op_qemu_ld16u, { "r", "l" } },
1729 { INDEX_op_qemu_ld16s, { "r", "l" } },
1730 { INDEX_op_qemu_ld32, { "r", "l" } },
1731 { INDEX_op_qemu_ld64, { "L", "L", "l" } },
1732
1733 { INDEX_op_qemu_st8, { "s", "s" } },
1734 { INDEX_op_qemu_st16, { "s", "s" } },
1735 { INDEX_op_qemu_st32, { "s", "s" } },
1736 { INDEX_op_qemu_st64, { "S", "S", "s" } },
1737 #else
1738 { INDEX_op_qemu_ld8u, { "r", "l", "l" } },
1739 { INDEX_op_qemu_ld8s, { "r", "l", "l" } },
1740 { INDEX_op_qemu_ld16u, { "r", "l", "l" } },
1741 { INDEX_op_qemu_ld16s, { "r", "l", "l" } },
1742 { INDEX_op_qemu_ld32, { "r", "l", "l" } },
1743 { INDEX_op_qemu_ld64, { "L", "L", "l", "l" } },
1744
1745 { INDEX_op_qemu_st8, { "s", "s", "s" } },
1746 { INDEX_op_qemu_st16, { "s", "s", "s" } },
1747 { INDEX_op_qemu_st32, { "s", "s", "s" } },
1748 { INDEX_op_qemu_st64, { "S", "S", "s", "s" } },
1749 #endif
1750
1751 { INDEX_op_bswap16_i32, { "r", "r" } },
1752 { INDEX_op_bswap32_i32, { "r", "r" } },
1753
1754 { INDEX_op_ext8s_i32, { "r", "r" } },
1755 { INDEX_op_ext16s_i32, { "r", "r" } },
1756 { INDEX_op_ext16u_i32, { "r", "r" } },
1757
1758 { -1 },
1759 };
1760
1761 static void tcg_target_init(TCGContext *s)
1762 {
1763 #if !defined(CONFIG_USER_ONLY)
1764 /* fail safe */
1765 if ((1 << CPU_TLB_ENTRY_BITS) != sizeof(CPUTLBEntry))
1766 tcg_abort();
1767 #endif
1768
1769 tcg_regset_set32(tcg_target_available_regs[TCG_TYPE_I32], 0, 0xffff);
1770 tcg_regset_set32(tcg_target_call_clobber_regs, 0,
1771 (1 << TCG_REG_R0) |
1772 (1 << TCG_REG_R1) |
1773 (1 << TCG_REG_R2) |
1774 (1 << TCG_REG_R3) |
1775 (1 << TCG_REG_R12) |
1776 (1 << TCG_REG_R14));
1777
1778 tcg_regset_clear(s->reserved_regs);
1779 tcg_regset_set_reg(s->reserved_regs, TCG_REG_CALL_STACK);
1780 tcg_regset_set_reg(s->reserved_regs, TCG_REG_R8);
1781 tcg_regset_set_reg(s->reserved_regs, TCG_REG_PC);
1782
1783 tcg_add_target_add_op_defs(arm_op_defs);
1784 }
1785
1786 static inline void tcg_out_ld(TCGContext *s, TCGType type, int arg,
1787 int arg1, tcg_target_long arg2)
1788 {
1789 tcg_out_ld32u(s, COND_AL, arg, arg1, arg2);
1790 }
1791
1792 static inline void tcg_out_st(TCGContext *s, TCGType type, int arg,
1793 int arg1, tcg_target_long arg2)
1794 {
1795 tcg_out_st32(s, COND_AL, arg, arg1, arg2);
1796 }
1797
1798 static void tcg_out_addi(TCGContext *s, int reg, tcg_target_long val)
1799 {
1800 if (val > 0)
1801 if (val < 0x100)
1802 tcg_out_dat_imm(s, COND_AL, ARITH_ADD, reg, reg, val);
1803 else
1804 tcg_abort();
1805 else if (val < 0) {
1806 if (val > -0x100)
1807 tcg_out_dat_imm(s, COND_AL, ARITH_SUB, reg, reg, -val);
1808 else
1809 tcg_abort();
1810 }
1811 }
1812
1813 static inline void tcg_out_mov(TCGContext *s, TCGType type, int ret, int arg)
1814 {
1815 tcg_out_dat_reg(s, COND_AL, ARITH_MOV, ret, 0, arg, SHIFT_IMM_LSL(0));
1816 }
1817
1818 static inline void tcg_out_movi(TCGContext *s, TCGType type,
1819 int ret, tcg_target_long arg)
1820 {
1821 tcg_out_movi32(s, COND_AL, ret, arg);
1822 }
1823
1824 static void tcg_target_qemu_prologue(TCGContext *s)
1825 {
1826 /* There is no need to save r7, it is used to store the address
1827 of the env structure and is not modified by GCC. */
1828
1829 /* stmdb sp!, { r4 - r6, r8 - r11, lr } */
1830 tcg_out32(s, (COND_AL << 28) | 0x092d4f70);
1831
1832 tcg_out_bx(s, COND_AL, TCG_REG_R0);
1833 tb_ret_addr = s->code_ptr;
1834
1835 /* ldmia sp!, { r4 - r6, r8 - r11, pc } */
1836 tcg_out32(s, (COND_AL << 28) | 0x08bd8f70);
1837 }
QEmu