?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tracetool: Add module for the 'h' format
[qemu/opensuse.git] / target-arm / translate.c
blob7a3c7d650ce8e7d2b4a564a5acb0a6840d9b29b9
1 /*
2 * ARM translation
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 * Copyright (c) 2005-2007 CodeSourcery
6 * Copyright (c) 2007 OpenedHand, Ltd.
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
20 */
21 #include <stdarg.h>
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include <inttypes.h>
26
27 #include "cpu.h"
28 #include "disas.h"
29 #include "tcg-op.h"
30 #include "qemu-log.h"
31
32 #include "helper.h"
33 #define GEN_HELPER 1
34 #include "helper.h"
35
36 #define ENABLE_ARCH_4T arm_feature(env, ARM_FEATURE_V4T)
37 #define ENABLE_ARCH_5 arm_feature(env, ARM_FEATURE_V5)
38 /* currently all emulated v5 cores are also v5TE, so don't bother */
39 #define ENABLE_ARCH_5TE arm_feature(env, ARM_FEATURE_V5)
40 #define ENABLE_ARCH_5J 0
41 #define ENABLE_ARCH_6 arm_feature(env, ARM_FEATURE_V6)
42 #define ENABLE_ARCH_6K arm_feature(env, ARM_FEATURE_V6K)
43 #define ENABLE_ARCH_6T2 arm_feature(env, ARM_FEATURE_THUMB2)
44 #define ENABLE_ARCH_7 arm_feature(env, ARM_FEATURE_V7)
45
46 #define ARCH(x) do { if (!ENABLE_ARCH_##x) goto illegal_op; } while(0)
47
48 /* internal defines */
49 typedef struct DisasContext {
50 target_ulong pc;
51 int is_jmp;
52 /* Nonzero if this instruction has been conditionally skipped. */
53 int condjmp;
54 /* The label that will be jumped to when the instruction is skipped. */
55 int condlabel;
56 /* Thumb-2 condtional execution bits. */
57 int condexec_mask;
58 int condexec_cond;
59 struct TranslationBlock *tb;
60 int singlestep_enabled;
61 int thumb;
62 int bswap_code;
63 #if !defined(CONFIG_USER_ONLY)
64 int user;
65 #endif
66 int vfp_enabled;
67 int vec_len;
68 int vec_stride;
69 } DisasContext;
70
71 static uint32_t gen_opc_condexec_bits[OPC_BUF_SIZE];
72
73 #if defined(CONFIG_USER_ONLY)
74 #define IS_USER(s) 1
75 #else
76 #define IS_USER(s) (s->user)
77 #endif
78
79 /* These instructions trap after executing, so defer them until after the
80 conditional executions state has been updated. */
81 #define DISAS_WFI 4
82 #define DISAS_SWI 5
83
84 static TCGv_ptr cpu_env;
85 /* We reuse the same 64-bit temporaries for efficiency. */
86 static TCGv_i64 cpu_V0, cpu_V1, cpu_M0;
87 static TCGv_i32 cpu_R[16];
88 static TCGv_i32 cpu_exclusive_addr;
89 static TCGv_i32 cpu_exclusive_val;
90 static TCGv_i32 cpu_exclusive_high;
91 #ifdef CONFIG_USER_ONLY
92 static TCGv_i32 cpu_exclusive_test;
93 static TCGv_i32 cpu_exclusive_info;
94 #endif
95
96 /* FIXME: These should be removed. */
97 static TCGv cpu_F0s, cpu_F1s;
98 static TCGv_i64 cpu_F0d, cpu_F1d;
99
100 #include "gen-icount.h"
101
102 static const char *regnames[] =
103 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
104 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "pc" };
105
106 /* initialize TCG globals. */
107 void arm_translate_init(void)
108 {
109 int i;
110
111 cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
112
113 for (i = 0; i < 16; i++) {
114 cpu_R[i] = tcg_global_mem_new_i32(TCG_AREG0,
115 offsetof(CPUARMState, regs[i]),
116 regnames[i]);
117 }
118 cpu_exclusive_addr = tcg_global_mem_new_i32(TCG_AREG0,
119 offsetof(CPUARMState, exclusive_addr), "exclusive_addr");
120 cpu_exclusive_val = tcg_global_mem_new_i32(TCG_AREG0,
121 offsetof(CPUARMState, exclusive_val), "exclusive_val");
122 cpu_exclusive_high = tcg_global_mem_new_i32(TCG_AREG0,
123 offsetof(CPUARMState, exclusive_high), "exclusive_high");
124 #ifdef CONFIG_USER_ONLY
125 cpu_exclusive_test = tcg_global_mem_new_i32(TCG_AREG0,
126 offsetof(CPUARMState, exclusive_test), "exclusive_test");
127 cpu_exclusive_info = tcg_global_mem_new_i32(TCG_AREG0,
128 offsetof(CPUARMState, exclusive_info), "exclusive_info");
129 #endif
130
131 #define GEN_HELPER 2
132 #include "helper.h"
133 }
134
135 static inline TCGv load_cpu_offset(int offset)
136 {
137 TCGv tmp = tcg_temp_new_i32();
138 tcg_gen_ld_i32(tmp, cpu_env, offset);
139 return tmp;
140 }
141
142 #define load_cpu_field(name) load_cpu_offset(offsetof(CPUARMState, name))
143
144 static inline void store_cpu_offset(TCGv var, int offset)
145 {
146 tcg_gen_st_i32(var, cpu_env, offset);
147 tcg_temp_free_i32(var);
148 }
149
150 #define store_cpu_field(var, name) \
151 store_cpu_offset(var, offsetof(CPUARMState, name))
152
153 /* Set a variable to the value of a CPU register. */
154 static void load_reg_var(DisasContext *s, TCGv var, int reg)
155 {
156 if (reg == 15) {
157 uint32_t addr;
158 /* normaly, since we updated PC, we need only to add one insn */
159 if (s->thumb)
160 addr = (long)s->pc + 2;
161 else
162 addr = (long)s->pc + 4;
163 tcg_gen_movi_i32(var, addr);
164 } else {
165 tcg_gen_mov_i32(var, cpu_R[reg]);
166 }
167 }
168
169 /* Create a new temporary and set it to the value of a CPU register. */
170 static inline TCGv load_reg(DisasContext *s, int reg)
171 {
172 TCGv tmp = tcg_temp_new_i32();
173 load_reg_var(s, tmp, reg);
174 return tmp;
175 }
176
177 /* Set a CPU register. The source must be a temporary and will be
178 marked as dead. */
179 static void store_reg(DisasContext *s, int reg, TCGv var)
180 {
181 if (reg == 15) {
182 tcg_gen_andi_i32(var, var, ~1);
183 s->is_jmp = DISAS_JUMP;
184 }
185 tcg_gen_mov_i32(cpu_R[reg], var);
186 tcg_temp_free_i32(var);
187 }
188
189 /* Value extensions. */
190 #define gen_uxtb(var) tcg_gen_ext8u_i32(var, var)
191 #define gen_uxth(var) tcg_gen_ext16u_i32(var, var)
192 #define gen_sxtb(var) tcg_gen_ext8s_i32(var, var)
193 #define gen_sxth(var) tcg_gen_ext16s_i32(var, var)
194
195 #define gen_sxtb16(var) gen_helper_sxtb16(var, var)
196 #define gen_uxtb16(var) gen_helper_uxtb16(var, var)
197
198
199 static inline void gen_set_cpsr(TCGv var, uint32_t mask)
200 {
201 TCGv tmp_mask = tcg_const_i32(mask);
202 gen_helper_cpsr_write(var, tmp_mask);
203 tcg_temp_free_i32(tmp_mask);
204 }
205 /* Set NZCV flags from the high 4 bits of var. */
206 #define gen_set_nzcv(var) gen_set_cpsr(var, CPSR_NZCV)
207
208 static void gen_exception(int excp)
209 {
210 TCGv tmp = tcg_temp_new_i32();
211 tcg_gen_movi_i32(tmp, excp);
212 gen_helper_exception(tmp);
213 tcg_temp_free_i32(tmp);
214 }
215
216 static void gen_smul_dual(TCGv a, TCGv b)
217 {
218 TCGv tmp1 = tcg_temp_new_i32();
219 TCGv tmp2 = tcg_temp_new_i32();
220 tcg_gen_ext16s_i32(tmp1, a);
221 tcg_gen_ext16s_i32(tmp2, b);
222 tcg_gen_mul_i32(tmp1, tmp1, tmp2);
223 tcg_temp_free_i32(tmp2);
224 tcg_gen_sari_i32(a, a, 16);
225 tcg_gen_sari_i32(b, b, 16);
226 tcg_gen_mul_i32(b, b, a);
227 tcg_gen_mov_i32(a, tmp1);
228 tcg_temp_free_i32(tmp1);
229 }
230
231 /* Byteswap each halfword. */
232 static void gen_rev16(TCGv var)
233 {
234 TCGv tmp = tcg_temp_new_i32();
235 tcg_gen_shri_i32(tmp, var, 8);
236 tcg_gen_andi_i32(tmp, tmp, 0x00ff00ff);
237 tcg_gen_shli_i32(var, var, 8);
238 tcg_gen_andi_i32(var, var, 0xff00ff00);
239 tcg_gen_or_i32(var, var, tmp);
240 tcg_temp_free_i32(tmp);
241 }
242
243 /* Byteswap low halfword and sign extend. */
244 static void gen_revsh(TCGv var)
245 {
246 tcg_gen_ext16u_i32(var, var);
247 tcg_gen_bswap16_i32(var, var);
248 tcg_gen_ext16s_i32(var, var);
249 }
250
251 /* Unsigned bitfield extract. */
252 static void gen_ubfx(TCGv var, int shift, uint32_t mask)
253 {
254 if (shift)
255 tcg_gen_shri_i32(var, var, shift);
256 tcg_gen_andi_i32(var, var, mask);
257 }
258
259 /* Signed bitfield extract. */
260 static void gen_sbfx(TCGv var, int shift, int width)
261 {
262 uint32_t signbit;
263
264 if (shift)
265 tcg_gen_sari_i32(var, var, shift);
266 if (shift + width < 32) {
267 signbit = 1u << (width - 1);
268 tcg_gen_andi_i32(var, var, (1u << width) - 1);
269 tcg_gen_xori_i32(var, var, signbit);
270 tcg_gen_subi_i32(var, var, signbit);
271 }
272 }
273
274 /* Bitfield insertion. Insert val into base. Clobbers base and val. */
275 static void gen_bfi(TCGv dest, TCGv base, TCGv val, int shift, uint32_t mask)
276 {
277 tcg_gen_andi_i32(val, val, mask);
278 tcg_gen_shli_i32(val, val, shift);
279 tcg_gen_andi_i32(base, base, ~(mask << shift));
280 tcg_gen_or_i32(dest, base, val);
281 }
282
283 /* Return (b << 32) + a. Mark inputs as dead */
284 static TCGv_i64 gen_addq_msw(TCGv_i64 a, TCGv b)
285 {
286 TCGv_i64 tmp64 = tcg_temp_new_i64();
287
288 tcg_gen_extu_i32_i64(tmp64, b);
289 tcg_temp_free_i32(b);
290 tcg_gen_shli_i64(tmp64, tmp64, 32);
291 tcg_gen_add_i64(a, tmp64, a);
292
293 tcg_temp_free_i64(tmp64);
294 return a;
295 }
296
297 /* Return (b << 32) - a. Mark inputs as dead. */
298 static TCGv_i64 gen_subq_msw(TCGv_i64 a, TCGv b)
299 {
300 TCGv_i64 tmp64 = tcg_temp_new_i64();
301
302 tcg_gen_extu_i32_i64(tmp64, b);
303 tcg_temp_free_i32(b);
304 tcg_gen_shli_i64(tmp64, tmp64, 32);
305 tcg_gen_sub_i64(a, tmp64, a);
306
307 tcg_temp_free_i64(tmp64);
308 return a;
309 }
310
311 /* FIXME: Most targets have native widening multiplication.
312 It would be good to use that instead of a full wide multiply. */
313 /* 32x32->64 multiply. Marks inputs as dead. */
314 static TCGv_i64 gen_mulu_i64_i32(TCGv a, TCGv b)
315 {
316 TCGv_i64 tmp1 = tcg_temp_new_i64();
317 TCGv_i64 tmp2 = tcg_temp_new_i64();
318
319 tcg_gen_extu_i32_i64(tmp1, a);
320 tcg_temp_free_i32(a);
321 tcg_gen_extu_i32_i64(tmp2, b);
322 tcg_temp_free_i32(b);
323 tcg_gen_mul_i64(tmp1, tmp1, tmp2);
324 tcg_temp_free_i64(tmp2);
325 return tmp1;
326 }
327
328 static TCGv_i64 gen_muls_i64_i32(TCGv a, TCGv b)
329 {
330 TCGv_i64 tmp1 = tcg_temp_new_i64();
331 TCGv_i64 tmp2 = tcg_temp_new_i64();
332
333 tcg_gen_ext_i32_i64(tmp1, a);
334 tcg_temp_free_i32(a);
335 tcg_gen_ext_i32_i64(tmp2, b);
336 tcg_temp_free_i32(b);
337 tcg_gen_mul_i64(tmp1, tmp1, tmp2);
338 tcg_temp_free_i64(tmp2);
339 return tmp1;
340 }
341
342 /* Swap low and high halfwords. */
343 static void gen_swap_half(TCGv var)
344 {
345 TCGv tmp = tcg_temp_new_i32();
346 tcg_gen_shri_i32(tmp, var, 16);
347 tcg_gen_shli_i32(var, var, 16);
348 tcg_gen_or_i32(var, var, tmp);
349 tcg_temp_free_i32(tmp);
350 }
351
352 /* Dual 16-bit add. Result placed in t0 and t1 is marked as dead.
353 tmp = (t0 ^ t1) & 0x8000;
354 t0 &= ~0x8000;
355 t1 &= ~0x8000;
356 t0 = (t0 + t1) ^ tmp;
357 */
358
359 static void gen_add16(TCGv t0, TCGv t1)
360 {
361 TCGv tmp = tcg_temp_new_i32();
362 tcg_gen_xor_i32(tmp, t0, t1);
363 tcg_gen_andi_i32(tmp, tmp, 0x8000);
364 tcg_gen_andi_i32(t0, t0, ~0x8000);
365 tcg_gen_andi_i32(t1, t1, ~0x8000);
366 tcg_gen_add_i32(t0, t0, t1);
367 tcg_gen_xor_i32(t0, t0, tmp);
368 tcg_temp_free_i32(tmp);
369 tcg_temp_free_i32(t1);
370 }
371
372 #define gen_set_CF(var) tcg_gen_st_i32(var, cpu_env, offsetof(CPUARMState, CF))
373
374 /* Set CF to the top bit of var. */
375 static void gen_set_CF_bit31(TCGv var)
376 {
377 TCGv tmp = tcg_temp_new_i32();
378 tcg_gen_shri_i32(tmp, var, 31);
379 gen_set_CF(tmp);
380 tcg_temp_free_i32(tmp);
381 }
382
383 /* Set N and Z flags from var. */
384 static inline void gen_logic_CC(TCGv var)
385 {
386 tcg_gen_st_i32(var, cpu_env, offsetof(CPUARMState, NF));
387 tcg_gen_st_i32(var, cpu_env, offsetof(CPUARMState, ZF));
388 }
389
390 /* T0 += T1 + CF. */
391 static void gen_adc(TCGv t0, TCGv t1)
392 {
393 TCGv tmp;
394 tcg_gen_add_i32(t0, t0, t1);
395 tmp = load_cpu_field(CF);
396 tcg_gen_add_i32(t0, t0, tmp);
397 tcg_temp_free_i32(tmp);
398 }
399
400 /* dest = T0 + T1 + CF. */
401 static void gen_add_carry(TCGv dest, TCGv t0, TCGv t1)
402 {
403 TCGv tmp;
404 tcg_gen_add_i32(dest, t0, t1);
405 tmp = load_cpu_field(CF);
406 tcg_gen_add_i32(dest, dest, tmp);
407 tcg_temp_free_i32(tmp);
408 }
409
410 /* dest = T0 - T1 + CF - 1. */
411 static void gen_sub_carry(TCGv dest, TCGv t0, TCGv t1)
412 {
413 TCGv tmp;
414 tcg_gen_sub_i32(dest, t0, t1);
415 tmp = load_cpu_field(CF);
416 tcg_gen_add_i32(dest, dest, tmp);
417 tcg_gen_subi_i32(dest, dest, 1);
418 tcg_temp_free_i32(tmp);
419 }
420
421 /* FIXME: Implement this natively. */
422 #define tcg_gen_abs_i32(t0, t1) gen_helper_abs(t0, t1)
423
424 static void shifter_out_im(TCGv var, int shift)
425 {
426 TCGv tmp = tcg_temp_new_i32();
427 if (shift == 0) {
428 tcg_gen_andi_i32(tmp, var, 1);
429 } else {
430 tcg_gen_shri_i32(tmp, var, shift);
431 if (shift != 31)
432 tcg_gen_andi_i32(tmp, tmp, 1);
433 }
434 gen_set_CF(tmp);
435 tcg_temp_free_i32(tmp);
436 }
437
438 /* Shift by immediate. Includes special handling for shift == 0. */
439 static inline void gen_arm_shift_im(TCGv var, int shiftop, int shift, int flags)
440 {
441 switch (shiftop) {
442 case 0: /* LSL */
443 if (shift != 0) {
444 if (flags)
445 shifter_out_im(var, 32 - shift);
446 tcg_gen_shli_i32(var, var, shift);
447 }
448 break;
449 case 1: /* LSR */
450 if (shift == 0) {
451 if (flags) {
452 tcg_gen_shri_i32(var, var, 31);
453 gen_set_CF(var);
454 }
455 tcg_gen_movi_i32(var, 0);
456 } else {
457 if (flags)
458 shifter_out_im(var, shift - 1);
459 tcg_gen_shri_i32(var, var, shift);
460 }
461 break;
462 case 2: /* ASR */
463 if (shift == 0)
464 shift = 32;
465 if (flags)
466 shifter_out_im(var, shift - 1);
467 if (shift == 32)
468 shift = 31;
469 tcg_gen_sari_i32(var, var, shift);
470 break;
471 case 3: /* ROR/RRX */
472 if (shift != 0) {
473 if (flags)
474 shifter_out_im(var, shift - 1);
475 tcg_gen_rotri_i32(var, var, shift); break;
476 } else {
477 TCGv tmp = load_cpu_field(CF);
478 if (flags)
479 shifter_out_im(var, 0);
480 tcg_gen_shri_i32(var, var, 1);
481 tcg_gen_shli_i32(tmp, tmp, 31);
482 tcg_gen_or_i32(var, var, tmp);
483 tcg_temp_free_i32(tmp);
484 }
485 }
486 };
487
488 static inline void gen_arm_shift_reg(TCGv var, int shiftop,
489 TCGv shift, int flags)
490 {
491 if (flags) {
492 switch (shiftop) {
493 case 0: gen_helper_shl_cc(var, var, shift); break;
494 case 1: gen_helper_shr_cc(var, var, shift); break;
495 case 2: gen_helper_sar_cc(var, var, shift); break;
496 case 3: gen_helper_ror_cc(var, var, shift); break;
497 }
498 } else {
499 switch (shiftop) {
500 case 0: gen_helper_shl(var, var, shift); break;
501 case 1: gen_helper_shr(var, var, shift); break;
502 case 2: gen_helper_sar(var, var, shift); break;
503 case 3: tcg_gen_andi_i32(shift, shift, 0x1f);
504 tcg_gen_rotr_i32(var, var, shift); break;
505 }
506 }
507 tcg_temp_free_i32(shift);
508 }
509
510 #define PAS_OP(pfx) \
511 switch (op2) { \
512 case 0: gen_pas_helper(glue(pfx,add16)); break; \
513 case 1: gen_pas_helper(glue(pfx,addsubx)); break; \
514 case 2: gen_pas_helper(glue(pfx,subaddx)); break; \
515 case 3: gen_pas_helper(glue(pfx,sub16)); break; \
516 case 4: gen_pas_helper(glue(pfx,add8)); break; \
517 case 7: gen_pas_helper(glue(pfx,sub8)); break; \
518 }
519 static void gen_arm_parallel_addsub(int op1, int op2, TCGv a, TCGv b)
520 {
521 TCGv_ptr tmp;
522
523 switch (op1) {
524 #define gen_pas_helper(name) glue(gen_helper_,name)(a, a, b, tmp)
525 case 1:
526 tmp = tcg_temp_new_ptr();
527 tcg_gen_addi_ptr(tmp, cpu_env, offsetof(CPUARMState, GE));
528 PAS_OP(s)
529 tcg_temp_free_ptr(tmp);
530 break;
531 case 5:
532 tmp = tcg_temp_new_ptr();
533 tcg_gen_addi_ptr(tmp, cpu_env, offsetof(CPUARMState, GE));
534 PAS_OP(u)
535 tcg_temp_free_ptr(tmp);
536 break;
537 #undef gen_pas_helper
538 #define gen_pas_helper(name) glue(gen_helper_,name)(a, a, b)
539 case 2:
540 PAS_OP(q);
541 break;
542 case 3:
543 PAS_OP(sh);
544 break;
545 case 6:
546 PAS_OP(uq);
547 break;
548 case 7:
549 PAS_OP(uh);
550 break;
551 #undef gen_pas_helper
552 }
553 }
554 #undef PAS_OP
555
556 /* For unknown reasons Arm and Thumb-2 use arbitrarily different encodings. */
557 #define PAS_OP(pfx) \
558 switch (op1) { \
559 case 0: gen_pas_helper(glue(pfx,add8)); break; \
560 case 1: gen_pas_helper(glue(pfx,add16)); break; \
561 case 2: gen_pas_helper(glue(pfx,addsubx)); break; \
562 case 4: gen_pas_helper(glue(pfx,sub8)); break; \
563 case 5: gen_pas_helper(glue(pfx,sub16)); break; \
564 case 6: gen_pas_helper(glue(pfx,subaddx)); break; \
565 }
566 static void gen_thumb2_parallel_addsub(int op1, int op2, TCGv a, TCGv b)
567 {
568 TCGv_ptr tmp;
569
570 switch (op2) {
571 #define gen_pas_helper(name) glue(gen_helper_,name)(a, a, b, tmp)
572 case 0:
573 tmp = tcg_temp_new_ptr();
574 tcg_gen_addi_ptr(tmp, cpu_env, offsetof(CPUARMState, GE));
575 PAS_OP(s)
576 tcg_temp_free_ptr(tmp);
577 break;
578 case 4:
579 tmp = tcg_temp_new_ptr();
580 tcg_gen_addi_ptr(tmp, cpu_env, offsetof(CPUARMState, GE));
581 PAS_OP(u)
582 tcg_temp_free_ptr(tmp);
583 break;
584 #undef gen_pas_helper
585 #define gen_pas_helper(name) glue(gen_helper_,name)(a, a, b)
586 case 1:
587 PAS_OP(q);
588 break;
589 case 2:
590 PAS_OP(sh);
591 break;
592 case 5:
593 PAS_OP(uq);
594 break;
595 case 6:
596 PAS_OP(uh);
597 break;
598 #undef gen_pas_helper
599 }
600 }
601 #undef PAS_OP
602
603 static void gen_test_cc(int cc, int label)
604 {
605 TCGv tmp;
606 TCGv tmp2;
607 int inv;
608
609 switch (cc) {
610 case 0: /* eq: Z */
611 tmp = load_cpu_field(ZF);
612 tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, label);
613 break;
614 case 1: /* ne: !Z */
615 tmp = load_cpu_field(ZF);
616 tcg_gen_brcondi_i32(TCG_COND_NE, tmp, 0, label);
617 break;
618 case 2: /* cs: C */
619 tmp = load_cpu_field(CF);
620 tcg_gen_brcondi_i32(TCG_COND_NE, tmp, 0, label);
621 break;
622 case 3: /* cc: !C */
623 tmp = load_cpu_field(CF);
624 tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, label);
625 break;
626 case 4: /* mi: N */
627 tmp = load_cpu_field(NF);
628 tcg_gen_brcondi_i32(TCG_COND_LT, tmp, 0, label);
629 break;
630 case 5: /* pl: !N */
631 tmp = load_cpu_field(NF);
632 tcg_gen_brcondi_i32(TCG_COND_GE, tmp, 0, label);
633 break;
634 case 6: /* vs: V */
635 tmp = load_cpu_field(VF);
636 tcg_gen_brcondi_i32(TCG_COND_LT, tmp, 0, label);
637 break;
638 case 7: /* vc: !V */
639 tmp = load_cpu_field(VF);
640 tcg_gen_brcondi_i32(TCG_COND_GE, tmp, 0, label);
641 break;
642 case 8: /* hi: C && !Z */
643 inv = gen_new_label();
644 tmp = load_cpu_field(CF);
645 tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, inv);
646 tcg_temp_free_i32(tmp);
647 tmp = load_cpu_field(ZF);
648 tcg_gen_brcondi_i32(TCG_COND_NE, tmp, 0, label);
649 gen_set_label(inv);
650 break;
651 case 9: /* ls: !C || Z */
652 tmp = load_cpu_field(CF);
653 tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, label);
654 tcg_temp_free_i32(tmp);
655 tmp = load_cpu_field(ZF);
656 tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, label);
657 break;
658 case 10: /* ge: N == V -> N ^ V == 0 */
659 tmp = load_cpu_field(VF);
660 tmp2 = load_cpu_field(NF);
661 tcg_gen_xor_i32(tmp, tmp, tmp2);
662 tcg_temp_free_i32(tmp2);
663 tcg_gen_brcondi_i32(TCG_COND_GE, tmp, 0, label);
664 break;
665 case 11: /* lt: N != V -> N ^ V != 0 */
666 tmp = load_cpu_field(VF);
667 tmp2 = load_cpu_field(NF);
668 tcg_gen_xor_i32(tmp, tmp, tmp2);
669 tcg_temp_free_i32(tmp2);
670 tcg_gen_brcondi_i32(TCG_COND_LT, tmp, 0, label);
671 break;
672 case 12: /* gt: !Z && N == V */
673 inv = gen_new_label();
674 tmp = load_cpu_field(ZF);
675 tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, inv);
676 tcg_temp_free_i32(tmp);
677 tmp = load_cpu_field(VF);
678 tmp2 = load_cpu_field(NF);
679 tcg_gen_xor_i32(tmp, tmp, tmp2);
680 tcg_temp_free_i32(tmp2);
681 tcg_gen_brcondi_i32(TCG_COND_GE, tmp, 0, label);
682 gen_set_label(inv);
683 break;
684 case 13: /* le: Z || N != V */
685 tmp = load_cpu_field(ZF);
686 tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, label);
687 tcg_temp_free_i32(tmp);
688 tmp = load_cpu_field(VF);
689 tmp2 = load_cpu_field(NF);
690 tcg_gen_xor_i32(tmp, tmp, tmp2);
691 tcg_temp_free_i32(tmp2);
692 tcg_gen_brcondi_i32(TCG_COND_LT, tmp, 0, label);
693 break;
694 default:
695 fprintf(stderr, "Bad condition code 0x%x\n", cc);
696 abort();
697 }
698 tcg_temp_free_i32(tmp);
699 }
700
701 static const uint8_t table_logic_cc[16] = {
702 1, /* and */
703 1, /* xor */
704 0, /* sub */
705 0, /* rsb */
706 0, /* add */
707 0, /* adc */
708 0, /* sbc */
709 0, /* rsc */
710 1, /* andl */
711 1, /* xorl */
712 0, /* cmp */
713 0, /* cmn */
714 1, /* orr */
715 1, /* mov */
716 1, /* bic */
717 1, /* mvn */
718 };
719
720 /* Set PC and Thumb state from an immediate address. */
721 static inline void gen_bx_im(DisasContext *s, uint32_t addr)
722 {
723 TCGv tmp;
724
725 s->is_jmp = DISAS_UPDATE;
726 if (s->thumb != (addr & 1)) {
727 tmp = tcg_temp_new_i32();
728 tcg_gen_movi_i32(tmp, addr & 1);
729 tcg_gen_st_i32(tmp, cpu_env, offsetof(CPUARMState, thumb));
730 tcg_temp_free_i32(tmp);
731 }
732 tcg_gen_movi_i32(cpu_R[15], addr & ~1);
733 }
734
735 /* Set PC and Thumb state from var. var is marked as dead. */
736 static inline void gen_bx(DisasContext *s, TCGv var)
737 {
738 s->is_jmp = DISAS_UPDATE;
739 tcg_gen_andi_i32(cpu_R[15], var, ~1);
740 tcg_gen_andi_i32(var, var, 1);
741 store_cpu_field(var, thumb);
742 }
743
744 /* Variant of store_reg which uses branch&exchange logic when storing
745 to r15 in ARM architecture v7 and above. The source must be a temporary
746 and will be marked as dead. */
747 static inline void store_reg_bx(CPUARMState *env, DisasContext *s,
748 int reg, TCGv var)
749 {
750 if (reg == 15 && ENABLE_ARCH_7) {
751 gen_bx(s, var);
752 } else {
753 store_reg(s, reg, var);
754 }
755 }
756
757 /* Variant of store_reg which uses branch&exchange logic when storing
758 * to r15 in ARM architecture v5T and above. This is used for storing
759 * the results of a LDR/LDM/POP into r15, and corresponds to the cases
760 * in the ARM ARM which use the LoadWritePC() pseudocode function. */
761 static inline void store_reg_from_load(CPUARMState *env, DisasContext *s,
762 int reg, TCGv var)
763 {
764 if (reg == 15 && ENABLE_ARCH_5) {
765 gen_bx(s, var);
766 } else {
767 store_reg(s, reg, var);
768 }
769 }
770
771 static inline TCGv gen_ld8s(TCGv addr, int index)
772 {
773 TCGv tmp = tcg_temp_new_i32();
774 tcg_gen_qemu_ld8s(tmp, addr, index);
775 return tmp;
776 }
777 static inline TCGv gen_ld8u(TCGv addr, int index)
778 {
779 TCGv tmp = tcg_temp_new_i32();
780 tcg_gen_qemu_ld8u(tmp, addr, index);
781 return tmp;
782 }
783 static inline TCGv gen_ld16s(TCGv addr, int index)
784 {
785 TCGv tmp = tcg_temp_new_i32();
786 tcg_gen_qemu_ld16s(tmp, addr, index);
787 return tmp;
788 }
789 static inline TCGv gen_ld16u(TCGv addr, int index)
790 {
791 TCGv tmp = tcg_temp_new_i32();
792 tcg_gen_qemu_ld16u(tmp, addr, index);
793 return tmp;
794 }
795 static inline TCGv gen_ld32(TCGv addr, int index)
796 {
797 TCGv tmp = tcg_temp_new_i32();
798 tcg_gen_qemu_ld32u(tmp, addr, index);
799 return tmp;
800 }
801 static inline TCGv_i64 gen_ld64(TCGv addr, int index)
802 {
803 TCGv_i64 tmp = tcg_temp_new_i64();
804 tcg_gen_qemu_ld64(tmp, addr, index);
805 return tmp;
806 }
807 static inline void gen_st8(TCGv val, TCGv addr, int index)
808 {
809 tcg_gen_qemu_st8(val, addr, index);
810 tcg_temp_free_i32(val);
811 }
812 static inline void gen_st16(TCGv val, TCGv addr, int index)
813 {
814 tcg_gen_qemu_st16(val, addr, index);
815 tcg_temp_free_i32(val);
816 }
817 static inline void gen_st32(TCGv val, TCGv addr, int index)
818 {
819 tcg_gen_qemu_st32(val, addr, index);
820 tcg_temp_free_i32(val);
821 }
822 static inline void gen_st64(TCGv_i64 val, TCGv addr, int index)
823 {
824 tcg_gen_qemu_st64(val, addr, index);
825 tcg_temp_free_i64(val);
826 }
827
828 static inline void gen_set_pc_im(uint32_t val)
829 {
830 tcg_gen_movi_i32(cpu_R[15], val);
831 }
832
833 /* Force a TB lookup after an instruction that changes the CPU state. */
834 static inline void gen_lookup_tb(DisasContext *s)
835 {
836 tcg_gen_movi_i32(cpu_R[15], s->pc & ~1);
837 s->is_jmp = DISAS_UPDATE;
838 }
839
840 static inline void gen_add_data_offset(DisasContext *s, unsigned int insn,
841 TCGv var)
842 {
843 int val, rm, shift, shiftop;
844 TCGv offset;
845
846 if (!(insn & (1 << 25))) {
847 /* immediate */
848 val = insn & 0xfff;
849 if (!(insn & (1 << 23)))
850 val = -val;
851 if (val != 0)
852 tcg_gen_addi_i32(var, var, val);
853 } else {
854 /* shift/register */
855 rm = (insn) & 0xf;
856 shift = (insn >> 7) & 0x1f;
857 shiftop = (insn >> 5) & 3;
858 offset = load_reg(s, rm);
859 gen_arm_shift_im(offset, shiftop, shift, 0);
860 if (!(insn & (1 << 23)))
861 tcg_gen_sub_i32(var, var, offset);
862 else
863 tcg_gen_add_i32(var, var, offset);
864 tcg_temp_free_i32(offset);
865 }
866 }
867
868 static inline void gen_add_datah_offset(DisasContext *s, unsigned int insn,
869 int extra, TCGv var)
870 {
871 int val, rm;
872 TCGv offset;
873
874 if (insn & (1 << 22)) {
875 /* immediate */
876 val = (insn & 0xf) | ((insn >> 4) & 0xf0);
877 if (!(insn & (1 << 23)))
878 val = -val;
879 val += extra;
880 if (val != 0)
881 tcg_gen_addi_i32(var, var, val);
882 } else {
883 /* register */
884 if (extra)
885 tcg_gen_addi_i32(var, var, extra);
886 rm = (insn) & 0xf;
887 offset = load_reg(s, rm);
888 if (!(insn & (1 << 23)))
889 tcg_gen_sub_i32(var, var, offset);
890 else
891 tcg_gen_add_i32(var, var, offset);
892 tcg_temp_free_i32(offset);
893 }
894 }
895
896 static TCGv_ptr get_fpstatus_ptr(int neon)
897 {
898 TCGv_ptr statusptr = tcg_temp_new_ptr();
899 int offset;
900 if (neon) {
901 offset = offsetof(CPUARMState, vfp.standard_fp_status);
902 } else {
903 offset = offsetof(CPUARMState, vfp.fp_status);
904 }
905 tcg_gen_addi_ptr(statusptr, cpu_env, offset);
906 return statusptr;
907 }
908
909 #define VFP_OP2(name) \
910 static inline void gen_vfp_##name(int dp) \
911 { \
912 TCGv_ptr fpst = get_fpstatus_ptr(0); \
913 if (dp) { \
914 gen_helper_vfp_##name##d(cpu_F0d, cpu_F0d, cpu_F1d, fpst); \
915 } else { \
916 gen_helper_vfp_##name##s(cpu_F0s, cpu_F0s, cpu_F1s, fpst); \
917 } \
918 tcg_temp_free_ptr(fpst); \
919 }
920
921 VFP_OP2(add)
922 VFP_OP2(sub)
923 VFP_OP2(mul)
924 VFP_OP2(div)
925
926 #undef VFP_OP2
927
928 static inline void gen_vfp_F1_mul(int dp)
929 {
930 /* Like gen_vfp_mul() but put result in F1 */
931 TCGv_ptr fpst = get_fpstatus_ptr(0);
932 if (dp) {
933 gen_helper_vfp_muld(cpu_F1d, cpu_F0d, cpu_F1d, fpst);
934 } else {
935 gen_helper_vfp_muls(cpu_F1s, cpu_F0s, cpu_F1s, fpst);
936 }
937 tcg_temp_free_ptr(fpst);
938 }
939
940 static inline void gen_vfp_F1_neg(int dp)
941 {
942 /* Like gen_vfp_neg() but put result in F1 */
943 if (dp) {
944 gen_helper_vfp_negd(cpu_F1d, cpu_F0d);
945 } else {
946 gen_helper_vfp_negs(cpu_F1s, cpu_F0s);
947 }
948 }
949
950 static inline void gen_vfp_abs(int dp)
951 {
952 if (dp)
953 gen_helper_vfp_absd(cpu_F0d, cpu_F0d);
954 else
955 gen_helper_vfp_abss(cpu_F0s, cpu_F0s);
956 }
957
958 static inline void gen_vfp_neg(int dp)
959 {
960 if (dp)
961 gen_helper_vfp_negd(cpu_F0d, cpu_F0d);
962 else
963 gen_helper_vfp_negs(cpu_F0s, cpu_F0s);
964 }
965
966 static inline void gen_vfp_sqrt(int dp)
967 {
968 if (dp)
969 gen_helper_vfp_sqrtd(cpu_F0d, cpu_F0d, cpu_env);
970 else
971 gen_helper_vfp_sqrts(cpu_F0s, cpu_F0s, cpu_env);
972 }
973
974 static inline void gen_vfp_cmp(int dp)
975 {
976 if (dp)
977 gen_helper_vfp_cmpd(cpu_F0d, cpu_F1d, cpu_env);
978 else
979 gen_helper_vfp_cmps(cpu_F0s, cpu_F1s, cpu_env);
980 }
981
982 static inline void gen_vfp_cmpe(int dp)
983 {
984 if (dp)
985 gen_helper_vfp_cmped(cpu_F0d, cpu_F1d, cpu_env);
986 else
987 gen_helper_vfp_cmpes(cpu_F0s, cpu_F1s, cpu_env);
988 }
989
990 static inline void gen_vfp_F1_ld0(int dp)
991 {
992 if (dp)
993 tcg_gen_movi_i64(cpu_F1d, 0);
994 else
995 tcg_gen_movi_i32(cpu_F1s, 0);
996 }
997
998 #define VFP_GEN_ITOF(name) \
999 static inline void gen_vfp_##name(int dp, int neon) \
1000 { \
1001 TCGv_ptr statusptr = get_fpstatus_ptr(neon); \
1002 if (dp) { \
1003 gen_helper_vfp_##name##d(cpu_F0d, cpu_F0s, statusptr); \
1004 } else { \
1005 gen_helper_vfp_##name##s(cpu_F0s, cpu_F0s, statusptr); \
1006 } \
1007 tcg_temp_free_ptr(statusptr); \
1008 }
1009
1010 VFP_GEN_ITOF(uito)
1011 VFP_GEN_ITOF(sito)
1012 #undef VFP_GEN_ITOF
1013
1014 #define VFP_GEN_FTOI(name) \
1015 static inline void gen_vfp_##name(int dp, int neon) \
1016 { \
1017 TCGv_ptr statusptr = get_fpstatus_ptr(neon); \
1018 if (dp) { \
1019 gen_helper_vfp_##name##d(cpu_F0s, cpu_F0d, statusptr); \
1020 } else { \
1021 gen_helper_vfp_##name##s(cpu_F0s, cpu_F0s, statusptr); \
1022 } \
1023 tcg_temp_free_ptr(statusptr); \
1024 }
1025
1026 VFP_GEN_FTOI(toui)
1027 VFP_GEN_FTOI(touiz)
1028 VFP_GEN_FTOI(tosi)
1029 VFP_GEN_FTOI(tosiz)
1030 #undef VFP_GEN_FTOI
1031
1032 #define VFP_GEN_FIX(name) \
1033 static inline void gen_vfp_##name(int dp, int shift, int neon) \
1034 { \
1035 TCGv tmp_shift = tcg_const_i32(shift); \
1036 TCGv_ptr statusptr = get_fpstatus_ptr(neon); \
1037 if (dp) { \
1038 gen_helper_vfp_##name##d(cpu_F0d, cpu_F0d, tmp_shift, statusptr); \
1039 } else { \
1040 gen_helper_vfp_##name##s(cpu_F0s, cpu_F0s, tmp_shift, statusptr); \
1041 } \
1042 tcg_temp_free_i32(tmp_shift); \
1043 tcg_temp_free_ptr(statusptr); \
1044 }
1045 VFP_GEN_FIX(tosh)
1046 VFP_GEN_FIX(tosl)
1047 VFP_GEN_FIX(touh)
1048 VFP_GEN_FIX(toul)
1049 VFP_GEN_FIX(shto)
1050 VFP_GEN_FIX(slto)
1051 VFP_GEN_FIX(uhto)
1052 VFP_GEN_FIX(ulto)
1053 #undef VFP_GEN_FIX
1054
1055 static inline void gen_vfp_ld(DisasContext *s, int dp, TCGv addr)
1056 {
1057 if (dp)
1058 tcg_gen_qemu_ld64(cpu_F0d, addr, IS_USER(s));
1059 else
1060 tcg_gen_qemu_ld32u(cpu_F0s, addr, IS_USER(s));
1061 }
1062
1063 static inline void gen_vfp_st(DisasContext *s, int dp, TCGv addr)
1064 {
1065 if (dp)
1066 tcg_gen_qemu_st64(cpu_F0d, addr, IS_USER(s));
1067 else
1068 tcg_gen_qemu_st32(cpu_F0s, addr, IS_USER(s));
1069 }
1070
1071 static inline long
1072 vfp_reg_offset (int dp, int reg)
1073 {
1074 if (dp)
1075 return offsetof(CPUARMState, vfp.regs[reg]);
1076 else if (reg & 1) {
1077 return offsetof(CPUARMState, vfp.regs[reg >> 1])
1078 + offsetof(CPU_DoubleU, l.upper);
1079 } else {
1080 return offsetof(CPUARMState, vfp.regs[reg >> 1])
1081 + offsetof(CPU_DoubleU, l.lower);
1082 }
1083 }
1084
1085 /* Return the offset of a 32-bit piece of a NEON register.
1086 zero is the least significant end of the register. */
1087 static inline long
1088 neon_reg_offset (int reg, int n)
1089 {
1090 int sreg;
1091 sreg = reg * 2 + n;
1092 return vfp_reg_offset(0, sreg);
1093 }
1094
1095 static TCGv neon_load_reg(int reg, int pass)
1096 {
1097 TCGv tmp = tcg_temp_new_i32();
1098 tcg_gen_ld_i32(tmp, cpu_env, neon_reg_offset(reg, pass));
1099 return tmp;
1100 }
1101
1102 static void neon_store_reg(int reg, int pass, TCGv var)
1103 {
1104 tcg_gen_st_i32(var, cpu_env, neon_reg_offset(reg, pass));
1105 tcg_temp_free_i32(var);
1106 }
1107
1108 static inline void neon_load_reg64(TCGv_i64 var, int reg)
1109 {
1110 tcg_gen_ld_i64(var, cpu_env, vfp_reg_offset(1, reg));
1111 }
1112
1113 static inline void neon_store_reg64(TCGv_i64 var, int reg)
1114 {
1115 tcg_gen_st_i64(var, cpu_env, vfp_reg_offset(1, reg));
1116 }
1117
1118 #define tcg_gen_ld_f32 tcg_gen_ld_i32
1119 #define tcg_gen_ld_f64 tcg_gen_ld_i64
1120 #define tcg_gen_st_f32 tcg_gen_st_i32
1121 #define tcg_gen_st_f64 tcg_gen_st_i64
1122
1123 static inline void gen_mov_F0_vreg(int dp, int reg)
1124 {
1125 if (dp)
1126 tcg_gen_ld_f64(cpu_F0d, cpu_env, vfp_reg_offset(dp, reg));
1127 else
1128 tcg_gen_ld_f32(cpu_F0s, cpu_env, vfp_reg_offset(dp, reg));
1129 }
1130
1131 static inline void gen_mov_F1_vreg(int dp, int reg)
1132 {
1133 if (dp)
1134 tcg_gen_ld_f64(cpu_F1d, cpu_env, vfp_reg_offset(dp, reg));
1135 else
1136 tcg_gen_ld_f32(cpu_F1s, cpu_env, vfp_reg_offset(dp, reg));
1137 }
1138
1139 static inline void gen_mov_vreg_F0(int dp, int reg)
1140 {
1141 if (dp)
1142 tcg_gen_st_f64(cpu_F0d, cpu_env, vfp_reg_offset(dp, reg));
1143 else
1144 tcg_gen_st_f32(cpu_F0s, cpu_env, vfp_reg_offset(dp, reg));
1145 }
1146
1147 #define ARM_CP_RW_BIT (1 << 20)
1148
1149 static inline void iwmmxt_load_reg(TCGv_i64 var, int reg)
1150 {
1151 tcg_gen_ld_i64(var, cpu_env, offsetof(CPUARMState, iwmmxt.regs[reg]));
1152 }
1153
1154 static inline void iwmmxt_store_reg(TCGv_i64 var, int reg)
1155 {
1156 tcg_gen_st_i64(var, cpu_env, offsetof(CPUARMState, iwmmxt.regs[reg]));
1157 }
1158
1159 static inline TCGv iwmmxt_load_creg(int reg)
1160 {
1161 TCGv var = tcg_temp_new_i32();
1162 tcg_gen_ld_i32(var, cpu_env, offsetof(CPUARMState, iwmmxt.cregs[reg]));
1163 return var;
1164 }
1165
1166 static inline void iwmmxt_store_creg(int reg, TCGv var)
1167 {
1168 tcg_gen_st_i32(var, cpu_env, offsetof(CPUARMState, iwmmxt.cregs[reg]));
1169 tcg_temp_free_i32(var);
1170 }
1171
1172 static inline void gen_op_iwmmxt_movq_wRn_M0(int rn)
1173 {
1174 iwmmxt_store_reg(cpu_M0, rn);
1175 }
1176
1177 static inline void gen_op_iwmmxt_movq_M0_wRn(int rn)
1178 {
1179 iwmmxt_load_reg(cpu_M0, rn);
1180 }
1181
1182 static inline void gen_op_iwmmxt_orq_M0_wRn(int rn)
1183 {
1184 iwmmxt_load_reg(cpu_V1, rn);
1185 tcg_gen_or_i64(cpu_M0, cpu_M0, cpu_V1);
1186 }
1187
1188 static inline void gen_op_iwmmxt_andq_M0_wRn(int rn)
1189 {
1190 iwmmxt_load_reg(cpu_V1, rn);
1191 tcg_gen_and_i64(cpu_M0, cpu_M0, cpu_V1);
1192 }
1193
1194 static inline void gen_op_iwmmxt_xorq_M0_wRn(int rn)
1195 {
1196 iwmmxt_load_reg(cpu_V1, rn);
1197 tcg_gen_xor_i64(cpu_M0, cpu_M0, cpu_V1);
1198 }
1199
1200 #define IWMMXT_OP(name) \
1201 static inline void gen_op_iwmmxt_##name##_M0_wRn(int rn) \
1202 { \
1203 iwmmxt_load_reg(cpu_V1, rn); \
1204 gen_helper_iwmmxt_##name(cpu_M0, cpu_M0, cpu_V1); \
1205 }
1206
1207 #define IWMMXT_OP_ENV(name) \
1208 static inline void gen_op_iwmmxt_##name##_M0_wRn(int rn) \
1209 { \
1210 iwmmxt_load_reg(cpu_V1, rn); \
1211 gen_helper_iwmmxt_##name(cpu_M0, cpu_env, cpu_M0, cpu_V1); \
1212 }
1213
1214 #define IWMMXT_OP_ENV_SIZE(name) \
1215 IWMMXT_OP_ENV(name##b) \
1216 IWMMXT_OP_ENV(name##w) \
1217 IWMMXT_OP_ENV(name##l)
1218
1219 #define IWMMXT_OP_ENV1(name) \
1220 static inline void gen_op_iwmmxt_##name##_M0(void) \
1221 { \
1222 gen_helper_iwmmxt_##name(cpu_M0, cpu_env, cpu_M0); \
1223 }
1224
1225 IWMMXT_OP(maddsq)
1226 IWMMXT_OP(madduq)
1227 IWMMXT_OP(sadb)
1228 IWMMXT_OP(sadw)
1229 IWMMXT_OP(mulslw)
1230 IWMMXT_OP(mulshw)
1231 IWMMXT_OP(mululw)
1232 IWMMXT_OP(muluhw)
1233 IWMMXT_OP(macsw)
1234 IWMMXT_OP(macuw)
1235
1236 IWMMXT_OP_ENV_SIZE(unpackl)
1237 IWMMXT_OP_ENV_SIZE(unpackh)
1238
1239 IWMMXT_OP_ENV1(unpacklub)
1240 IWMMXT_OP_ENV1(unpackluw)
1241 IWMMXT_OP_ENV1(unpacklul)
1242 IWMMXT_OP_ENV1(unpackhub)
1243 IWMMXT_OP_ENV1(unpackhuw)
1244 IWMMXT_OP_ENV1(unpackhul)
1245 IWMMXT_OP_ENV1(unpacklsb)
1246 IWMMXT_OP_ENV1(unpacklsw)
1247 IWMMXT_OP_ENV1(unpacklsl)
1248 IWMMXT_OP_ENV1(unpackhsb)
1249 IWMMXT_OP_ENV1(unpackhsw)
1250 IWMMXT_OP_ENV1(unpackhsl)
1251
1252 IWMMXT_OP_ENV_SIZE(cmpeq)
1253 IWMMXT_OP_ENV_SIZE(cmpgtu)
1254 IWMMXT_OP_ENV_SIZE(cmpgts)
1255
1256 IWMMXT_OP_ENV_SIZE(mins)
1257 IWMMXT_OP_ENV_SIZE(minu)
1258 IWMMXT_OP_ENV_SIZE(maxs)
1259 IWMMXT_OP_ENV_SIZE(maxu)
1260
1261 IWMMXT_OP_ENV_SIZE(subn)
1262 IWMMXT_OP_ENV_SIZE(addn)
1263 IWMMXT_OP_ENV_SIZE(subu)
1264 IWMMXT_OP_ENV_SIZE(addu)
1265 IWMMXT_OP_ENV_SIZE(subs)
1266 IWMMXT_OP_ENV_SIZE(adds)
1267
1268 IWMMXT_OP_ENV(avgb0)
1269 IWMMXT_OP_ENV(avgb1)
1270 IWMMXT_OP_ENV(avgw0)
1271 IWMMXT_OP_ENV(avgw1)
1272
1273 IWMMXT_OP(msadb)
1274
1275 IWMMXT_OP_ENV(packuw)
1276 IWMMXT_OP_ENV(packul)
1277 IWMMXT_OP_ENV(packuq)
1278 IWMMXT_OP_ENV(packsw)
1279 IWMMXT_OP_ENV(packsl)
1280 IWMMXT_OP_ENV(packsq)
1281
1282 static void gen_op_iwmmxt_set_mup(void)
1283 {
1284 TCGv tmp;
1285 tmp = load_cpu_field(iwmmxt.cregs[ARM_IWMMXT_wCon]);
1286 tcg_gen_ori_i32(tmp, tmp, 2);
1287 store_cpu_field(tmp, iwmmxt.cregs[ARM_IWMMXT_wCon]);
1288 }
1289
1290 static void gen_op_iwmmxt_set_cup(void)
1291 {
1292 TCGv tmp;
1293 tmp = load_cpu_field(iwmmxt.cregs[ARM_IWMMXT_wCon]);
1294 tcg_gen_ori_i32(tmp, tmp, 1);
1295 store_cpu_field(tmp, iwmmxt.cregs[ARM_IWMMXT_wCon]);
1296 }
1297
1298 static void gen_op_iwmmxt_setpsr_nz(void)
1299 {
1300 TCGv tmp = tcg_temp_new_i32();
1301 gen_helper_iwmmxt_setpsr_nz(tmp, cpu_M0);
1302 store_cpu_field(tmp, iwmmxt.cregs[ARM_IWMMXT_wCASF]);
1303 }
1304
1305 static inline void gen_op_iwmmxt_addl_M0_wRn(int rn)
1306 {
1307 iwmmxt_load_reg(cpu_V1, rn);
1308 tcg_gen_ext32u_i64(cpu_V1, cpu_V1);
1309 tcg_gen_add_i64(cpu_M0, cpu_M0, cpu_V1);
1310 }
1311
1312 static inline int gen_iwmmxt_address(DisasContext *s, uint32_t insn, TCGv dest)
1313 {
1314 int rd;
1315 uint32_t offset;
1316 TCGv tmp;
1317
1318 rd = (insn >> 16) & 0xf;
1319 tmp = load_reg(s, rd);
1320
1321 offset = (insn & 0xff) << ((insn >> 7) & 2);
1322 if (insn & (1 << 24)) {
1323 /* Pre indexed */
1324 if (insn & (1 << 23))
1325 tcg_gen_addi_i32(tmp, tmp, offset);
1326 else
1327 tcg_gen_addi_i32(tmp, tmp, -offset);
1328 tcg_gen_mov_i32(dest, tmp);
1329 if (insn & (1 << 21))
1330 store_reg(s, rd, tmp);
1331 else
1332 tcg_temp_free_i32(tmp);
1333 } else if (insn & (1 << 21)) {
1334 /* Post indexed */
1335 tcg_gen_mov_i32(dest, tmp);
1336 if (insn & (1 << 23))
1337 tcg_gen_addi_i32(tmp, tmp, offset);
1338 else
1339 tcg_gen_addi_i32(tmp, tmp, -offset);
1340 store_reg(s, rd, tmp);
1341 } else if (!(insn & (1 << 23)))
1342 return 1;
1343 return 0;
1344 }
1345
1346 static inline int gen_iwmmxt_shift(uint32_t insn, uint32_t mask, TCGv dest)
1347 {
1348 int rd = (insn >> 0) & 0xf;
1349 TCGv tmp;
1350
1351 if (insn & (1 << 8)) {
1352 if (rd < ARM_IWMMXT_wCGR0 || rd > ARM_IWMMXT_wCGR3) {
1353 return 1;
1354 } else {
1355 tmp = iwmmxt_load_creg(rd);
1356 }
1357 } else {
1358 tmp = tcg_temp_new_i32();
1359 iwmmxt_load_reg(cpu_V0, rd);
1360 tcg_gen_trunc_i64_i32(tmp, cpu_V0);
1361 }
1362 tcg_gen_andi_i32(tmp, tmp, mask);
1363 tcg_gen_mov_i32(dest, tmp);
1364 tcg_temp_free_i32(tmp);
1365 return 0;
1366 }
1367
1368 /* Disassemble an iwMMXt instruction. Returns nonzero if an error occurred
1369 (ie. an undefined instruction). */
1370 static int disas_iwmmxt_insn(CPUARMState *env, DisasContext *s, uint32_t insn)
1371 {
1372 int rd, wrd;
1373 int rdhi, rdlo, rd0, rd1, i;
1374 TCGv addr;
1375 TCGv tmp, tmp2, tmp3;
1376
1377 if ((insn & 0x0e000e00) == 0x0c000000) {
1378 if ((insn & 0x0fe00ff0) == 0x0c400000) {
1379 wrd = insn & 0xf;
1380 rdlo = (insn >> 12) & 0xf;
1381 rdhi = (insn >> 16) & 0xf;
1382 if (insn & ARM_CP_RW_BIT) { /* TMRRC */
1383 iwmmxt_load_reg(cpu_V0, wrd);
1384 tcg_gen_trunc_i64_i32(cpu_R[rdlo], cpu_V0);
1385 tcg_gen_shri_i64(cpu_V0, cpu_V0, 32);
1386 tcg_gen_trunc_i64_i32(cpu_R[rdhi], cpu_V0);
1387 } else { /* TMCRR */
1388 tcg_gen_concat_i32_i64(cpu_V0, cpu_R[rdlo], cpu_R[rdhi]);
1389 iwmmxt_store_reg(cpu_V0, wrd);
1390 gen_op_iwmmxt_set_mup();
1391 }
1392 return 0;
1393 }
1394
1395 wrd = (insn >> 12) & 0xf;
1396 addr = tcg_temp_new_i32();
1397 if (gen_iwmmxt_address(s, insn, addr)) {
1398 tcg_temp_free_i32(addr);
1399 return 1;
1400 }
1401 if (insn & ARM_CP_RW_BIT) {
1402 if ((insn >> 28) == 0xf) { /* WLDRW wCx */
1403 tmp = tcg_temp_new_i32();
1404 tcg_gen_qemu_ld32u(tmp, addr, IS_USER(s));
1405 iwmmxt_store_creg(wrd, tmp);
1406 } else {
1407 i = 1;
1408 if (insn & (1 << 8)) {
1409 if (insn & (1 << 22)) { /* WLDRD */
1410 tcg_gen_qemu_ld64(cpu_M0, addr, IS_USER(s));
1411 i = 0;
1412 } else { /* WLDRW wRd */
1413 tmp = gen_ld32(addr, IS_USER(s));
1414 }
1415 } else {
1416 if (insn & (1 << 22)) { /* WLDRH */
1417 tmp = gen_ld16u(addr, IS_USER(s));
1418 } else { /* WLDRB */
1419 tmp = gen_ld8u(addr, IS_USER(s));
1420 }
1421 }
1422 if (i) {
1423 tcg_gen_extu_i32_i64(cpu_M0, tmp);
1424 tcg_temp_free_i32(tmp);
1425 }
1426 gen_op_iwmmxt_movq_wRn_M0(wrd);
1427 }
1428 } else {
1429 if ((insn >> 28) == 0xf) { /* WSTRW wCx */
1430 tmp = iwmmxt_load_creg(wrd);
1431 gen_st32(tmp, addr, IS_USER(s));
1432 } else {
1433 gen_op_iwmmxt_movq_M0_wRn(wrd);
1434 tmp = tcg_temp_new_i32();
1435 if (insn & (1 << 8)) {
1436 if (insn & (1 << 22)) { /* WSTRD */
1437 tcg_temp_free_i32(tmp);
1438 tcg_gen_qemu_st64(cpu_M0, addr, IS_USER(s));
1439 } else { /* WSTRW wRd */
1440 tcg_gen_trunc_i64_i32(tmp, cpu_M0);
1441 gen_st32(tmp, addr, IS_USER(s));
1442 }
1443 } else {
1444 if (insn & (1 << 22)) { /* WSTRH */
1445 tcg_gen_trunc_i64_i32(tmp, cpu_M0);
1446 gen_st16(tmp, addr, IS_USER(s));
1447 } else { /* WSTRB */
1448 tcg_gen_trunc_i64_i32(tmp, cpu_M0);
1449 gen_st8(tmp, addr, IS_USER(s));
1450 }
1451 }
1452 }
1453 }
1454 tcg_temp_free_i32(addr);
1455 return 0;
1456 }
1457
1458 if ((insn & 0x0f000000) != 0x0e000000)
1459 return 1;
1460
1461 switch (((insn >> 12) & 0xf00) | ((insn >> 4) & 0xff)) {
1462 case 0x000: /* WOR */
1463 wrd = (insn >> 12) & 0xf;
1464 rd0 = (insn >> 0) & 0xf;
1465 rd1 = (insn >> 16) & 0xf;
1466 gen_op_iwmmxt_movq_M0_wRn(rd0);
1467 gen_op_iwmmxt_orq_M0_wRn(rd1);
1468 gen_op_iwmmxt_setpsr_nz();
1469 gen_op_iwmmxt_movq_wRn_M0(wrd);
1470 gen_op_iwmmxt_set_mup();
1471 gen_op_iwmmxt_set_cup();
1472 break;
1473 case 0x011: /* TMCR */
1474 if (insn & 0xf)
1475 return 1;
1476 rd = (insn >> 12) & 0xf;
1477 wrd = (insn >> 16) & 0xf;
1478 switch (wrd) {
1479 case ARM_IWMMXT_wCID:
1480 case ARM_IWMMXT_wCASF:
1481 break;
1482 case ARM_IWMMXT_wCon:
1483 gen_op_iwmmxt_set_cup();
1484 /* Fall through. */
1485 case ARM_IWMMXT_wCSSF:
1486 tmp = iwmmxt_load_creg(wrd);
1487 tmp2 = load_reg(s, rd);
1488 tcg_gen_andc_i32(tmp, tmp, tmp2);
1489 tcg_temp_free_i32(tmp2);
1490 iwmmxt_store_creg(wrd, tmp);
1491 break;
1492 case ARM_IWMMXT_wCGR0:
1493 case ARM_IWMMXT_wCGR1:
1494 case ARM_IWMMXT_wCGR2:
1495 case ARM_IWMMXT_wCGR3:
1496 gen_op_iwmmxt_set_cup();
1497 tmp = load_reg(s, rd);
1498 iwmmxt_store_creg(wrd, tmp);
1499 break;
1500 default:
1501 return 1;
1502 }
1503 break;
1504 case 0x100: /* WXOR */
1505 wrd = (insn >> 12) & 0xf;
1506 rd0 = (insn >> 0) & 0xf;
1507 rd1 = (insn >> 16) & 0xf;
1508 gen_op_iwmmxt_movq_M0_wRn(rd0);
1509 gen_op_iwmmxt_xorq_M0_wRn(rd1);
1510 gen_op_iwmmxt_setpsr_nz();
1511 gen_op_iwmmxt_movq_wRn_M0(wrd);
1512 gen_op_iwmmxt_set_mup();
1513 gen_op_iwmmxt_set_cup();
1514 break;
1515 case 0x111: /* TMRC */
1516 if (insn & 0xf)
1517 return 1;
1518 rd = (insn >> 12) & 0xf;
1519 wrd = (insn >> 16) & 0xf;
1520 tmp = iwmmxt_load_creg(wrd);
1521 store_reg(s, rd, tmp);
1522 break;
1523 case 0x300: /* WANDN */
1524 wrd = (insn >> 12) & 0xf;
1525 rd0 = (insn >> 0) & 0xf;
1526 rd1 = (insn >> 16) & 0xf;
1527 gen_op_iwmmxt_movq_M0_wRn(rd0);
1528 tcg_gen_neg_i64(cpu_M0, cpu_M0);
1529 gen_op_iwmmxt_andq_M0_wRn(rd1);
1530 gen_op_iwmmxt_setpsr_nz();
1531 gen_op_iwmmxt_movq_wRn_M0(wrd);
1532 gen_op_iwmmxt_set_mup();
1533 gen_op_iwmmxt_set_cup();
1534 break;
1535 case 0x200: /* WAND */
1536 wrd = (insn >> 12) & 0xf;
1537 rd0 = (insn >> 0) & 0xf;
1538 rd1 = (insn >> 16) & 0xf;
1539 gen_op_iwmmxt_movq_M0_wRn(rd0);
1540 gen_op_iwmmxt_andq_M0_wRn(rd1);
1541 gen_op_iwmmxt_setpsr_nz();
1542 gen_op_iwmmxt_movq_wRn_M0(wrd);
1543 gen_op_iwmmxt_set_mup();
1544 gen_op_iwmmxt_set_cup();
1545 break;
1546 case 0x810: case 0xa10: /* WMADD */
1547 wrd = (insn >> 12) & 0xf;
1548 rd0 = (insn >> 0) & 0xf;
1549 rd1 = (insn >> 16) & 0xf;
1550 gen_op_iwmmxt_movq_M0_wRn(rd0);
1551 if (insn & (1 << 21))
1552 gen_op_iwmmxt_maddsq_M0_wRn(rd1);
1553 else
1554 gen_op_iwmmxt_madduq_M0_wRn(rd1);
1555 gen_op_iwmmxt_movq_wRn_M0(wrd);
1556 gen_op_iwmmxt_set_mup();
1557 break;
1558 case 0x10e: case 0x50e: case 0x90e: case 0xd0e: /* WUNPCKIL */
1559 wrd = (insn >> 12) & 0xf;
1560 rd0 = (insn >> 16) & 0xf;
1561 rd1 = (insn >> 0) & 0xf;
1562 gen_op_iwmmxt_movq_M0_wRn(rd0);
1563 switch ((insn >> 22) & 3) {
1564 case 0:
1565 gen_op_iwmmxt_unpacklb_M0_wRn(rd1);
1566 break;
1567 case 1:
1568 gen_op_iwmmxt_unpacklw_M0_wRn(rd1);
1569 break;
1570 case 2:
1571 gen_op_iwmmxt_unpackll_M0_wRn(rd1);
1572 break;
1573 case 3:
1574 return 1;
1575 }
1576 gen_op_iwmmxt_movq_wRn_M0(wrd);
1577 gen_op_iwmmxt_set_mup();
1578 gen_op_iwmmxt_set_cup();
1579 break;
1580 case 0x10c: case 0x50c: case 0x90c: case 0xd0c: /* WUNPCKIH */
1581 wrd = (insn >> 12) & 0xf;
1582 rd0 = (insn >> 16) & 0xf;
1583 rd1 = (insn >> 0) & 0xf;
1584 gen_op_iwmmxt_movq_M0_wRn(rd0);
1585 switch ((insn >> 22) & 3) {
1586 case 0:
1587 gen_op_iwmmxt_unpackhb_M0_wRn(rd1);
1588 break;
1589 case 1:
1590 gen_op_iwmmxt_unpackhw_M0_wRn(rd1);
1591 break;
1592 case 2:
1593 gen_op_iwmmxt_unpackhl_M0_wRn(rd1);
1594 break;
1595 case 3:
1596 return 1;
1597 }
1598 gen_op_iwmmxt_movq_wRn_M0(wrd);
1599 gen_op_iwmmxt_set_mup();
1600 gen_op_iwmmxt_set_cup();
1601 break;
1602 case 0x012: case 0x112: case 0x412: case 0x512: /* WSAD */
1603 wrd = (insn >> 12) & 0xf;
1604 rd0 = (insn >> 16) & 0xf;
1605 rd1 = (insn >> 0) & 0xf;
1606 gen_op_iwmmxt_movq_M0_wRn(rd0);
1607 if (insn & (1 << 22))
1608 gen_op_iwmmxt_sadw_M0_wRn(rd1);
1609 else
1610 gen_op_iwmmxt_sadb_M0_wRn(rd1);
1611 if (!(insn & (1 << 20)))
1612 gen_op_iwmmxt_addl_M0_wRn(wrd);
1613 gen_op_iwmmxt_movq_wRn_M0(wrd);
1614 gen_op_iwmmxt_set_mup();
1615 break;
1616 case 0x010: case 0x110: case 0x210: case 0x310: /* WMUL */
1617 wrd = (insn >> 12) & 0xf;
1618 rd0 = (insn >> 16) & 0xf;
1619 rd1 = (insn >> 0) & 0xf;
1620 gen_op_iwmmxt_movq_M0_wRn(rd0);
1621 if (insn & (1 << 21)) {
1622 if (insn & (1 << 20))
1623 gen_op_iwmmxt_mulshw_M0_wRn(rd1);
1624 else
1625 gen_op_iwmmxt_mulslw_M0_wRn(rd1);
1626 } else {
1627 if (insn & (1 << 20))
1628 gen_op_iwmmxt_muluhw_M0_wRn(rd1);
1629 else
1630 gen_op_iwmmxt_mululw_M0_wRn(rd1);
1631 }
1632 gen_op_iwmmxt_movq_wRn_M0(wrd);
1633 gen_op_iwmmxt_set_mup();
1634 break;
1635 case 0x410: case 0x510: case 0x610: case 0x710: /* WMAC */
1636 wrd = (insn >> 12) & 0xf;
1637 rd0 = (insn >> 16) & 0xf;
1638 rd1 = (insn >> 0) & 0xf;
1639 gen_op_iwmmxt_movq_M0_wRn(rd0);
1640 if (insn & (1 << 21))
1641 gen_op_iwmmxt_macsw_M0_wRn(rd1);
1642 else
1643 gen_op_iwmmxt_macuw_M0_wRn(rd1);
1644 if (!(insn & (1 << 20))) {
1645 iwmmxt_load_reg(cpu_V1, wrd);
1646 tcg_gen_add_i64(cpu_M0, cpu_M0, cpu_V1);
1647 }
1648 gen_op_iwmmxt_movq_wRn_M0(wrd);
1649 gen_op_iwmmxt_set_mup();
1650 break;
1651 case 0x006: case 0x406: case 0x806: case 0xc06: /* WCMPEQ */
1652 wrd = (insn >> 12) & 0xf;
1653 rd0 = (insn >> 16) & 0xf;
1654 rd1 = (insn >> 0) & 0xf;
1655 gen_op_iwmmxt_movq_M0_wRn(rd0);
1656 switch ((insn >> 22) & 3) {
1657 case 0:
1658 gen_op_iwmmxt_cmpeqb_M0_wRn(rd1);
1659 break;
1660 case 1:
1661 gen_op_iwmmxt_cmpeqw_M0_wRn(rd1);
1662 break;
1663 case 2:
1664 gen_op_iwmmxt_cmpeql_M0_wRn(rd1);
1665 break;
1666 case 3:
1667 return 1;
1668 }
1669 gen_op_iwmmxt_movq_wRn_M0(wrd);
1670 gen_op_iwmmxt_set_mup();
1671 gen_op_iwmmxt_set_cup();
1672 break;
1673 case 0x800: case 0x900: case 0xc00: case 0xd00: /* WAVG2 */
1674 wrd = (insn >> 12) & 0xf;
1675 rd0 = (insn >> 16) & 0xf;
1676 rd1 = (insn >> 0) & 0xf;
1677 gen_op_iwmmxt_movq_M0_wRn(rd0);
1678 if (insn & (1 << 22)) {
1679 if (insn & (1 << 20))
1680 gen_op_iwmmxt_avgw1_M0_wRn(rd1);
1681 else
1682 gen_op_iwmmxt_avgw0_M0_wRn(rd1);
1683 } else {
1684 if (insn & (1 << 20))
1685 gen_op_iwmmxt_avgb1_M0_wRn(rd1);
1686 else
1687 gen_op_iwmmxt_avgb0_M0_wRn(rd1);
1688 }
1689 gen_op_iwmmxt_movq_wRn_M0(wrd);
1690 gen_op_iwmmxt_set_mup();
1691 gen_op_iwmmxt_set_cup();
1692 break;
1693 case 0x802: case 0x902: case 0xa02: case 0xb02: /* WALIGNR */
1694 wrd = (insn >> 12) & 0xf;
1695 rd0 = (insn >> 16) & 0xf;
1696 rd1 = (insn >> 0) & 0xf;
1697 gen_op_iwmmxt_movq_M0_wRn(rd0);
1698 tmp = iwmmxt_load_creg(ARM_IWMMXT_wCGR0 + ((insn >> 20) & 3));
1699 tcg_gen_andi_i32(tmp, tmp, 7);
1700 iwmmxt_load_reg(cpu_V1, rd1);
1701 gen_helper_iwmmxt_align(cpu_M0, cpu_M0, cpu_V1, tmp);
1702 tcg_temp_free_i32(tmp);
1703 gen_op_iwmmxt_movq_wRn_M0(wrd);
1704 gen_op_iwmmxt_set_mup();
1705 break;
1706 case 0x601: case 0x605: case 0x609: case 0x60d: /* TINSR */
1707 if (((insn >> 6) & 3) == 3)
1708 return 1;
1709 rd = (insn >> 12) & 0xf;
1710 wrd = (insn >> 16) & 0xf;
1711 tmp = load_reg(s, rd);
1712 gen_op_iwmmxt_movq_M0_wRn(wrd);
1713 switch ((insn >> 6) & 3) {
1714 case 0:
1715 tmp2 = tcg_const_i32(0xff);
1716 tmp3 = tcg_const_i32((insn & 7) << 3);
1717 break;
1718 case 1:
1719 tmp2 = tcg_const_i32(0xffff);
1720 tmp3 = tcg_const_i32((insn & 3) << 4);
1721 break;
1722 case 2:
1723 tmp2 = tcg_const_i32(0xffffffff);
1724 tmp3 = tcg_const_i32((insn & 1) << 5);
1725 break;
1726 default:
1727 TCGV_UNUSED(tmp2);
1728 TCGV_UNUSED(tmp3);
1729 }
1730 gen_helper_iwmmxt_insr(cpu_M0, cpu_M0, tmp, tmp2, tmp3);
1731 tcg_temp_free(tmp3);
1732 tcg_temp_free(tmp2);
1733 tcg_temp_free_i32(tmp);
1734 gen_op_iwmmxt_movq_wRn_M0(wrd);
1735 gen_op_iwmmxt_set_mup();
1736 break;
1737 case 0x107: case 0x507: case 0x907: case 0xd07: /* TEXTRM */
1738 rd = (insn >> 12) & 0xf;
1739 wrd = (insn >> 16) & 0xf;
1740 if (rd == 15 || ((insn >> 22) & 3) == 3)
1741 return 1;
1742 gen_op_iwmmxt_movq_M0_wRn(wrd);
1743 tmp = tcg_temp_new_i32();
1744 switch ((insn >> 22) & 3) {
1745 case 0:
1746 tcg_gen_shri_i64(cpu_M0, cpu_M0, (insn & 7) << 3);
1747 tcg_gen_trunc_i64_i32(tmp, cpu_M0);
1748 if (insn & 8) {
1749 tcg_gen_ext8s_i32(tmp, tmp);
1750 } else {
1751 tcg_gen_andi_i32(tmp, tmp, 0xff);
1752 }
1753 break;
1754 case 1:
1755 tcg_gen_shri_i64(cpu_M0, cpu_M0, (insn & 3) << 4);
1756 tcg_gen_trunc_i64_i32(tmp, cpu_M0);
1757 if (insn & 8) {
1758 tcg_gen_ext16s_i32(tmp, tmp);
1759 } else {
1760 tcg_gen_andi_i32(tmp, tmp, 0xffff);
1761 }
1762 break;
1763 case 2:
1764 tcg_gen_shri_i64(cpu_M0, cpu_M0, (insn & 1) << 5);
1765 tcg_gen_trunc_i64_i32(tmp, cpu_M0);
1766 break;
1767 }
1768 store_reg(s, rd, tmp);
1769 break;
1770 case 0x117: case 0x517: case 0x917: case 0xd17: /* TEXTRC */
1771 if ((insn & 0x000ff008) != 0x0003f000 || ((insn >> 22) & 3) == 3)
1772 return 1;
1773 tmp = iwmmxt_load_creg(ARM_IWMMXT_wCASF);
1774 switch ((insn >> 22) & 3) {
1775 case 0:
1776 tcg_gen_shri_i32(tmp, tmp, ((insn & 7) << 2) + 0);
1777 break;
1778 case 1:
1779 tcg_gen_shri_i32(tmp, tmp, ((insn & 3) << 3) + 4);
1780 break;
1781 case 2:
1782 tcg_gen_shri_i32(tmp, tmp, ((insn & 1) << 4) + 12);
1783 break;
1784 }
1785 tcg_gen_shli_i32(tmp, tmp, 28);
1786 gen_set_nzcv(tmp);
1787 tcg_temp_free_i32(tmp);
1788 break;
1789 case 0x401: case 0x405: case 0x409: case 0x40d: /* TBCST */
1790 if (((insn >> 6) & 3) == 3)
1791 return 1;
1792 rd = (insn >> 12) & 0xf;
1793 wrd = (insn >> 16) & 0xf;
1794 tmp = load_reg(s, rd);
1795 switch ((insn >> 6) & 3) {
1796 case 0:
1797 gen_helper_iwmmxt_bcstb(cpu_M0, tmp);
1798 break;
1799 case 1:
1800 gen_helper_iwmmxt_bcstw(cpu_M0, tmp);
1801 break;
1802 case 2:
1803 gen_helper_iwmmxt_bcstl(cpu_M0, tmp);
1804 break;
1805 }
1806 tcg_temp_free_i32(tmp);
1807 gen_op_iwmmxt_movq_wRn_M0(wrd);
1808 gen_op_iwmmxt_set_mup();
1809 break;
1810 case 0x113: case 0x513: case 0x913: case 0xd13: /* TANDC */
1811 if ((insn & 0x000ff00f) != 0x0003f000 || ((insn >> 22) & 3) == 3)
1812 return 1;
1813 tmp = iwmmxt_load_creg(ARM_IWMMXT_wCASF);
1814 tmp2 = tcg_temp_new_i32();
1815 tcg_gen_mov_i32(tmp2, tmp);
1816 switch ((insn >> 22) & 3) {
1817 case 0:
1818 for (i = 0; i < 7; i ++) {
1819 tcg_gen_shli_i32(tmp2, tmp2, 4);
1820 tcg_gen_and_i32(tmp, tmp, tmp2);
1821 }
1822 break;
1823 case 1:
1824 for (i = 0; i < 3; i ++) {
1825 tcg_gen_shli_i32(tmp2, tmp2, 8);
1826 tcg_gen_and_i32(tmp, tmp, tmp2);
1827 }
1828 break;
1829 case 2:
1830 tcg_gen_shli_i32(tmp2, tmp2, 16);
1831 tcg_gen_and_i32(tmp, tmp, tmp2);
1832 break;
1833 }
1834 gen_set_nzcv(tmp);
1835 tcg_temp_free_i32(tmp2);
1836 tcg_temp_free_i32(tmp);
1837 break;
1838 case 0x01c: case 0x41c: case 0x81c: case 0xc1c: /* WACC */
1839 wrd = (insn >> 12) & 0xf;
1840 rd0 = (insn >> 16) & 0xf;
1841 gen_op_iwmmxt_movq_M0_wRn(rd0);
1842 switch ((insn >> 22) & 3) {
1843 case 0:
1844 gen_helper_iwmmxt_addcb(cpu_M0, cpu_M0);
1845 break;
1846 case 1:
1847 gen_helper_iwmmxt_addcw(cpu_M0, cpu_M0);
1848 break;
1849 case 2:
1850 gen_helper_iwmmxt_addcl(cpu_M0, cpu_M0);
1851 break;
1852 case 3:
1853 return 1;
1854 }
1855 gen_op_iwmmxt_movq_wRn_M0(wrd);
1856 gen_op_iwmmxt_set_mup();
1857 break;
1858 case 0x115: case 0x515: case 0x915: case 0xd15: /* TORC */
1859 if ((insn & 0x000ff00f) != 0x0003f000 || ((insn >> 22) & 3) == 3)
1860 return 1;
1861 tmp = iwmmxt_load_creg(ARM_IWMMXT_wCASF);
1862 tmp2 = tcg_temp_new_i32();
1863 tcg_gen_mov_i32(tmp2, tmp);
1864 switch ((insn >> 22) & 3) {
1865 case 0:
1866 for (i = 0; i < 7; i ++) {
1867 tcg_gen_shli_i32(tmp2, tmp2, 4);
1868 tcg_gen_or_i32(tmp, tmp, tmp2);
1869 }
1870 break;
1871 case 1:
1872 for (i = 0; i < 3; i ++) {
1873 tcg_gen_shli_i32(tmp2, tmp2, 8);
1874 tcg_gen_or_i32(tmp, tmp, tmp2);
1875 }
1876 break;
1877 case 2:
1878 tcg_gen_shli_i32(tmp2, tmp2, 16);
1879 tcg_gen_or_i32(tmp, tmp, tmp2);
1880 break;
1881 }
1882 gen_set_nzcv(tmp);
1883 tcg_temp_free_i32(tmp2);
1884 tcg_temp_free_i32(tmp);
1885 break;
1886 case 0x103: case 0x503: case 0x903: case 0xd03: /* TMOVMSK */
1887 rd = (insn >> 12) & 0xf;
1888 rd0 = (insn >> 16) & 0xf;
1889 if ((insn & 0xf) != 0 || ((insn >> 22) & 3) == 3)
1890 return 1;
1891 gen_op_iwmmxt_movq_M0_wRn(rd0);
1892 tmp = tcg_temp_new_i32();
1893 switch ((insn >> 22) & 3) {
1894 case 0:
1895 gen_helper_iwmmxt_msbb(tmp, cpu_M0);
1896 break;
1897 case 1:
1898 gen_helper_iwmmxt_msbw(tmp, cpu_M0);
1899 break;
1900 case 2:
1901 gen_helper_iwmmxt_msbl(tmp, cpu_M0);
1902 break;
1903 }
1904 store_reg(s, rd, tmp);
1905 break;
1906 case 0x106: case 0x306: case 0x506: case 0x706: /* WCMPGT */
1907 case 0x906: case 0xb06: case 0xd06: case 0xf06:
1908 wrd = (insn >> 12) & 0xf;
1909 rd0 = (insn >> 16) & 0xf;
1910 rd1 = (insn >> 0) & 0xf;
1911 gen_op_iwmmxt_movq_M0_wRn(rd0);
1912 switch ((insn >> 22) & 3) {
1913 case 0:
1914 if (insn & (1 << 21))
1915 gen_op_iwmmxt_cmpgtsb_M0_wRn(rd1);
1916 else
1917 gen_op_iwmmxt_cmpgtub_M0_wRn(rd1);
1918 break;
1919 case 1:
1920 if (insn & (1 << 21))
1921 gen_op_iwmmxt_cmpgtsw_M0_wRn(rd1);
1922 else
1923 gen_op_iwmmxt_cmpgtuw_M0_wRn(rd1);
1924 break;
1925 case 2:
1926 if (insn & (1 << 21))
1927 gen_op_iwmmxt_cmpgtsl_M0_wRn(rd1);
1928 else
1929 gen_op_iwmmxt_cmpgtul_M0_wRn(rd1);
1930 break;
1931 case 3:
1932 return 1;
1933 }
1934 gen_op_iwmmxt_movq_wRn_M0(wrd);
1935 gen_op_iwmmxt_set_mup();
1936 gen_op_iwmmxt_set_cup();
1937 break;
1938 case 0x00e: case 0x20e: case 0x40e: case 0x60e: /* WUNPCKEL */
1939 case 0x80e: case 0xa0e: case 0xc0e: case 0xe0e:
1940 wrd = (insn >> 12) & 0xf;
1941 rd0 = (insn >> 16) & 0xf;
1942 gen_op_iwmmxt_movq_M0_wRn(rd0);
1943 switch ((insn >> 22) & 3) {
1944 case 0:
1945 if (insn & (1 << 21))
1946 gen_op_iwmmxt_unpacklsb_M0();
1947 else
1948 gen_op_iwmmxt_unpacklub_M0();
1949 break;
1950 case 1:
1951 if (insn & (1 << 21))
1952 gen_op_iwmmxt_unpacklsw_M0();
1953 else
1954 gen_op_iwmmxt_unpackluw_M0();
1955 break;
1956 case 2:
1957 if (insn & (1 << 21))
1958 gen_op_iwmmxt_unpacklsl_M0();
1959 else
1960 gen_op_iwmmxt_unpacklul_M0();
1961 break;
1962 case 3:
1963 return 1;
1964 }
1965 gen_op_iwmmxt_movq_wRn_M0(wrd);
1966 gen_op_iwmmxt_set_mup();
1967 gen_op_iwmmxt_set_cup();
1968 break;
1969 case 0x00c: case 0x20c: case 0x40c: case 0x60c: /* WUNPCKEH */
1970 case 0x80c: case 0xa0c: case 0xc0c: case 0xe0c:
1971 wrd = (insn >> 12) & 0xf;
1972 rd0 = (insn >> 16) & 0xf;
1973 gen_op_iwmmxt_movq_M0_wRn(rd0);
1974 switch ((insn >> 22) & 3) {
1975 case 0:
1976 if (insn & (1 << 21))
1977 gen_op_iwmmxt_unpackhsb_M0();
1978 else
1979 gen_op_iwmmxt_unpackhub_M0();
1980 break;
1981 case 1:
1982 if (insn & (1 << 21))
1983 gen_op_iwmmxt_unpackhsw_M0();
1984 else
1985 gen_op_iwmmxt_unpackhuw_M0();
1986 break;
1987 case 2:
1988 if (insn & (1 << 21))
1989 gen_op_iwmmxt_unpackhsl_M0();
1990 else
1991 gen_op_iwmmxt_unpackhul_M0();
1992 break;
1993 case 3:
1994 return 1;
1995 }
1996 gen_op_iwmmxt_movq_wRn_M0(wrd);
1997 gen_op_iwmmxt_set_mup();
1998 gen_op_iwmmxt_set_cup();
1999 break;
2000 case 0x204: case 0x604: case 0xa04: case 0xe04: /* WSRL */
2001 case 0x214: case 0x614: case 0xa14: case 0xe14:
2002 if (((insn >> 22) & 3) == 0)
2003 return 1;
2004 wrd = (insn >> 12) & 0xf;
2005 rd0 = (insn >> 16) & 0xf;
2006 gen_op_iwmmxt_movq_M0_wRn(rd0);
2007 tmp = tcg_temp_new_i32();
2008 if (gen_iwmmxt_shift(insn, 0xff, tmp)) {
2009 tcg_temp_free_i32(tmp);
2010 return 1;
2011 }
2012 switch ((insn >> 22) & 3) {
2013 case 1:
2014 gen_helper_iwmmxt_srlw(cpu_M0, cpu_env, cpu_M0, tmp);
2015 break;
2016 case 2:
2017 gen_helper_iwmmxt_srll(cpu_M0, cpu_env, cpu_M0, tmp);
2018 break;
2019 case 3:
2020 gen_helper_iwmmxt_srlq(cpu_M0, cpu_env, cpu_M0, tmp);
2021 break;
2022 }
2023 tcg_temp_free_i32(tmp);
2024 gen_op_iwmmxt_movq_wRn_M0(wrd);
2025 gen_op_iwmmxt_set_mup();
2026 gen_op_iwmmxt_set_cup();
2027 break;
2028 case 0x004: case 0x404: case 0x804: case 0xc04: /* WSRA */
2029 case 0x014: case 0x414: case 0x814: case 0xc14:
2030 if (((insn >> 22) & 3) == 0)
2031 return 1;
2032 wrd = (insn >> 12) & 0xf;
2033 rd0 = (insn >> 16) & 0xf;
2034 gen_op_iwmmxt_movq_M0_wRn(rd0);
2035 tmp = tcg_temp_new_i32();
2036 if (gen_iwmmxt_shift(insn, 0xff, tmp)) {
2037 tcg_temp_free_i32(tmp);
2038 return 1;
2039 }
2040 switch ((insn >> 22) & 3) {
2041 case 1:
2042 gen_helper_iwmmxt_sraw(cpu_M0, cpu_env, cpu_M0, tmp);
2043 break;
2044 case 2:
2045 gen_helper_iwmmxt_sral(cpu_M0, cpu_env, cpu_M0, tmp);
2046 break;
2047 case 3:
2048 gen_helper_iwmmxt_sraq(cpu_M0, cpu_env, cpu_M0, tmp);
2049 break;
2050 }
2051 tcg_temp_free_i32(tmp);
2052 gen_op_iwmmxt_movq_wRn_M0(wrd);
2053 gen_op_iwmmxt_set_mup();
2054 gen_op_iwmmxt_set_cup();
2055 break;
2056 case 0x104: case 0x504: case 0x904: case 0xd04: /* WSLL */
2057 case 0x114: case 0x514: case 0x914: case 0xd14:
2058 if (((insn >> 22) & 3) == 0)
2059 return 1;
2060 wrd = (insn >> 12) & 0xf;
2061 rd0 = (insn >> 16) & 0xf;
2062 gen_op_iwmmxt_movq_M0_wRn(rd0);
2063 tmp = tcg_temp_new_i32();
2064 if (gen_iwmmxt_shift(insn, 0xff, tmp)) {
2065 tcg_temp_free_i32(tmp);
2066 return 1;
2067 }
2068 switch ((insn >> 22) & 3) {
2069 case 1:
2070 gen_helper_iwmmxt_sllw(cpu_M0, cpu_env, cpu_M0, tmp);
2071 break;
2072 case 2:
2073 gen_helper_iwmmxt_slll(cpu_M0, cpu_env, cpu_M0, tmp);
2074 break;
2075 case 3:
2076 gen_helper_iwmmxt_sllq(cpu_M0, cpu_env, cpu_M0, tmp);
2077 break;
2078 }
2079 tcg_temp_free_i32(tmp);
2080 gen_op_iwmmxt_movq_wRn_M0(wrd);
2081 gen_op_iwmmxt_set_mup();
2082 gen_op_iwmmxt_set_cup();
2083 break;
2084 case 0x304: case 0x704: case 0xb04: case 0xf04: /* WROR */
2085 case 0x314: case 0x714: case 0xb14: case 0xf14:
2086 if (((insn >> 22) & 3) == 0)
2087 return 1;
2088 wrd = (insn >> 12) & 0xf;
2089 rd0 = (insn >> 16) & 0xf;
2090 gen_op_iwmmxt_movq_M0_wRn(rd0);
2091 tmp = tcg_temp_new_i32();
2092 switch ((insn >> 22) & 3) {
2093 case 1:
2094 if (gen_iwmmxt_shift(insn, 0xf, tmp)) {
2095 tcg_temp_free_i32(tmp);
2096 return 1;
2097 }
2098 gen_helper_iwmmxt_rorw(cpu_M0, cpu_env, cpu_M0, tmp);
2099 break;
2100 case 2:
2101 if (gen_iwmmxt_shift(insn, 0x1f, tmp)) {
2102 tcg_temp_free_i32(tmp);
2103 return 1;
2104 }
2105 gen_helper_iwmmxt_rorl(cpu_M0, cpu_env, cpu_M0, tmp);
2106 break;
2107 case 3:
2108 if (gen_iwmmxt_shift(insn, 0x3f, tmp)) {
2109 tcg_temp_free_i32(tmp);
2110 return 1;
2111 }
2112 gen_helper_iwmmxt_rorq(cpu_M0, cpu_env, cpu_M0, tmp);
2113 break;
2114 }
2115 tcg_temp_free_i32(tmp);
2116 gen_op_iwmmxt_movq_wRn_M0(wrd);
2117 gen_op_iwmmxt_set_mup();
2118 gen_op_iwmmxt_set_cup();
2119 break;
2120 case 0x116: case 0x316: case 0x516: case 0x716: /* WMIN */
2121 case 0x916: case 0xb16: case 0xd16: case 0xf16:
2122 wrd = (insn >> 12) & 0xf;
2123 rd0 = (insn >> 16) & 0xf;
2124 rd1 = (insn >> 0) & 0xf;
2125 gen_op_iwmmxt_movq_M0_wRn(rd0);
2126 switch ((insn >> 22) & 3) {
2127 case 0:
2128 if (insn & (1 << 21))
2129 gen_op_iwmmxt_minsb_M0_wRn(rd1);
2130 else
2131 gen_op_iwmmxt_minub_M0_wRn(rd1);
2132 break;
2133 case 1:
2134 if (insn & (1 << 21))
2135 gen_op_iwmmxt_minsw_M0_wRn(rd1);
2136 else
2137 gen_op_iwmmxt_minuw_M0_wRn(rd1);
2138 break;
2139 case 2:
2140 if (insn & (1 << 21))
2141 gen_op_iwmmxt_minsl_M0_wRn(rd1);
2142 else
2143 gen_op_iwmmxt_minul_M0_wRn(rd1);
2144 break;
2145 case 3:
2146 return 1;
2147 }
2148 gen_op_iwmmxt_movq_wRn_M0(wrd);
2149 gen_op_iwmmxt_set_mup();
2150 break;
2151 case 0x016: case 0x216: case 0x416: case 0x616: /* WMAX */
2152 case 0x816: case 0xa16: case 0xc16: case 0xe16:
2153 wrd = (insn >> 12) & 0xf;
2154 rd0 = (insn >> 16) & 0xf;
2155 rd1 = (insn >> 0) & 0xf;
2156 gen_op_iwmmxt_movq_M0_wRn(rd0);
2157 switch ((insn >> 22) & 3) {
2158 case 0:
2159 if (insn & (1 << 21))
2160 gen_op_iwmmxt_maxsb_M0_wRn(rd1);
2161 else
2162 gen_op_iwmmxt_maxub_M0_wRn(rd1);
2163 break;
2164 case 1:
2165 if (insn & (1 << 21))
2166 gen_op_iwmmxt_maxsw_M0_wRn(rd1);
2167 else
2168 gen_op_iwmmxt_maxuw_M0_wRn(rd1);
2169 break;
2170 case 2:
2171 if (insn & (1 << 21))
2172 gen_op_iwmmxt_maxsl_M0_wRn(rd1);
2173 else
2174 gen_op_iwmmxt_maxul_M0_wRn(rd1);
2175 break;
2176 case 3:
2177 return 1;
2178 }
2179 gen_op_iwmmxt_movq_wRn_M0(wrd);
2180 gen_op_iwmmxt_set_mup();
2181 break;
2182 case 0x002: case 0x102: case 0x202: case 0x302: /* WALIGNI */
2183 case 0x402: case 0x502: case 0x602: case 0x702:
2184 wrd = (insn >> 12) & 0xf;
2185 rd0 = (insn >> 16) & 0xf;
2186 rd1 = (insn >> 0) & 0xf;
2187 gen_op_iwmmxt_movq_M0_wRn(rd0);
2188 tmp = tcg_const_i32((insn >> 20) & 3);
2189 iwmmxt_load_reg(cpu_V1, rd1);
2190 gen_helper_iwmmxt_align(cpu_M0, cpu_M0, cpu_V1, tmp);
2191 tcg_temp_free(tmp);
2192 gen_op_iwmmxt_movq_wRn_M0(wrd);
2193 gen_op_iwmmxt_set_mup();
2194 break;
2195 case 0x01a: case 0x11a: case 0x21a: case 0x31a: /* WSUB */
2196 case 0x41a: case 0x51a: case 0x61a: case 0x71a:
2197 case 0x81a: case 0x91a: case 0xa1a: case 0xb1a:
2198 case 0xc1a: case 0xd1a: case 0xe1a: case 0xf1a:
2199 wrd = (insn >> 12) & 0xf;
2200 rd0 = (insn >> 16) & 0xf;
2201 rd1 = (insn >> 0) & 0xf;
2202 gen_op_iwmmxt_movq_M0_wRn(rd0);
2203 switch ((insn >> 20) & 0xf) {
2204 case 0x0:
2205 gen_op_iwmmxt_subnb_M0_wRn(rd1);
2206 break;
2207 case 0x1:
2208 gen_op_iwmmxt_subub_M0_wRn(rd1);
2209 break;
2210 case 0x3:
2211 gen_op_iwmmxt_subsb_M0_wRn(rd1);
2212 break;
2213 case 0x4:
2214 gen_op_iwmmxt_subnw_M0_wRn(rd1);
2215 break;
2216 case 0x5:
2217 gen_op_iwmmxt_subuw_M0_wRn(rd1);
2218 break;
2219 case 0x7:
2220 gen_op_iwmmxt_subsw_M0_wRn(rd1);
2221 break;
2222 case 0x8:
2223 gen_op_iwmmxt_subnl_M0_wRn(rd1);
2224 break;
2225 case 0x9:
2226 gen_op_iwmmxt_subul_M0_wRn(rd1);
2227 break;
2228 case 0xb:
2229 gen_op_iwmmxt_subsl_M0_wRn(rd1);
2230 break;
2231 default:
2232 return 1;
2233 }
2234 gen_op_iwmmxt_movq_wRn_M0(wrd);
2235 gen_op_iwmmxt_set_mup();
2236 gen_op_iwmmxt_set_cup();
2237 break;
2238 case 0x01e: case 0x11e: case 0x21e: case 0x31e: /* WSHUFH */
2239 case 0x41e: case 0x51e: case 0x61e: case 0x71e:
2240 case 0x81e: case 0x91e: case 0xa1e: case 0xb1e:
2241 case 0xc1e: case 0xd1e: case 0xe1e: case 0xf1e:
2242 wrd = (insn >> 12) & 0xf;
2243 rd0 = (insn >> 16) & 0xf;
2244 gen_op_iwmmxt_movq_M0_wRn(rd0);
2245 tmp = tcg_const_i32(((insn >> 16) & 0xf0) | (insn & 0x0f));
2246 gen_helper_iwmmxt_shufh(cpu_M0, cpu_env, cpu_M0, tmp);
2247 tcg_temp_free(tmp);
2248 gen_op_iwmmxt_movq_wRn_M0(wrd);
2249 gen_op_iwmmxt_set_mup();
2250 gen_op_iwmmxt_set_cup();
2251 break;
2252 case 0x018: case 0x118: case 0x218: case 0x318: /* WADD */
2253 case 0x418: case 0x518: case 0x618: case 0x718:
2254 case 0x818: case 0x918: case 0xa18: case 0xb18:
2255 case 0xc18: case 0xd18: case 0xe18: case 0xf18:
2256 wrd = (insn >> 12) & 0xf;
2257 rd0 = (insn >> 16) & 0xf;
2258 rd1 = (insn >> 0) & 0xf;
2259 gen_op_iwmmxt_movq_M0_wRn(rd0);
2260 switch ((insn >> 20) & 0xf) {
2261 case 0x0:
2262 gen_op_iwmmxt_addnb_M0_wRn(rd1);
2263 break;
2264 case 0x1:
2265 gen_op_iwmmxt_addub_M0_wRn(rd1);
2266 break;
2267 case 0x3:
2268 gen_op_iwmmxt_addsb_M0_wRn(rd1);
2269 break;
2270 case 0x4:
2271 gen_op_iwmmxt_addnw_M0_wRn(rd1);
2272 break;
2273 case 0x5:
2274 gen_op_iwmmxt_adduw_M0_wRn(rd1);
2275 break;
2276 case 0x7:
2277 gen_op_iwmmxt_addsw_M0_wRn(rd1);
2278 break;
2279 case 0x8:
2280 gen_op_iwmmxt_addnl_M0_wRn(rd1);
2281 break;
2282 case 0x9:
2283 gen_op_iwmmxt_addul_M0_wRn(rd1);
2284 break;
2285 case 0xb:
2286 gen_op_iwmmxt_addsl_M0_wRn(rd1);
2287 break;
2288 default:
2289 return 1;
2290 }
2291 gen_op_iwmmxt_movq_wRn_M0(wrd);
2292 gen_op_iwmmxt_set_mup();
2293 gen_op_iwmmxt_set_cup();
2294 break;
2295 case 0x008: case 0x108: case 0x208: case 0x308: /* WPACK */
2296 case 0x408: case 0x508: case 0x608: case 0x708:
2297 case 0x808: case 0x908: case 0xa08: case 0xb08:
2298 case 0xc08: case 0xd08: case 0xe08: case 0xf08:
2299 if (!(insn & (1 << 20)) || ((insn >> 22) & 3) == 0)
2300 return 1;
2301 wrd = (insn >> 12) & 0xf;
2302 rd0 = (insn >> 16) & 0xf;
2303 rd1 = (insn >> 0) & 0xf;
2304 gen_op_iwmmxt_movq_M0_wRn(rd0);
2305 switch ((insn >> 22) & 3) {
2306 case 1:
2307 if (insn & (1 << 21))
2308 gen_op_iwmmxt_packsw_M0_wRn(rd1);
2309 else
2310 gen_op_iwmmxt_packuw_M0_wRn(rd1);
2311 break;
2312 case 2:
2313 if (insn & (1 << 21))
2314 gen_op_iwmmxt_packsl_M0_wRn(rd1);
2315 else
2316 gen_op_iwmmxt_packul_M0_wRn(rd1);
2317 break;
2318 case 3:
2319 if (insn & (1 << 21))
2320 gen_op_iwmmxt_packsq_M0_wRn(rd1);
2321 else
2322 gen_op_iwmmxt_packuq_M0_wRn(rd1);
2323 break;
2324 }
2325 gen_op_iwmmxt_movq_wRn_M0(wrd);
2326 gen_op_iwmmxt_set_mup();
2327 gen_op_iwmmxt_set_cup();
2328 break;
2329 case 0x201: case 0x203: case 0x205: case 0x207:
2330 case 0x209: case 0x20b: case 0x20d: case 0x20f:
2331 case 0x211: case 0x213: case 0x215: case 0x217:
2332 case 0x219: case 0x21b: case 0x21d: case 0x21f:
2333 wrd = (insn >> 5) & 0xf;
2334 rd0 = (insn >> 12) & 0xf;
2335 rd1 = (insn >> 0) & 0xf;
2336 if (rd0 == 0xf || rd1 == 0xf)
2337 return 1;
2338 gen_op_iwmmxt_movq_M0_wRn(wrd);
2339 tmp = load_reg(s, rd0);
2340 tmp2 = load_reg(s, rd1);
2341 switch ((insn >> 16) & 0xf) {
2342 case 0x0: /* TMIA */
2343 gen_helper_iwmmxt_muladdsl(cpu_M0, cpu_M0, tmp, tmp2);
2344 break;
2345 case 0x8: /* TMIAPH */
2346 gen_helper_iwmmxt_muladdsw(cpu_M0, cpu_M0, tmp, tmp2);
2347 break;
2348 case 0xc: case 0xd: case 0xe: case 0xf: /* TMIAxy */
2349 if (insn & (1 << 16))
2350 tcg_gen_shri_i32(tmp, tmp, 16);
2351 if (insn & (1 << 17))
2352 tcg_gen_shri_i32(tmp2, tmp2, 16);
2353 gen_helper_iwmmxt_muladdswl(cpu_M0, cpu_M0, tmp, tmp2);
2354 break;
2355 default:
2356 tcg_temp_free_i32(tmp2);
2357 tcg_temp_free_i32(tmp);
2358 return 1;
2359 }
2360 tcg_temp_free_i32(tmp2);
2361 tcg_temp_free_i32(tmp);
2362 gen_op_iwmmxt_movq_wRn_M0(wrd);
2363 gen_op_iwmmxt_set_mup();
2364 break;
2365 default:
2366 return 1;
2367 }
2368
2369 return 0;
2370 }
2371
2372 /* Disassemble an XScale DSP instruction. Returns nonzero if an error occurred
2373 (ie. an undefined instruction). */
2374 static int disas_dsp_insn(CPUARMState *env, DisasContext *s, uint32_t insn)
2375 {
2376 int acc, rd0, rd1, rdhi, rdlo;
2377 TCGv tmp, tmp2;
2378
2379 if ((insn & 0x0ff00f10) == 0x0e200010) {
2380 /* Multiply with Internal Accumulate Format */
2381 rd0 = (insn >> 12) & 0xf;
2382 rd1 = insn & 0xf;
2383 acc = (insn >> 5) & 7;
2384
2385 if (acc != 0)
2386 return 1;
2387
2388 tmp = load_reg(s, rd0);
2389 tmp2 = load_reg(s, rd1);
2390 switch ((insn >> 16) & 0xf) {
2391 case 0x0: /* MIA */
2392 gen_helper_iwmmxt_muladdsl(cpu_M0, cpu_M0, tmp, tmp2);
2393 break;
2394 case 0x8: /* MIAPH */
2395 gen_helper_iwmmxt_muladdsw(cpu_M0, cpu_M0, tmp, tmp2);
2396 break;
2397 case 0xc: /* MIABB */
2398 case 0xd: /* MIABT */
2399 case 0xe: /* MIATB */
2400 case 0xf: /* MIATT */
2401 if (insn & (1 << 16))
2402 tcg_gen_shri_i32(tmp, tmp, 16);
2403 if (insn & (1 << 17))
2404 tcg_gen_shri_i32(tmp2, tmp2, 16);
2405 gen_helper_iwmmxt_muladdswl(cpu_M0, cpu_M0, tmp, tmp2);
2406 break;
2407 default:
2408 return 1;
2409 }
2410 tcg_temp_free_i32(tmp2);
2411 tcg_temp_free_i32(tmp);
2412
2413 gen_op_iwmmxt_movq_wRn_M0(acc);
2414 return 0;
2415 }
2416
2417 if ((insn & 0x0fe00ff8) == 0x0c400000) {
2418 /* Internal Accumulator Access Format */
2419 rdhi = (insn >> 16) & 0xf;
2420 rdlo = (insn >> 12) & 0xf;
2421 acc = insn & 7;
2422
2423 if (acc != 0)
2424 return 1;
2425
2426 if (insn & ARM_CP_RW_BIT) { /* MRA */
2427 iwmmxt_load_reg(cpu_V0, acc);
2428 tcg_gen_trunc_i64_i32(cpu_R[rdlo], cpu_V0);
2429 tcg_gen_shri_i64(cpu_V0, cpu_V0, 32);
2430 tcg_gen_trunc_i64_i32(cpu_R[rdhi], cpu_V0);
2431 tcg_gen_andi_i32(cpu_R[rdhi], cpu_R[rdhi], (1 << (40 - 32)) - 1);
2432 } else { /* MAR */
2433 tcg_gen_concat_i32_i64(cpu_V0, cpu_R[rdlo], cpu_R[rdhi]);
2434 iwmmxt_store_reg(cpu_V0, acc);
2435 }
2436 return 0;
2437 }
2438
2439 return 1;
2440 }
2441
2442 /* Disassemble system coprocessor instruction. Return nonzero if
2443 instruction is not defined. */
2444 static int disas_cp_insn(CPUARMState *env, DisasContext *s, uint32_t insn)
2445 {
2446 TCGv tmp, tmp2;
2447 uint32_t rd = (insn >> 12) & 0xf;
2448 uint32_t cp = (insn >> 8) & 0xf;
2449 if (IS_USER(s)) {
2450 return 1;
2451 }
2452
2453 if (insn & ARM_CP_RW_BIT) {
2454 if (!env->cp[cp].cp_read)
2455 return 1;
2456 gen_set_pc_im(s->pc);
2457 tmp = tcg_temp_new_i32();
2458 tmp2 = tcg_const_i32(insn);
2459 gen_helper_get_cp(tmp, cpu_env, tmp2);
2460 tcg_temp_free(tmp2);
2461 store_reg(s, rd, tmp);
2462 } else {
2463 if (!env->cp[cp].cp_write)
2464 return 1;
2465 gen_set_pc_im(s->pc);
2466 tmp = load_reg(s, rd);
2467 tmp2 = tcg_const_i32(insn);
2468 gen_helper_set_cp(cpu_env, tmp2, tmp);
2469 tcg_temp_free(tmp2);
2470 tcg_temp_free_i32(tmp);
2471 }
2472 return 0;
2473 }
2474
2475 static int cp15_user_ok(CPUARMState *env, uint32_t insn)
2476 {
2477 int cpn = (insn >> 16) & 0xf;
2478 int cpm = insn & 0xf;
2479 int op = ((insn >> 5) & 7) | ((insn >> 18) & 0x38);
2480
2481 if (arm_feature(env, ARM_FEATURE_V7) && cpn == 9) {
2482 /* Performance monitor registers fall into three categories:
2483 * (a) always UNDEF in usermode
2484 * (b) UNDEF only if PMUSERENR.EN is 0
2485 * (c) always read OK and UNDEF on write (PMUSERENR only)
2486 */
2487 if ((cpm == 12 && (op < 6)) ||
2488 (cpm == 13 && (op < 3))) {
2489 return env->cp15.c9_pmuserenr;
2490 } else if (cpm == 14 && op == 0 && (insn & ARM_CP_RW_BIT)) {
2491 /* PMUSERENR, read only */
2492 return 1;
2493 }
2494 return 0;
2495 }
2496
2497 if (cpn == 13 && cpm == 0) {
2498 /* TLS register. */
2499 if (op == 2 || (op == 3 && (insn & ARM_CP_RW_BIT)))
2500 return 1;
2501 }
2502 return 0;
2503 }
2504
2505 static int cp15_tls_load_store(CPUARMState *env, DisasContext *s, uint32_t insn, uint32_t rd)
2506 {
2507 TCGv tmp;
2508 int cpn = (insn >> 16) & 0xf;
2509 int cpm = insn & 0xf;
2510 int op = ((insn >> 5) & 7) | ((insn >> 18) & 0x38);
2511
2512 if (!arm_feature(env, ARM_FEATURE_V6K))
2513 return 0;
2514
2515 if (!(cpn == 13 && cpm == 0))
2516 return 0;
2517
2518 if (insn & ARM_CP_RW_BIT) {
2519 switch (op) {
2520 case 2:
2521 tmp = load_cpu_field(cp15.c13_tls1);
2522 break;
2523 case 3:
2524 tmp = load_cpu_field(cp15.c13_tls2);
2525 break;
2526 case 4:
2527 tmp = load_cpu_field(cp15.c13_tls3);
2528 break;
2529 default:
2530 return 0;
2531 }
2532 store_reg(s, rd, tmp);
2533
2534 } else {
2535 tmp = load_reg(s, rd);
2536 switch (op) {
2537 case 2:
2538 store_cpu_field(tmp, cp15.c13_tls1);
2539 break;
2540 case 3:
2541 store_cpu_field(tmp, cp15.c13_tls2);
2542 break;
2543 case 4:
2544 store_cpu_field(tmp, cp15.c13_tls3);
2545 break;
2546 default:
2547 tcg_temp_free_i32(tmp);
2548 return 0;
2549 }
2550 }
2551 return 1;
2552 }
2553
2554 /* Disassemble system coprocessor (cp15) instruction. Return nonzero if
2555 instruction is not defined. */
2556 static int disas_cp15_insn(CPUARMState *env, DisasContext *s, uint32_t insn)
2557 {
2558 uint32_t rd;
2559 TCGv tmp, tmp2;
2560
2561 /* M profile cores use memory mapped registers instead of cp15. */
2562 if (arm_feature(env, ARM_FEATURE_M))
2563 return 1;
2564
2565 if ((insn & (1 << 25)) == 0) {
2566 if (insn & (1 << 20)) {
2567 /* mrrc */
2568 return 1;
2569 }
2570 /* mcrr. Used for block cache operations, so implement as no-op. */
2571 return 0;
2572 }
2573 if ((insn & (1 << 4)) == 0) {
2574 /* cdp */
2575 return 1;
2576 }
2577 /* We special case a number of cp15 instructions which were used
2578 * for things which are real instructions in ARMv7. This allows
2579 * them to work in linux-user mode which doesn't provide functional
2580 * get_cp15/set_cp15 helpers, and is more efficient anyway.
2581 */
2582 switch ((insn & 0x0fff0fff)) {
2583 case 0x0e070f90:
2584 /* 0,c7,c0,4: Standard v6 WFI (also used in some pre-v6 cores).
2585 * In v7, this must NOP.
2586 */
2587 if (IS_USER(s)) {
2588 return 1;
2589 }
2590 if (!arm_feature(env, ARM_FEATURE_V7)) {
2591 /* Wait for interrupt. */
2592 gen_set_pc_im(s->pc);
2593 s->is_jmp = DISAS_WFI;
2594 }
2595 return 0;
2596 case 0x0e070f58:
2597 /* 0,c7,c8,2: Not all pre-v6 cores implemented this WFI,
2598 * so this is slightly over-broad.
2599 */
2600 if (!IS_USER(s) && !arm_feature(env, ARM_FEATURE_V6)) {
2601 /* Wait for interrupt. */
2602 gen_set_pc_im(s->pc);
2603 s->is_jmp = DISAS_WFI;
2604 return 0;
2605 }
2606 /* Otherwise continue to handle via helper function.
2607 * In particular, on v7 and some v6 cores this is one of
2608 * the VA-PA registers.
2609 */
2610 break;
2611 case 0x0e070f3d:
2612 /* 0,c7,c13,1: prefetch-by-MVA in v6, NOP in v7 */
2613 if (arm_feature(env, ARM_FEATURE_V6)) {
2614 return IS_USER(s) ? 1 : 0;
2615 }
2616 break;
2617 case 0x0e070f95: /* 0,c7,c5,4 : ISB */
2618 case 0x0e070f9a: /* 0,c7,c10,4: DSB */
2619 case 0x0e070fba: /* 0,c7,c10,5: DMB */
2620 /* Barriers in both v6 and v7 */
2621 if (arm_feature(env, ARM_FEATURE_V6)) {
2622 return 0;
2623 }
2624 break;
2625 default:
2626 break;
2627 }
2628
2629 if (IS_USER(s) && !cp15_user_ok(env, insn)) {
2630 return 1;
2631 }
2632
2633 rd = (insn >> 12) & 0xf;
2634
2635 if (cp15_tls_load_store(env, s, insn, rd))
2636 return 0;
2637
2638 tmp2 = tcg_const_i32(insn);
2639 if (insn & ARM_CP_RW_BIT) {
2640 tmp = tcg_temp_new_i32();
2641 gen_helper_get_cp15(tmp, cpu_env, tmp2);
2642 /* If the destination register is r15 then sets condition codes. */
2643 if (rd != 15)
2644 store_reg(s, rd, tmp);
2645 else
2646 tcg_temp_free_i32(tmp);
2647 } else {
2648 tmp = load_reg(s, rd);
2649 gen_helper_set_cp15(cpu_env, tmp2, tmp);
2650 tcg_temp_free_i32(tmp);
2651 /* Normally we would always end the TB here, but Linux
2652 * arch/arm/mach-pxa/sleep.S expects two instructions following
2653 * an MMU enable to execute from cache. Imitate this behaviour. */
2654 if (!arm_feature(env, ARM_FEATURE_XSCALE) ||
2655 (insn & 0x0fff0fff) != 0x0e010f10)
2656 gen_lookup_tb(s);
2657 }
2658 tcg_temp_free_i32(tmp2);
2659 return 0;
2660 }
2661
2662 #define VFP_REG_SHR(x, n) (((n) > 0) ? (x) >> (n) : (x) << -(n))
2663 #define VFP_SREG(insn, bigbit, smallbit) \
2664 ((VFP_REG_SHR(insn, bigbit - 1) & 0x1e) | (((insn) >> (smallbit)) & 1))
2665 #define VFP_DREG(reg, insn, bigbit, smallbit) do { \
2666 if (arm_feature(env, ARM_FEATURE_VFP3)) { \
2667 reg = (((insn) >> (bigbit)) & 0x0f) \
2668 | (((insn) >> ((smallbit) - 4)) & 0x10); \
2669 } else { \
2670 if (insn & (1 << (smallbit))) \
2671 return 1; \
2672 reg = ((insn) >> (bigbit)) & 0x0f; \
2673 }} while (0)
2674
2675 #define VFP_SREG_D(insn) VFP_SREG(insn, 12, 22)
2676 #define VFP_DREG_D(reg, insn) VFP_DREG(reg, insn, 12, 22)
2677 #define VFP_SREG_N(insn) VFP_SREG(insn, 16, 7)
2678 #define VFP_DREG_N(reg, insn) VFP_DREG(reg, insn, 16, 7)
2679 #define VFP_SREG_M(insn) VFP_SREG(insn, 0, 5)
2680 #define VFP_DREG_M(reg, insn) VFP_DREG(reg, insn, 0, 5)
2681
2682 /* Move between integer and VFP cores. */
2683 static TCGv gen_vfp_mrs(void)
2684 {
2685 TCGv tmp = tcg_temp_new_i32();
2686 tcg_gen_mov_i32(tmp, cpu_F0s);
2687 return tmp;
2688 }
2689
2690 static void gen_vfp_msr(TCGv tmp)
2691 {
2692 tcg_gen_mov_i32(cpu_F0s, tmp);
2693 tcg_temp_free_i32(tmp);
2694 }
2695
2696 static void gen_neon_dup_u8(TCGv var, int shift)
2697 {
2698 TCGv tmp = tcg_temp_new_i32();
2699 if (shift)
2700 tcg_gen_shri_i32(var, var, shift);
2701 tcg_gen_ext8u_i32(var, var);
2702 tcg_gen_shli_i32(tmp, var, 8);
2703 tcg_gen_or_i32(var, var, tmp);
2704 tcg_gen_shli_i32(tmp, var, 16);
2705 tcg_gen_or_i32(var, var, tmp);
2706 tcg_temp_free_i32(tmp);
2707 }
2708
2709 static void gen_neon_dup_low16(TCGv var)
2710 {
2711 TCGv tmp = tcg_temp_new_i32();
2712 tcg_gen_ext16u_i32(var, var);
2713 tcg_gen_shli_i32(tmp, var, 16);
2714 tcg_gen_or_i32(var, var, tmp);
2715 tcg_temp_free_i32(tmp);
2716 }
2717
2718 static void gen_neon_dup_high16(TCGv var)
2719 {
2720 TCGv tmp = tcg_temp_new_i32();
2721 tcg_gen_andi_i32(var, var, 0xffff0000);
2722 tcg_gen_shri_i32(tmp, var, 16);
2723 tcg_gen_or_i32(var, var, tmp);
2724 tcg_temp_free_i32(tmp);
2725 }
2726
2727 static TCGv gen_load_and_replicate(DisasContext *s, TCGv addr, int size)
2728 {
2729 /* Load a single Neon element and replicate into a 32 bit TCG reg */
2730 TCGv tmp;
2731 switch (size) {
2732 case 0:
2733 tmp = gen_ld8u(addr, IS_USER(s));
2734 gen_neon_dup_u8(tmp, 0);
2735 break;
2736 case 1:
2737 tmp = gen_ld16u(addr, IS_USER(s));
2738 gen_neon_dup_low16(tmp);
2739 break;
2740 case 2:
2741 tmp = gen_ld32(addr, IS_USER(s));
2742 break;
2743 default: /* Avoid compiler warnings. */
2744 abort();
2745 }
2746 return tmp;
2747 }
2748
2749 /* Disassemble a VFP instruction. Returns nonzero if an error occurred
2750 (ie. an undefined instruction). */
2751 static int disas_vfp_insn(CPUARMState * env, DisasContext *s, uint32_t insn)
2752 {
2753 uint32_t rd, rn, rm, op, i, n, offset, delta_d, delta_m, bank_mask;
2754 int dp, veclen;
2755 TCGv addr;
2756 TCGv tmp;
2757 TCGv tmp2;
2758
2759 if (!arm_feature(env, ARM_FEATURE_VFP))
2760 return 1;
2761
2762 if (!s->vfp_enabled) {
2763 /* VFP disabled. Only allow fmxr/fmrx to/from some control regs. */
2764 if ((insn & 0x0fe00fff) != 0x0ee00a10)
2765 return 1;
2766 rn = (insn >> 16) & 0xf;
2767 if (rn != ARM_VFP_FPSID && rn != ARM_VFP_FPEXC
2768 && rn != ARM_VFP_MVFR1 && rn != ARM_VFP_MVFR0)
2769 return 1;
2770 }
2771 dp = ((insn & 0xf00) == 0xb00);
2772 switch ((insn >> 24) & 0xf) {
2773 case 0xe:
2774 if (insn & (1 << 4)) {
2775 /* single register transfer */
2776 rd = (insn >> 12) & 0xf;
2777 if (dp) {
2778 int size;
2779 int pass;
2780
2781 VFP_DREG_N(rn, insn);
2782 if (insn & 0xf)
2783 return 1;
2784 if (insn & 0x00c00060
2785 && !arm_feature(env, ARM_FEATURE_NEON))
2786 return 1;
2787
2788 pass = (insn >> 21) & 1;
2789 if (insn & (1 << 22)) {
2790 size = 0;
2791 offset = ((insn >> 5) & 3) * 8;
2792 } else if (insn & (1 << 5)) {
2793 size = 1;
2794 offset = (insn & (1 << 6)) ? 16 : 0;
2795 } else {
2796 size = 2;
2797 offset = 0;
2798 }
2799 if (insn & ARM_CP_RW_BIT) {
2800 /* vfp->arm */
2801 tmp = neon_load_reg(rn, pass);
2802 switch (size) {
2803 case 0:
2804 if (offset)
2805 tcg_gen_shri_i32(tmp, tmp, offset);
2806 if (insn & (1 << 23))
2807 gen_uxtb(tmp);
2808 else
2809 gen_sxtb(tmp);
2810 break;
2811 case 1:
2812 if (insn & (1 << 23)) {
2813 if (offset) {
2814 tcg_gen_shri_i32(tmp, tmp, 16);
2815 } else {
2816 gen_uxth(tmp);
2817 }
2818 } else {
2819 if (offset) {
2820 tcg_gen_sari_i32(tmp, tmp, 16);
2821 } else {
2822 gen_sxth(tmp);
2823 }
2824 }
2825 break;
2826 case 2:
2827 break;
2828 }
2829 store_reg(s, rd, tmp);
2830 } else {
2831 /* arm->vfp */
2832 tmp = load_reg(s, rd);
2833 if (insn & (1 << 23)) {
2834 /* VDUP */
2835 if (size == 0) {
2836 gen_neon_dup_u8(tmp, 0);
2837 } else if (size == 1) {
2838 gen_neon_dup_low16(tmp);
2839 }
2840 for (n = 0; n <= pass * 2; n++) {
2841 tmp2 = tcg_temp_new_i32();
2842 tcg_gen_mov_i32(tmp2, tmp);
2843 neon_store_reg(rn, n, tmp2);
2844 }
2845 neon_store_reg(rn, n, tmp);
2846 } else {
2847 /* VMOV */
2848 switch (size) {
2849 case 0:
2850 tmp2 = neon_load_reg(rn, pass);
2851 gen_bfi(tmp, tmp2, tmp, offset, 0xff);
2852 tcg_temp_free_i32(tmp2);
2853 break;
2854 case 1:
2855 tmp2 = neon_load_reg(rn, pass);
2856 gen_bfi(tmp, tmp2, tmp, offset, 0xffff);
2857 tcg_temp_free_i32(tmp2);
2858 break;
2859 case 2:
2860 break;
2861 }
2862 neon_store_reg(rn, pass, tmp);
2863 }
2864 }
2865 } else { /* !dp */
2866 if ((insn & 0x6f) != 0x00)
2867 return 1;
2868 rn = VFP_SREG_N(insn);
2869 if (insn & ARM_CP_RW_BIT) {
2870 /* vfp->arm */
2871 if (insn & (1 << 21)) {
2872 /* system register */
2873 rn >>= 1;
2874
2875 switch (rn) {
2876 case ARM_VFP_FPSID:
2877 /* VFP2 allows access to FSID from userspace.
2878 VFP3 restricts all id registers to privileged
2879 accesses. */
2880 if (IS_USER(s)
2881 && arm_feature(env, ARM_FEATURE_VFP3))
2882 return 1;
2883 tmp = load_cpu_field(vfp.xregs[rn]);
2884 break;
2885 case ARM_VFP_FPEXC:
2886 if (IS_USER(s))
2887 return 1;
2888 tmp = load_cpu_field(vfp.xregs[rn]);
2889 break;
2890 case ARM_VFP_FPINST:
2891 case ARM_VFP_FPINST2:
2892 /* Not present in VFP3. */
2893 if (IS_USER(s)
2894 || arm_feature(env, ARM_FEATURE_VFP3))
2895 return 1;
2896 tmp = load_cpu_field(vfp.xregs[rn]);
2897 break;
2898 case ARM_VFP_FPSCR:
2899 if (rd == 15) {
2900 tmp = load_cpu_field(vfp.xregs[ARM_VFP_FPSCR]);
2901 tcg_gen_andi_i32(tmp, tmp, 0xf0000000);
2902 } else {
2903 tmp = tcg_temp_new_i32();
2904 gen_helper_vfp_get_fpscr(tmp, cpu_env);
2905 }
2906 break;
2907 case ARM_VFP_MVFR0:
2908 case ARM_VFP_MVFR1:
2909 if (IS_USER(s)
2910 || !arm_feature(env, ARM_FEATURE_MVFR))
2911 return 1;
2912 tmp = load_cpu_field(vfp.xregs[rn]);
2913 break;
2914 default:
2915 return 1;
2916 }
2917 } else {
2918 gen_mov_F0_vreg(0, rn);
2919 tmp = gen_vfp_mrs();
2920 }
2921 if (rd == 15) {
2922 /* Set the 4 flag bits in the CPSR. */
2923 gen_set_nzcv(tmp);
2924 tcg_temp_free_i32(tmp);
2925 } else {
2926 store_reg(s, rd, tmp);
2927 }
2928 } else {
2929 /* arm->vfp */
2930 tmp = load_reg(s, rd);
2931 if (insn & (1 << 21)) {
2932 rn >>= 1;
2933 /* system register */
2934 switch (rn) {
2935 case ARM_VFP_FPSID:
2936 case ARM_VFP_MVFR0:
2937 case ARM_VFP_MVFR1:
2938 /* Writes are ignored. */
2939 break;
2940 case ARM_VFP_FPSCR:
2941 gen_helper_vfp_set_fpscr(cpu_env, tmp);
2942 tcg_temp_free_i32(tmp);
2943 gen_lookup_tb(s);
2944 break;
2945 case ARM_VFP_FPEXC:
2946 if (IS_USER(s))
2947 return 1;
2948 /* TODO: VFP subarchitecture support.
2949 * For now, keep the EN bit only */
2950 tcg_gen_andi_i32(tmp, tmp, 1 << 30);
2951 store_cpu_field(tmp, vfp.xregs[rn]);
2952 gen_lookup_tb(s);
2953 break;
2954 case ARM_VFP_FPINST:
2955 case ARM_VFP_FPINST2:
2956 store_cpu_field(tmp, vfp.xregs[rn]);
2957 break;
2958 default:
2959 return 1;
2960 }
2961 } else {
2962 gen_vfp_msr(tmp);
2963 gen_mov_vreg_F0(0, rn);
2964 }
2965 }
2966 }
2967 } else {
2968 /* data processing */
2969 /* The opcode is in bits 23, 21, 20 and 6. */
2970 op = ((insn >> 20) & 8) | ((insn >> 19) & 6) | ((insn >> 6) & 1);
2971 if (dp) {
2972 if (op == 15) {
2973 /* rn is opcode */
2974 rn = ((insn >> 15) & 0x1e) | ((insn >> 7) & 1);
2975 } else {
2976 /* rn is register number */
2977 VFP_DREG_N(rn, insn);
2978 }
2979
2980 if (op == 15 && (rn == 15 || ((rn & 0x1c) == 0x18))) {
2981 /* Integer or single precision destination. */
2982 rd = VFP_SREG_D(insn);
2983 } else {
2984 VFP_DREG_D(rd, insn);
2985 }
2986 if (op == 15 &&
2987 (((rn & 0x1c) == 0x10) || ((rn & 0x14) == 0x14))) {
2988 /* VCVT from int is always from S reg regardless of dp bit.
2989 * VCVT with immediate frac_bits has same format as SREG_M
2990 */
2991 rm = VFP_SREG_M(insn);
2992 } else {
2993 VFP_DREG_M(rm, insn);
2994 }
2995 } else {
2996 rn = VFP_SREG_N(insn);
2997 if (op == 15 && rn == 15) {
2998 /* Double precision destination. */
2999 VFP_DREG_D(rd, insn);
3000 } else {
3001 rd = VFP_SREG_D(insn);
3002 }
3003 /* NB that we implicitly rely on the encoding for the frac_bits
3004 * in VCVT of fixed to float being the same as that of an SREG_M
3005 */
3006 rm = VFP_SREG_M(insn);
3007 }
3008
3009 veclen = s->vec_len;
3010 if (op == 15 && rn > 3)
3011 veclen = 0;
3012
3013 /* Shut up compiler warnings. */
3014 delta_m = 0;
3015 delta_d = 0;
3016 bank_mask = 0;
3017
3018 if (veclen > 0) {
3019 if (dp)
3020 bank_mask = 0xc;
3021 else
3022 bank_mask = 0x18;
3023
3024 /* Figure out what type of vector operation this is. */
3025 if ((rd & bank_mask) == 0) {
3026 /* scalar */
3027 veclen = 0;
3028 } else {
3029 if (dp)
3030 delta_d = (s->vec_stride >> 1) + 1;
3031 else
3032 delta_d = s->vec_stride + 1;
3033
3034 if ((rm & bank_mask) == 0) {
3035 /* mixed scalar/vector */
3036 delta_m = 0;
3037 } else {
3038 /* vector */
3039 delta_m = delta_d;
3040 }
3041 }
3042 }
3043
3044 /* Load the initial operands. */
3045 if (op == 15) {
3046 switch (rn) {
3047 case 16:
3048 case 17:
3049 /* Integer source */
3050 gen_mov_F0_vreg(0, rm);
3051 break;
3052 case 8:
3053 case 9:
3054 /* Compare */
3055 gen_mov_F0_vreg(dp, rd);
3056 gen_mov_F1_vreg(dp, rm);
3057 break;
3058 case 10:
3059 case 11:
3060 /* Compare with zero */
3061 gen_mov_F0_vreg(dp, rd);
3062 gen_vfp_F1_ld0(dp);
3063 break;
3064 case 20:
3065 case 21:
3066 case 22:
3067 case 23:
3068 case 28:
3069 case 29:
3070 case 30:
3071 case 31:
3072 /* Source and destination the same. */
3073 gen_mov_F0_vreg(dp, rd);
3074 break;
3075 case 4:
3076 case 5:
3077 case 6:
3078 case 7:
3079 /* VCVTB, VCVTT: only present with the halfprec extension,
3080 * UNPREDICTABLE if bit 8 is set (we choose to UNDEF)
3081 */
3082 if (dp || !arm_feature(env, ARM_FEATURE_VFP_FP16)) {
3083 return 1;
3084 }
3085 /* Otherwise fall through */
3086 default:
3087 /* One source operand. */
3088 gen_mov_F0_vreg(dp, rm);
3089 break;
3090 }
3091 } else {
3092 /* Two source operands. */
3093 gen_mov_F0_vreg(dp, rn);
3094 gen_mov_F1_vreg(dp, rm);
3095 }
3096
3097 for (;;) {
3098 /* Perform the calculation. */
3099 switch (op) {
3100 case 0: /* VMLA: fd + (fn * fm) */
3101 /* Note that order of inputs to the add matters for NaNs */
3102 gen_vfp_F1_mul(dp);
3103 gen_mov_F0_vreg(dp, rd);
3104 gen_vfp_add(dp);
3105 break;
3106 case 1: /* VMLS: fd + -(fn * fm) */
3107 gen_vfp_mul(dp);
3108 gen_vfp_F1_neg(dp);
3109 gen_mov_F0_vreg(dp, rd);
3110 gen_vfp_add(dp);
3111 break;
3112 case 2: /* VNMLS: -fd + (fn * fm) */
3113 /* Note that it isn't valid to replace (-A + B) with (B - A)
3114 * or similar plausible looking simplifications
3115 * because this will give wrong results for NaNs.
3116 */
3117 gen_vfp_F1_mul(dp);
3118 gen_mov_F0_vreg(dp, rd);
3119 gen_vfp_neg(dp);
3120 gen_vfp_add(dp);
3121 break;
3122 case 3: /* VNMLA: -fd + -(fn * fm) */
3123 gen_vfp_mul(dp);
3124 gen_vfp_F1_neg(dp);
3125 gen_mov_F0_vreg(dp, rd);
3126 gen_vfp_neg(dp);
3127 gen_vfp_add(dp);
3128 break;
3129 case 4: /* mul: fn * fm */
3130 gen_vfp_mul(dp);
3131 break;
3132 case 5: /* nmul: -(fn * fm) */
3133 gen_vfp_mul(dp);
3134 gen_vfp_neg(dp);
3135 break;
3136 case 6: /* add: fn + fm */
3137 gen_vfp_add(dp);
3138 break;
3139 case 7: /* sub: fn - fm */
3140 gen_vfp_sub(dp);
3141 break;
3142 case 8: /* div: fn / fm */
3143 gen_vfp_div(dp);
3144 break;
3145 case 10: /* VFNMA : fd = muladd(-fd, fn, fm) */
3146 case 11: /* VFNMS : fd = muladd(-fd, -fn, fm) */
3147 case 12: /* VFMA : fd = muladd( fd, fn, fm) */
3148 case 13: /* VFMS : fd = muladd( fd, -fn, fm) */
3149 /* These are fused multiply-add, and must be done as one
3150 * floating point operation with no rounding between the
3151 * multiplication and addition steps.
3152 * NB that doing the negations here as separate steps is
3153 * correct : an input NaN should come out with its sign bit
3154 * flipped if it is a negated-input.
3155 */
3156 if (!arm_feature(env, ARM_FEATURE_VFP4)) {
3157 return 1;
3158 }
3159 if (dp) {
3160 TCGv_ptr fpst;
3161 TCGv_i64 frd;
3162 if (op & 1) {
3163 /* VFNMS, VFMS */
3164 gen_helper_vfp_negd(cpu_F0d, cpu_F0d);
3165 }
3166 frd = tcg_temp_new_i64();
3167 tcg_gen_ld_f64(frd, cpu_env, vfp_reg_offset(dp, rd));
3168 if (op & 2) {
3169 /* VFNMA, VFNMS */
3170 gen_helper_vfp_negd(frd, frd);
3171 }
3172 fpst = get_fpstatus_ptr(0);
3173 gen_helper_vfp_muladdd(cpu_F0d, cpu_F0d,
3174 cpu_F1d, frd, fpst);
3175 tcg_temp_free_ptr(fpst);
3176 tcg_temp_free_i64(frd);
3177 } else {
3178 TCGv_ptr fpst;
3179 TCGv_i32 frd;
3180 if (op & 1) {
3181 /* VFNMS, VFMS */
3182 gen_helper_vfp_negs(cpu_F0s, cpu_F0s);
3183 }
3184 frd = tcg_temp_new_i32();
3185 tcg_gen_ld_f32(frd, cpu_env, vfp_reg_offset(dp, rd));
3186 if (op & 2) {
3187 gen_helper_vfp_negs(frd, frd);
3188 }
3189 fpst = get_fpstatus_ptr(0);
3190 gen_helper_vfp_muladds(cpu_F0s, cpu_F0s,
3191 cpu_F1s, frd, fpst);
3192 tcg_temp_free_ptr(fpst);
3193 tcg_temp_free_i32(frd);
3194 }
3195 break;
3196 case 14: /* fconst */
3197 if (!arm_feature(env, ARM_FEATURE_VFP3))
3198 return 1;
3199
3200 n = (insn << 12) & 0x80000000;
3201 i = ((insn >> 12) & 0x70) | (insn & 0xf);
3202 if (dp) {
3203 if (i & 0x40)
3204 i |= 0x3f80;
3205 else
3206 i |= 0x4000;
3207 n |= i << 16;
3208 tcg_gen_movi_i64(cpu_F0d, ((uint64_t)n) << 32);
3209 } else {
3210 if (i & 0x40)
3211 i |= 0x780;
3212 else
3213 i |= 0x800;
3214 n |= i << 19;
3215 tcg_gen_movi_i32(cpu_F0s, n);
3216 }
3217 break;
3218 case 15: /* extension space */
3219 switch (rn) {
3220 case 0: /* cpy */
3221 /* no-op */
3222 break;
3223 case 1: /* abs */
3224 gen_vfp_abs(dp);
3225 break;
3226 case 2: /* neg */
3227 gen_vfp_neg(dp);
3228 break;
3229 case 3: /* sqrt */
3230 gen_vfp_sqrt(dp);
3231 break;
3232 case 4: /* vcvtb.f32.f16 */
3233 tmp = gen_vfp_mrs();
3234 tcg_gen_ext16u_i32(tmp, tmp);
3235 gen_helper_vfp_fcvt_f16_to_f32(cpu_F0s, tmp, cpu_env);
3236 tcg_temp_free_i32(tmp);
3237 break;
3238 case 5: /* vcvtt.f32.f16 */
3239 tmp = gen_vfp_mrs();
3240 tcg_gen_shri_i32(tmp, tmp, 16);
3241 gen_helper_vfp_fcvt_f16_to_f32(cpu_F0s, tmp, cpu_env);
3242 tcg_temp_free_i32(tmp);
3243 break;
3244 case 6: /* vcvtb.f16.f32 */
3245 tmp = tcg_temp_new_i32();
3246 gen_helper_vfp_fcvt_f32_to_f16(tmp, cpu_F0s, cpu_env);
3247 gen_mov_F0_vreg(0, rd);
3248 tmp2 = gen_vfp_mrs();
3249 tcg_gen_andi_i32(tmp2, tmp2, 0xffff0000);
3250 tcg_gen_or_i32(tmp, tmp, tmp2);
3251 tcg_temp_free_i32(tmp2);
3252 gen_vfp_msr(tmp);
3253 break;
3254 case 7: /* vcvtt.f16.f32 */
3255 tmp = tcg_temp_new_i32();
3256 gen_helper_vfp_fcvt_f32_to_f16(tmp, cpu_F0s, cpu_env);
3257 tcg_gen_shli_i32(tmp, tmp, 16);
3258 gen_mov_F0_vreg(0, rd);
3259 tmp2 = gen_vfp_mrs();
3260 tcg_gen_ext16u_i32(tmp2, tmp2);
3261 tcg_gen_or_i32(tmp, tmp, tmp2);
3262 tcg_temp_free_i32(tmp2);
3263 gen_vfp_msr(tmp);
3264 break;
3265 case 8: /* cmp */
3266 gen_vfp_cmp(dp);
3267 break;
3268 case 9: /* cmpe */
3269 gen_vfp_cmpe(dp);
3270 break;
3271 case 10: /* cmpz */
3272 gen_vfp_cmp(dp);
3273 break;
3274 case 11: /* cmpez */
3275 gen_vfp_F1_ld0(dp);
3276 gen_vfp_cmpe(dp);
3277 break;
3278 case 15: /* single<->double conversion */
3279 if (dp)
3280 gen_helper_vfp_fcvtsd(cpu_F0s, cpu_F0d, cpu_env);
3281 else
3282 gen_helper_vfp_fcvtds(cpu_F0d, cpu_F0s, cpu_env);
3283 break;
3284 case 16: /* fuito */
3285 gen_vfp_uito(dp, 0);
3286 break;
3287 case 17: /* fsito */
3288 gen_vfp_sito(dp, 0);
3289 break;
3290 case 20: /* fshto */
3291 if (!arm_feature(env, ARM_FEATURE_VFP3))
3292 return 1;
3293 gen_vfp_shto(dp, 16 - rm, 0);
3294 break;
3295 case 21: /* fslto */
3296 if (!arm_feature(env, ARM_FEATURE_VFP3))
3297 return 1;
3298 gen_vfp_slto(dp, 32 - rm, 0);
3299 break;
3300 case 22: /* fuhto */
3301 if (!arm_feature(env, ARM_FEATURE_VFP3))
3302 return 1;
3303 gen_vfp_uhto(dp, 16 - rm, 0);
3304 break;
3305 case 23: /* fulto */
3306 if (!arm_feature(env, ARM_FEATURE_VFP3))
3307 return 1;
3308 gen_vfp_ulto(dp, 32 - rm, 0);
3309 break;
3310 case 24: /* ftoui */
3311 gen_vfp_toui(dp, 0);
3312 break;
3313 case 25: /* ftouiz */
3314 gen_vfp_touiz(dp, 0);
3315 break;
3316 case 26: /* ftosi */
3317 gen_vfp_tosi(dp, 0);
3318 break;
3319 case 27: /* ftosiz */
3320 gen_vfp_tosiz(dp, 0);
3321 break;
3322 case 28: /* ftosh */
3323 if (!arm_feature(env, ARM_FEATURE_VFP3))
3324 return 1;
3325 gen_vfp_tosh(dp, 16 - rm, 0);
3326 break;
3327 case 29: /* ftosl */
3328 if (!arm_feature(env, ARM_FEATURE_VFP3))
3329 return 1;
3330 gen_vfp_tosl(dp, 32 - rm, 0);
3331 break;
3332 case 30: /* ftouh */
3333 if (!arm_feature(env, ARM_FEATURE_VFP3))
3334 return 1;
3335 gen_vfp_touh(dp, 16 - rm, 0);
3336 break;
3337 case 31: /* ftoul */
3338 if (!arm_feature(env, ARM_FEATURE_VFP3))
3339 return 1;
3340 gen_vfp_toul(dp, 32 - rm, 0);
3341 break;
3342 default: /* undefined */
3343 return 1;
3344 }
3345 break;
3346 default: /* undefined */
3347 return 1;
3348 }
3349
3350 /* Write back the result. */
3351 if (op == 15 && (rn >= 8 && rn <= 11))
3352 ; /* Comparison, do nothing. */
3353 else if (op == 15 && dp && ((rn & 0x1c) == 0x18))
3354 /* VCVT double to int: always integer result. */
3355 gen_mov_vreg_F0(0, rd);
3356 else if (op == 15 && rn == 15)
3357 /* conversion */
3358 gen_mov_vreg_F0(!dp, rd);
3359 else
3360 gen_mov_vreg_F0(dp, rd);
3361
3362 /* break out of the loop if we have finished */
3363 if (veclen == 0)
3364 break;
3365
3366 if (op == 15 && delta_m == 0) {
3367 /* single source one-many */
3368 while (veclen--) {
3369 rd = ((rd + delta_d) & (bank_mask - 1))
3370 | (rd & bank_mask);
3371 gen_mov_vreg_F0(dp, rd);
3372 }
3373 break;
3374 }
3375 /* Setup the next operands. */
3376 veclen--;
3377 rd = ((rd + delta_d) & (bank_mask - 1))
3378 | (rd & bank_mask);
3379
3380 if (op == 15) {
3381 /* One source operand. */
3382 rm = ((rm + delta_m) & (bank_mask - 1))
3383 | (rm & bank_mask);
3384 gen_mov_F0_vreg(dp, rm);
3385 } else {
3386 /* Two source operands. */
3387 rn = ((rn + delta_d) & (bank_mask - 1))
3388 | (rn & bank_mask);
3389 gen_mov_F0_vreg(dp, rn);
3390 if (delta_m) {
3391 rm = ((rm + delta_m) & (bank_mask - 1))
3392 | (rm & bank_mask);
3393 gen_mov_F1_vreg(dp, rm);
3394 }
3395 }
3396 }
3397 }
3398 break;
3399 case 0xc:
3400 case 0xd:
3401 if ((insn & 0x03e00000) == 0x00400000) {
3402 /* two-register transfer */
3403 rn = (insn >> 16) & 0xf;
3404 rd = (insn >> 12) & 0xf;
3405 if (dp) {
3406 VFP_DREG_M(rm, insn);
3407 } else {
3408 rm = VFP_SREG_M(insn);
3409 }
3410
3411 if (insn & ARM_CP_RW_BIT) {
3412 /* vfp->arm */
3413 if (dp) {
3414 gen_mov_F0_vreg(0, rm * 2);
3415 tmp = gen_vfp_mrs();
3416 store_reg(s, rd, tmp);
3417 gen_mov_F0_vreg(0, rm * 2 + 1);
3418 tmp = gen_vfp_mrs();
3419 store_reg(s, rn, tmp);
3420 } else {
3421 gen_mov_F0_vreg(0, rm);
3422 tmp = gen_vfp_mrs();
3423 store_reg(s, rd, tmp);
3424 gen_mov_F0_vreg(0, rm + 1);
3425 tmp = gen_vfp_mrs();
3426 store_reg(s, rn, tmp);
3427 }
3428 } else {
3429 /* arm->vfp */
3430 if (dp) {
3431 tmp = load_reg(s, rd);
3432 gen_vfp_msr(tmp);
3433 gen_mov_vreg_F0(0, rm * 2);
3434 tmp = load_reg(s, rn);
3435 gen_vfp_msr(tmp);
3436 gen_mov_vreg_F0(0, rm * 2 + 1);
3437 } else {
3438 tmp = load_reg(s, rd);
3439 gen_vfp_msr(tmp);
3440 gen_mov_vreg_F0(0, rm);
3441 tmp = load_reg(s, rn);
3442 gen_vfp_msr(tmp);
3443 gen_mov_vreg_F0(0, rm + 1);
3444 }
3445 }
3446 } else {
3447 /* Load/store */
3448 rn = (insn >> 16) & 0xf;
3449 if (dp)
3450 VFP_DREG_D(rd, insn);
3451 else
3452 rd = VFP_SREG_D(insn);
3453 if ((insn & 0x01200000) == 0x01000000) {
3454 /* Single load/store */
3455 offset = (insn & 0xff) << 2;
3456 if ((insn & (1 << 23)) == 0)
3457 offset = -offset;
3458 if (s->thumb && rn == 15) {
3459 /* This is actually UNPREDICTABLE */
3460 addr = tcg_temp_new_i32();
3461 tcg_gen_movi_i32(addr, s->pc & ~2);
3462 } else {
3463 addr = load_reg(s, rn);
3464 }
3465 tcg_gen_addi_i32(addr, addr, offset);
3466 if (insn & (1 << 20)) {
3467 gen_vfp_ld(s, dp, addr);
3468 gen_mov_vreg_F0(dp, rd);
3469 } else {
3470 gen_mov_F0_vreg(dp, rd);
3471 gen_vfp_st(s, dp, addr);
3472 }
3473 tcg_temp_free_i32(addr);
3474 } else {
3475 /* load/store multiple */
3476 int w = insn & (1 << 21);
3477 if (dp)
3478 n = (insn >> 1) & 0x7f;
3479 else
3480 n = insn & 0xff;
3481
3482 if (w && !(((insn >> 23) ^ (insn >> 24)) & 1)) {
3483 /* P == U , W == 1 => UNDEF */
3484 return 1;
3485 }
3486 if (n == 0 || (rd + n) > 32 || (dp && n > 16)) {
3487 /* UNPREDICTABLE cases for bad immediates: we choose to
3488 * UNDEF to avoid generating huge numbers of TCG ops
3489 */
3490 return 1;
3491 }
3492 if (rn == 15 && w) {
3493 /* writeback to PC is UNPREDICTABLE, we choose to UNDEF */
3494 return 1;
3495 }
3496
3497 if (s->thumb && rn == 15) {
3498 /* This is actually UNPREDICTABLE */
3499 addr = tcg_temp_new_i32();
3500 tcg_gen_movi_i32(addr, s->pc & ~2);
3501 } else {
3502 addr = load_reg(s, rn);
3503 }
3504 if (insn & (1 << 24)) /* pre-decrement */
3505 tcg_gen_addi_i32(addr, addr, -((insn & 0xff) << 2));
3506
3507 if (dp)
3508 offset = 8;
3509 else
3510 offset = 4;
3511 for (i = 0; i < n; i++) {
3512 if (insn & ARM_CP_RW_BIT) {
3513 /* load */
3514 gen_vfp_ld(s, dp, addr);
3515 gen_mov_vreg_F0(dp, rd + i);
3516 } else {
3517 /* store */
3518 gen_mov_F0_vreg(dp, rd + i);
3519 gen_vfp_st(s, dp, addr);
3520 }
3521 tcg_gen_addi_i32(addr, addr, offset);
3522 }
3523 if (w) {
3524 /* writeback */
3525 if (insn & (1 << 24))
3526 offset = -offset * n;
3527 else if (dp && (insn & 1))
3528 offset = 4;
3529 else
3530 offset = 0;
3531
3532 if (offset != 0)
3533 tcg_gen_addi_i32(addr, addr, offset);
3534 store_reg(s, rn, addr);
3535 } else {
3536 tcg_temp_free_i32(addr);
3537 }
3538 }
3539 }
3540 break;
3541 default:
3542 /* Should never happen. */
3543 return 1;
3544 }
3545 return 0;
3546 }
3547
3548 static inline void gen_goto_tb(DisasContext *s, int n, uint32_t dest)
3549 {
3550 TranslationBlock *tb;
3551
3552 tb = s->tb;
3553 if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
3554 tcg_gen_goto_tb(n);
3555 gen_set_pc_im(dest);
3556 tcg_gen_exit_tb((tcg_target_long)tb + n);
3557 } else {
3558 gen_set_pc_im(dest);
3559 tcg_gen_exit_tb(0);
3560 }
3561 }
3562
3563 static inline void gen_jmp (DisasContext *s, uint32_t dest)
3564 {
3565 if (unlikely(s->singlestep_enabled)) {
3566 /* An indirect jump so that we still trigger the debug exception. */
3567 if (s->thumb)
3568 dest |= 1;
3569 gen_bx_im(s, dest);
3570 } else {
3571 gen_goto_tb(s, 0, dest);
3572 s->is_jmp = DISAS_TB_JUMP;
3573 }
3574 }
3575
3576 static inline void gen_mulxy(TCGv t0, TCGv t1, int x, int y)
3577 {
3578 if (x)
3579 tcg_gen_sari_i32(t0, t0, 16);
3580 else
3581 gen_sxth(t0);
3582 if (y)
3583 tcg_gen_sari_i32(t1, t1, 16);
3584 else
3585 gen_sxth(t1);
3586 tcg_gen_mul_i32(t0, t0, t1);
3587 }
3588
3589 /* Return the mask of PSR bits set by a MSR instruction. */
3590 static uint32_t msr_mask(CPUARMState *env, DisasContext *s, int flags, int spsr) {
3591 uint32_t mask;
3592
3593 mask = 0;
3594 if (flags & (1 << 0))
3595 mask |= 0xff;
3596 if (flags & (1 << 1))
3597 mask |= 0xff00;
3598 if (flags & (1 << 2))
3599 mask |= 0xff0000;
3600 if (flags & (1 << 3))
3601 mask |= 0xff000000;
3602
3603 /* Mask out undefined bits. */
3604 mask &= ~CPSR_RESERVED;
3605 if (!arm_feature(env, ARM_FEATURE_V4T))
3606 mask &= ~CPSR_T;
3607 if (!arm_feature(env, ARM_FEATURE_V5))
3608 mask &= ~CPSR_Q; /* V5TE in reality*/
3609 if (!arm_feature(env, ARM_FEATURE_V6))
3610 mask &= ~(CPSR_E | CPSR_GE);
3611 if (!arm_feature(env, ARM_FEATURE_THUMB2))
3612 mask &= ~CPSR_IT;
3613 /* Mask out execution state bits. */
3614 if (!spsr)
3615 mask &= ~CPSR_EXEC;
3616 /* Mask out privileged bits. */
3617 if (IS_USER(s))
3618 mask &= CPSR_USER;
3619 return mask;
3620 }
3621
3622 /* Returns nonzero if access to the PSR is not permitted. Marks t0 as dead. */
3623 static int gen_set_psr(DisasContext *s, uint32_t mask, int spsr, TCGv t0)
3624 {
3625 TCGv tmp;
3626 if (spsr) {
3627 /* ??? This is also undefined in system mode. */
3628 if (IS_USER(s))
3629 return 1;
3630
3631 tmp = load_cpu_field(spsr);
3632 tcg_gen_andi_i32(tmp, tmp, ~mask);
3633 tcg_gen_andi_i32(t0, t0, mask);
3634 tcg_gen_or_i32(tmp, tmp, t0);
3635 store_cpu_field(tmp, spsr);
3636 } else {
3637 gen_set_cpsr(t0, mask);
3638 }
3639 tcg_temp_free_i32(t0);
3640 gen_lookup_tb(s);
3641 return 0;
3642 }
3643
3644 /* Returns nonzero if access to the PSR is not permitted. */
3645 static int gen_set_psr_im(DisasContext *s, uint32_t mask, int spsr, uint32_t val)
3646 {
3647 TCGv tmp;
3648 tmp = tcg_temp_new_i32();
3649 tcg_gen_movi_i32(tmp, val);
3650 return gen_set_psr(s, mask, spsr, tmp);
3651 }
3652
3653 /* Generate an old-style exception return. Marks pc as dead. */
3654 static void gen_exception_return(DisasContext *s, TCGv pc)
3655 {
3656 TCGv tmp;
3657 store_reg(s, 15, pc);
3658 tmp = load_cpu_field(spsr);
3659 gen_set_cpsr(tmp, 0xffffffff);
3660 tcg_temp_free_i32(tmp);
3661 s->is_jmp = DISAS_UPDATE;
3662 }
3663
3664 /* Generate a v6 exception return. Marks both values as dead. */
3665 static void gen_rfe(DisasContext *s, TCGv pc, TCGv cpsr)
3666 {
3667 gen_set_cpsr(cpsr, 0xffffffff);
3668 tcg_temp_free_i32(cpsr);
3669 store_reg(s, 15, pc);
3670 s->is_jmp = DISAS_UPDATE;
3671 }
3672
3673 static inline void
3674 gen_set_condexec (DisasContext *s)
3675 {
3676 if (s->condexec_mask) {
3677 uint32_t val = (s->condexec_cond << 4) | (s->condexec_mask >> 1);
3678 TCGv tmp = tcg_temp_new_i32();
3679 tcg_gen_movi_i32(tmp, val);
3680 store_cpu_field(tmp, condexec_bits);
3681 }
3682 }
3683
3684 static void gen_exception_insn(DisasContext *s, int offset, int excp)
3685 {
3686 gen_set_condexec(s);
3687 gen_set_pc_im(s->pc - offset);
3688 gen_exception(excp);
3689 s->is_jmp = DISAS_JUMP;
3690 }
3691
3692 static void gen_nop_hint(DisasContext *s, int val)
3693 {
3694 switch (val) {
3695 case 3: /* wfi */
3696 gen_set_pc_im(s->pc);
3697 s->is_jmp = DISAS_WFI;
3698 break;
3699 case 2: /* wfe */
3700 case 4: /* sev */
3701 /* TODO: Implement SEV and WFE. May help SMP performance. */
3702 default: /* nop */
3703 break;
3704 }
3705 }
3706
3707 #define CPU_V001 cpu_V0, cpu_V0, cpu_V1
3708
3709 static inline void gen_neon_add(int size, TCGv t0, TCGv t1)
3710 {
3711 switch (size) {
3712 case 0: gen_helper_neon_add_u8(t0, t0, t1); break;
3713 case 1: gen_helper_neon_add_u16(t0, t0, t1); break;
3714 case 2: tcg_gen_add_i32(t0, t0, t1); break;
3715 default: abort();
3716 }
3717 }
3718
3719 static inline void gen_neon_rsb(int size, TCGv t0, TCGv t1)
3720 {
3721 switch (size) {
3722 case 0: gen_helper_neon_sub_u8(t0, t1, t0); break;
3723 case 1: gen_helper_neon_sub_u16(t0, t1, t0); break;
3724 case 2: tcg_gen_sub_i32(t0, t1, t0); break;
3725 default: return;
3726 }
3727 }
3728
3729 /* 32-bit pairwise ops end up the same as the elementwise versions. */
3730 #define gen_helper_neon_pmax_s32 gen_helper_neon_max_s32
3731 #define gen_helper_neon_pmax_u32 gen_helper_neon_max_u32
3732 #define gen_helper_neon_pmin_s32 gen_helper_neon_min_s32
3733 #define gen_helper_neon_pmin_u32 gen_helper_neon_min_u32
3734
3735 #define GEN_NEON_INTEGER_OP_ENV(name) do { \
3736 switch ((size << 1) | u) { \
3737 case 0: \
3738 gen_helper_neon_##name##_s8(tmp, cpu_env, tmp, tmp2); \
3739 break; \
3740 case 1: \
3741 gen_helper_neon_##name##_u8(tmp, cpu_env, tmp, tmp2); \
3742 break; \
3743 case 2: \
3744 gen_helper_neon_##name##_s16(tmp, cpu_env, tmp, tmp2); \
3745 break; \
3746 case 3: \
3747 gen_helper_neon_##name##_u16(tmp, cpu_env, tmp, tmp2); \
3748 break; \
3749 case 4: \
3750 gen_helper_neon_##name##_s32(tmp, cpu_env, tmp, tmp2); \
3751 break; \
3752 case 5: \
3753 gen_helper_neon_##name##_u32(tmp, cpu_env, tmp, tmp2); \
3754 break; \
3755 default: return 1; \
3756 }} while (0)
3757
3758 #define GEN_NEON_INTEGER_OP(name) do { \
3759 switch ((size << 1) | u) { \
3760 case 0: \
3761 gen_helper_neon_##name##_s8(tmp, tmp, tmp2); \
3762 break; \
3763 case 1: \
3764 gen_helper_neon_##name##_u8(tmp, tmp, tmp2); \
3765 break; \
3766 case 2: \
3767 gen_helper_neon_##name##_s16(tmp, tmp, tmp2); \
3768 break; \
3769 case 3: \
3770 gen_helper_neon_##name##_u16(tmp, tmp, tmp2); \
3771 break; \
3772 case 4: \
3773 gen_helper_neon_##name##_s32(tmp, tmp, tmp2); \
3774 break; \
3775 case 5: \
3776 gen_helper_neon_##name##_u32(tmp, tmp, tmp2); \
3777 break; \
3778 default: return 1; \
3779 }} while (0)
3780
3781 static TCGv neon_load_scratch(int scratch)
3782 {
3783 TCGv tmp = tcg_temp_new_i32();
3784 tcg_gen_ld_i32(tmp, cpu_env, offsetof(CPUARMState, vfp.scratch[scratch]));
3785 return tmp;
3786 }
3787
3788 static void neon_store_scratch(int scratch, TCGv var)
3789 {
3790 tcg_gen_st_i32(var, cpu_env, offsetof(CPUARMState, vfp.scratch[scratch]));
3791 tcg_temp_free_i32(var);
3792 }
3793
3794 static inline TCGv neon_get_scalar(int size, int reg)
3795 {
3796 TCGv tmp;
3797 if (size == 1) {
3798 tmp = neon_load_reg(reg & 7, reg >> 4);
3799 if (reg & 8) {
3800 gen_neon_dup_high16(tmp);
3801 } else {
3802 gen_neon_dup_low16(tmp);
3803 }
3804 } else {
3805 tmp = neon_load_reg(reg & 15, reg >> 4);
3806 }
3807 return tmp;
3808 }
3809
3810 static int gen_neon_unzip(int rd, int rm, int size, int q)
3811 {
3812 TCGv tmp, tmp2;
3813 if (!q && size == 2) {
3814 return 1;
3815 }
3816 tmp = tcg_const_i32(rd);
3817 tmp2 = tcg_const_i32(rm);
3818 if (q) {
3819 switch (size) {
3820 case 0:
3821 gen_helper_neon_qunzip8(cpu_env, tmp, tmp2);
3822 break;
3823 case 1:
3824 gen_helper_neon_qunzip16(cpu_env, tmp, tmp2);
3825 break;
3826 case 2:
3827 gen_helper_neon_qunzip32(cpu_env, tmp, tmp2);
3828 break;
3829 default:
3830 abort();
3831 }
3832 } else {
3833 switch (size) {
3834 case 0:
3835 gen_helper_neon_unzip8(cpu_env, tmp, tmp2);
3836 break;
3837 case 1:
3838 gen_helper_neon_unzip16(cpu_env, tmp, tmp2);
3839 break;
3840 default:
3841 abort();
3842 }
3843 }
3844 tcg_temp_free_i32(tmp);
3845 tcg_temp_free_i32(tmp2);
3846 return 0;
3847 }
3848
3849 static int gen_neon_zip(int rd, int rm, int size, int q)
3850 {
3851 TCGv tmp, tmp2;
3852 if (!q && size == 2) {
3853 return 1;
3854 }
3855 tmp = tcg_const_i32(rd);
3856 tmp2 = tcg_const_i32(rm);
3857 if (q) {
3858 switch (size) {
3859 case 0:
3860 gen_helper_neon_qzip8(cpu_env, tmp, tmp2);
3861 break;
3862 case 1:
3863 gen_helper_neon_qzip16(cpu_env, tmp, tmp2);
3864 break;
3865 case 2:
3866 gen_helper_neon_qzip32(cpu_env, tmp, tmp2);
3867 break;
3868 default:
3869 abort();
3870 }
3871 } else {
3872 switch (size) {
3873 case 0:
3874 gen_helper_neon_zip8(cpu_env, tmp, tmp2);
3875 break;
3876 case 1:
3877 gen_helper_neon_zip16(cpu_env, tmp, tmp2);
3878 break;
3879 default:
3880 abort();
3881 }
3882 }
3883 tcg_temp_free_i32(tmp);
3884 tcg_temp_free_i32(tmp2);
3885 return 0;
3886 }
3887
3888 static void gen_neon_trn_u8(TCGv t0, TCGv t1)
3889 {
3890 TCGv rd, tmp;
3891
3892 rd = tcg_temp_new_i32();
3893 tmp = tcg_temp_new_i32();
3894
3895 tcg_gen_shli_i32(rd, t0, 8);
3896 tcg_gen_andi_i32(rd, rd, 0xff00ff00);
3897 tcg_gen_andi_i32(tmp, t1, 0x00ff00ff);
3898 tcg_gen_or_i32(rd, rd, tmp);
3899
3900 tcg_gen_shri_i32(t1, t1, 8);
3901 tcg_gen_andi_i32(t1, t1, 0x00ff00ff);
3902 tcg_gen_andi_i32(tmp, t0, 0xff00ff00);
3903 tcg_gen_or_i32(t1, t1, tmp);
3904 tcg_gen_mov_i32(t0, rd);
3905
3906 tcg_temp_free_i32(tmp);
3907 tcg_temp_free_i32(rd);
3908 }
3909
3910 static void gen_neon_trn_u16(TCGv t0, TCGv t1)
3911 {
3912 TCGv rd, tmp;
3913
3914 rd = tcg_temp_new_i32();
3915 tmp = tcg_temp_new_i32();
3916
3917 tcg_gen_shli_i32(rd, t0, 16);
3918 tcg_gen_andi_i32(tmp, t1, 0xffff);
3919 tcg_gen_or_i32(rd, rd, tmp);
3920 tcg_gen_shri_i32(t1, t1, 16);
3921 tcg_gen_andi_i32(tmp, t0, 0xffff0000);
3922 tcg_gen_or_i32(t1, t1, tmp);
3923 tcg_gen_mov_i32(t0, rd);
3924
3925 tcg_temp_free_i32(tmp);
3926 tcg_temp_free_i32(rd);
3927 }
3928
3929
3930 static struct {
3931 int nregs;
3932 int interleave;
3933 int spacing;
3934 } neon_ls_element_type[11] = {
3935 {4, 4, 1},
3936 {4, 4, 2},
3937 {4, 1, 1},
3938 {4, 2, 1},
3939 {3, 3, 1},
3940 {3, 3, 2},
3941 {3, 1, 1},
3942 {1, 1, 1},
3943 {2, 2, 1},
3944 {2, 2, 2},
3945 {2, 1, 1}
3946 };
3947
3948 /* Translate a NEON load/store element instruction. Return nonzero if the
3949 instruction is invalid. */
3950 static int disas_neon_ls_insn(CPUARMState * env, DisasContext *s, uint32_t insn)
3951 {
3952 int rd, rn, rm;
3953 int op;
3954 int nregs;
3955 int interleave;
3956 int spacing;
3957 int stride;
3958 int size;
3959 int reg;
3960 int pass;
3961 int load;
3962 int shift;
3963 int n;
3964 TCGv addr;
3965 TCGv tmp;
3966 TCGv tmp2;
3967 TCGv_i64 tmp64;
3968
3969 if (!s->vfp_enabled)
3970 return 1;
3971 VFP_DREG_D(rd, insn);
3972 rn = (insn >> 16) & 0xf;
3973 rm = insn & 0xf;
3974 load = (insn & (1 << 21)) != 0;
3975 if ((insn & (1 << 23)) == 0) {
3976 /* Load store all elements. */
3977 op = (insn >> 8) & 0xf;
3978 size = (insn >> 6) & 3;
3979 if (op > 10)
3980 return 1;
3981 /* Catch UNDEF cases for bad values of align field */
3982 switch (op & 0xc) {
3983 case 4:
3984 if (((insn >> 5) & 1) == 1) {
3985 return 1;
3986 }
3987 break;
3988 case 8:
3989 if (((insn >> 4) & 3) == 3) {
3990 return 1;
3991 }
3992 break;
3993 default:
3994 break;
3995 }
3996 nregs = neon_ls_element_type[op].nregs;
3997 interleave = neon_ls_element_type[op].interleave;
3998 spacing = neon_ls_element_type[op].spacing;
3999 if (size == 3 && (interleave | spacing) != 1)
4000 return 1;
4001 addr = tcg_temp_new_i32();
4002 load_reg_var(s, addr, rn);
4003 stride = (1 << size) * interleave;
4004 for (reg = 0; reg < nregs; reg++) {
4005 if (interleave > 2 || (interleave == 2 && nregs == 2)) {
4006 load_reg_var(s, addr, rn);
4007 tcg_gen_addi_i32(addr, addr, (1 << size) * reg);
4008 } else if (interleave == 2 && nregs == 4 && reg == 2) {
4009 load_reg_var(s, addr, rn);
4010 tcg_gen_addi_i32(addr, addr, 1 << size);
4011 }
4012 if (size == 3) {
4013 if (load) {
4014 tmp64 = gen_ld64(addr, IS_USER(s));
4015 neon_store_reg64(tmp64, rd);
4016 tcg_temp_free_i64(tmp64);
4017 } else {
4018 tmp64 = tcg_temp_new_i64();
4019 neon_load_reg64(tmp64, rd);
4020 gen_st64(tmp64, addr, IS_USER(s));
4021 }
4022 tcg_gen_addi_i32(addr, addr, stride);
4023 } else {
4024 for (pass = 0; pass < 2; pass++) {
4025 if (size == 2) {
4026 if (load) {
4027 tmp = gen_ld32(addr, IS_USER(s));
4028 neon_store_reg(rd, pass, tmp);
4029 } else {
4030 tmp = neon_load_reg(rd, pass);
4031 gen_st32(tmp, addr, IS_USER(s));
4032 }
4033 tcg_gen_addi_i32(addr, addr, stride);
4034 } else if (size == 1) {
4035 if (load) {
4036 tmp = gen_ld16u(addr, IS_USER(s));
4037 tcg_gen_addi_i32(addr, addr, stride);
4038 tmp2 = gen_ld16u(addr, IS_USER(s));
4039 tcg_gen_addi_i32(addr, addr, stride);
4040 tcg_gen_shli_i32(tmp2, tmp2, 16);
4041 tcg_gen_or_i32(tmp, tmp, tmp2);
4042 tcg_temp_free_i32(tmp2);
4043 neon_store_reg(rd, pass, tmp);
4044 } else {
4045 tmp = neon_load_reg(rd, pass);
4046 tmp2 = tcg_temp_new_i32();
4047 tcg_gen_shri_i32(tmp2, tmp, 16);
4048 gen_st16(tmp, addr, IS_USER(s));
4049 tcg_gen_addi_i32(addr, addr, stride);
4050 gen_st16(tmp2, addr, IS_USER(s));
4051 tcg_gen_addi_i32(addr, addr, stride);
4052 }
4053 } else /* size == 0 */ {
4054 if (load) {
4055 TCGV_UNUSED(tmp2);
4056 for (n = 0; n < 4; n++) {
4057 tmp = gen_ld8u(addr, IS_USER(s));
4058 tcg_gen_addi_i32(addr, addr, stride);
4059 if (n == 0) {
4060 tmp2 = tmp;
4061 } else {
4062 tcg_gen_shli_i32(tmp, tmp, n * 8);
4063 tcg_gen_or_i32(tmp2, tmp2, tmp);
4064 tcg_temp_free_i32(tmp);
4065 }
4066 }
4067 neon_store_reg(rd, pass, tmp2);
4068 } else {
4069 tmp2 = neon_load_reg(rd, pass);
4070 for (n = 0; n < 4; n++) {
4071 tmp = tcg_temp_new_i32();
4072 if (n == 0) {
4073 tcg_gen_mov_i32(tmp, tmp2);
4074 } else {
4075 tcg_gen_shri_i32(tmp, tmp2, n * 8);
4076 }
4077 gen_st8(tmp, addr, IS_USER(s));
4078 tcg_gen_addi_i32(addr, addr, stride);
4079 }
4080 tcg_temp_free_i32(tmp2);
4081 }
4082 }
4083 }
4084 }
4085 rd += spacing;
4086 }
4087 tcg_temp_free_i32(addr);
4088 stride = nregs * 8;
4089 } else {
4090 size = (insn >> 10) & 3;
4091 if (size == 3) {
4092 /* Load single element to all lanes. */
4093 int a = (insn >> 4) & 1;
4094 if (!load) {
4095 return 1;
4096 }
4097 size = (insn >> 6) & 3;
4098 nregs = ((insn >> 8) & 3) + 1;
4099
4100 if (size == 3) {
4101 if (nregs != 4 || a == 0) {
4102 return 1;
4103 }
4104 /* For VLD4 size==3 a == 1 means 32 bits at 16 byte alignment */
4105 size = 2;
4106 }
4107 if (nregs == 1 && a == 1 && size == 0) {
4108 return 1;
4109 }
4110 if (nregs == 3 && a == 1) {
4111 return 1;
4112 }
4113 addr = tcg_temp_new_i32();
4114 load_reg_var(s, addr, rn);
4115 if (nregs == 1) {
4116 /* VLD1 to all lanes: bit 5 indicates how many Dregs to write */
4117 tmp = gen_load_and_replicate(s, addr, size);
4118 tcg_gen_st_i32(tmp, cpu_env, neon_reg_offset(rd, 0));
4119 tcg_gen_st_i32(tmp, cpu_env, neon_reg_offset(rd, 1));
4120 if (insn & (1 << 5)) {
4121 tcg_gen_st_i32(tmp, cpu_env, neon_reg_offset(rd + 1, 0));
4122 tcg_gen_st_i32(tmp, cpu_env, neon_reg_offset(rd + 1, 1));
4123 }
4124 tcg_temp_free_i32(tmp);
4125 } else {
4126 /* VLD2/3/4 to all lanes: bit 5 indicates register stride */
4127 stride = (insn & (1 << 5)) ? 2 : 1;
4128 for (reg = 0; reg < nregs; reg++) {
4129 tmp = gen_load_and_replicate(s, addr, size);
4130 tcg_gen_st_i32(tmp, cpu_env, neon_reg_offset(rd, 0));
4131 tcg_gen_st_i32(tmp, cpu_env, neon_reg_offset(rd, 1));
4132 tcg_temp_free_i32(tmp);
4133 tcg_gen_addi_i32(addr, addr, 1 << size);
4134 rd += stride;
4135 }
4136 }
4137 tcg_temp_free_i32(addr);
4138 stride = (1 << size) * nregs;
4139 } else {
4140 /* Single element. */
4141 int idx = (insn >> 4) & 0xf;
4142 pass = (insn >> 7) & 1;
4143 switch (size) {
4144 case 0:
4145 shift = ((insn >> 5) & 3) * 8;
4146 stride = 1;
4147 break;
4148 case 1:
4149 shift = ((insn >> 6) & 1) * 16;
4150 stride = (insn & (1 << 5)) ? 2 : 1;
4151 break;
4152 case 2:
4153 shift = 0;
4154 stride = (insn & (1 << 6)) ? 2 : 1;
4155 break;
4156 default:
4157 abort();
4158 }
4159 nregs = ((insn >> 8) & 3) + 1;
4160 /* Catch the UNDEF cases. This is unavoidably a bit messy. */
4161 switch (nregs) {
4162 case 1:
4163 if (((idx & (1 << size)) != 0) ||
4164 (size == 2 && ((idx & 3) == 1 || (idx & 3) == 2))) {
4165 return 1;
4166 }
4167 break;
4168 case 3:
4169 if ((idx & 1) != 0) {
4170 return 1;
4171 }
4172 /* fall through */
4173 case 2:
4174 if (size == 2 && (idx & 2) != 0) {
4175 return 1;
4176 }
4177 break;
4178 case 4:
4179 if ((size == 2) && ((idx & 3) == 3)) {
4180 return 1;
4181 }
4182 break;
4183 default:
4184 abort();
4185 }
4186 if ((rd + stride * (nregs - 1)) > 31) {
4187 /* Attempts to write off the end of the register file
4188 * are UNPREDICTABLE; we choose to UNDEF because otherwise
4189 * the neon_load_reg() would write off the end of the array.
4190 */
4191 return 1;
4192 }
4193 addr = tcg_temp_new_i32();
4194 load_reg_var(s, addr, rn);
4195 for (reg = 0; reg < nregs; reg++) {
4196 if (load) {
4197 switch (size) {
4198 case 0:
4199 tmp = gen_ld8u(addr, IS_USER(s));
4200 break;
4201 case 1:
4202 tmp = gen_ld16u(addr, IS_USER(s));
4203 break;
4204 case 2:
4205 tmp = gen_ld32(addr, IS_USER(s));
4206 break;
4207 default: /* Avoid compiler warnings. */
4208 abort();
4209 }
4210 if (size != 2) {
4211 tmp2 = neon_load_reg(rd, pass);
4212 gen_bfi(tmp, tmp2, tmp, shift, size ? 0xffff : 0xff);
4213 tcg_temp_free_i32(tmp2);
4214 }
4215 neon_store_reg(rd, pass, tmp);
4216 } else { /* Store */
4217 tmp = neon_load_reg(rd, pass);
4218 if (shift)
4219 tcg_gen_shri_i32(tmp, tmp, shift);
4220 switch (size) {
4221 case 0:
4222 gen_st8(tmp, addr, IS_USER(s));
4223 break;
4224 case 1:
4225 gen_st16(tmp, addr, IS_USER(s));
4226 break;
4227 case 2:
4228 gen_st32(tmp, addr, IS_USER(s));
4229 break;
4230 }
4231 }
4232 rd += stride;
4233 tcg_gen_addi_i32(addr, addr, 1 << size);
4234 }
4235 tcg_temp_free_i32(addr);
4236 stride = nregs * (1 << size);
4237 }
4238 }
4239 if (rm != 15) {
4240 TCGv base;
4241
4242 base = load_reg(s, rn);
4243 if (rm == 13) {
4244 tcg_gen_addi_i32(base, base, stride);
4245 } else {
4246 TCGv index;
4247 index = load_reg(s, rm);
4248 tcg_gen_add_i32(base, base, index);
4249 tcg_temp_free_i32(index);
4250 }
4251 store_reg(s, rn, base);
4252 }
4253 return 0;
4254 }
4255
4256 /* Bitwise select. dest = c ? t : f. Clobbers T and F. */
4257 static void gen_neon_bsl(TCGv dest, TCGv t, TCGv f, TCGv c)
4258 {
4259 tcg_gen_and_i32(t, t, c);
4260 tcg_gen_andc_i32(f, f, c);
4261 tcg_gen_or_i32(dest, t, f);
4262 }
4263
4264 static inline void gen_neon_narrow(int size, TCGv dest, TCGv_i64 src)
4265 {
4266 switch (size) {
4267 case 0: gen_helper_neon_narrow_u8(dest, src); break;
4268 case 1: gen_helper_neon_narrow_u16(dest, src); break;
4269 case 2: tcg_gen_trunc_i64_i32(dest, src); break;
4270 default: abort();
4271 }
4272 }
4273
4274 static inline void gen_neon_narrow_sats(int size, TCGv dest, TCGv_i64 src)
4275 {
4276 switch (size) {
4277 case 0: gen_helper_neon_narrow_sat_s8(dest, cpu_env, src); break;
4278 case 1: gen_helper_neon_narrow_sat_s16(dest, cpu_env, src); break;
4279 case 2: gen_helper_neon_narrow_sat_s32(dest, cpu_env, src); break;
4280 default: abort();
4281 }
4282 }
4283
4284 static inline void gen_neon_narrow_satu(int size, TCGv dest, TCGv_i64 src)
4285 {
4286 switch (size) {
4287 case 0: gen_helper_neon_narrow_sat_u8(dest, cpu_env, src); break;
4288 case 1: gen_helper_neon_narrow_sat_u16(dest, cpu_env, src); break;
4289 case 2: gen_helper_neon_narrow_sat_u32(dest, cpu_env, src); break;
4290 default: abort();
4291 }
4292 }
4293
4294 static inline void gen_neon_unarrow_sats(int size, TCGv dest, TCGv_i64 src)
4295 {
4296 switch (size) {
4297 case 0: gen_helper_neon_unarrow_sat8(dest, cpu_env, src); break;
4298 case 1: gen_helper_neon_unarrow_sat16(dest, cpu_env, src); break;
4299 case 2: gen_helper_neon_unarrow_sat32(dest, cpu_env, src); break;
4300 default: abort();
4301 }
4302 }
4303
4304 static inline void gen_neon_shift_narrow(int size, TCGv var, TCGv shift,
4305 int q, int u)
4306 {
4307 if (q) {
4308 if (u) {
4309 switch (size) {
4310 case 1: gen_helper_neon_rshl_u16(var, var, shift); break;
4311 case 2: gen_helper_neon_rshl_u32(var, var, shift); break;
4312 default: abort();
4313 }
4314 } else {
4315 switch (size) {
4316 case 1: gen_helper_neon_rshl_s16(var, var, shift); break;
4317 case 2: gen_helper_neon_rshl_s32(var, var, shift); break;
4318 default: abort();
4319 }
4320 }
4321 } else {
4322 if (u) {
4323 switch (size) {
4324 case 1: gen_helper_neon_shl_u16(var, var, shift); break;
4325 case 2: gen_helper_neon_shl_u32(var, var, shift); break;
4326 default: abort();
4327 }
4328 } else {
4329 switch (size) {
4330 case 1: gen_helper_neon_shl_s16(var, var, shift); break;
4331 case 2: gen_helper_neon_shl_s32(var, var, shift); break;
4332 default: abort();
4333 }
4334 }
4335 }
4336 }
4337
4338 static inline void gen_neon_widen(TCGv_i64 dest, TCGv src, int size, int u)
4339 {
4340 if (u) {
4341 switch (size) {
4342 case 0: gen_helper_neon_widen_u8(dest, src); break;
4343 case 1: gen_helper_neon_widen_u16(dest, src); break;
4344 case 2: tcg_gen_extu_i32_i64(dest, src); break;
4345 default: abort();
4346 }
4347 } else {
4348 switch (size) {
4349 case 0: gen_helper_neon_widen_s8(dest, src); break;
4350 case 1: gen_helper_neon_widen_s16(dest, src); break;
4351 case 2: tcg_gen_ext_i32_i64(dest, src); break;
4352 default: abort();
4353 }
4354 }
4355 tcg_temp_free_i32(src);
4356 }
4357
4358 static inline void gen_neon_addl(int size)
4359 {
4360 switch (size) {
4361 case 0: gen_helper_neon_addl_u16(CPU_V001); break;
4362 case 1: gen_helper_neon_addl_u32(CPU_V001); break;
4363 case 2: tcg_gen_add_i64(CPU_V001); break;
4364 default: abort();
4365 }
4366 }
4367
4368 static inline void gen_neon_subl(int size)
4369 {
4370 switch (size) {
4371 case 0: gen_helper_neon_subl_u16(CPU_V001); break;
4372 case 1: gen_helper_neon_subl_u32(CPU_V001); break;
4373 case 2: tcg_gen_sub_i64(CPU_V001); break;
4374 default: abort();
4375 }
4376 }
4377
4378 static inline void gen_neon_negl(TCGv_i64 var, int size)
4379 {
4380 switch (size) {
4381 case 0: gen_helper_neon_negl_u16(var, var); break;
4382 case 1: gen_helper_neon_negl_u32(var, var); break;
4383 case 2: gen_helper_neon_negl_u64(var, var); break;
4384 default: abort();
4385 }
4386 }
4387
4388 static inline void gen_neon_addl_saturate(TCGv_i64 op0, TCGv_i64 op1, int size)
4389 {
4390 switch (size) {
4391 case 1: gen_helper_neon_addl_saturate_s32(op0, cpu_env, op0, op1); break;
4392 case 2: gen_helper_neon_addl_saturate_s64(op0, cpu_env, op0, op1); break;
4393 default: abort();
4394 }
4395 }
4396
4397 static inline void gen_neon_mull(TCGv_i64 dest, TCGv a, TCGv b, int size, int u)
4398 {
4399 TCGv_i64 tmp;
4400
4401 switch ((size << 1) | u) {
4402 case 0: gen_helper_neon_mull_s8(dest, a, b); break;
4403 case 1: gen_helper_neon_mull_u8(dest, a, b); break;
4404 case 2: gen_helper_neon_mull_s16(dest, a, b); break;
4405 case 3: gen_helper_neon_mull_u16(dest, a, b); break;
4406 case 4:
4407 tmp = gen_muls_i64_i32(a, b);
4408 tcg_gen_mov_i64(dest, tmp);
4409 tcg_temp_free_i64(tmp);
4410 break;
4411 case 5:
4412 tmp = gen_mulu_i64_i32(a, b);
4413 tcg_gen_mov_i64(dest, tmp);
4414 tcg_temp_free_i64(tmp);
4415 break;
4416 default: abort();
4417 }
4418
4419 /* gen_helper_neon_mull_[su]{8|16} do not free their parameters.
4420 Don't forget to clean them now. */
4421 if (size < 2) {
4422 tcg_temp_free_i32(a);
4423 tcg_temp_free_i32(b);
4424 }
4425 }
4426
4427 static void gen_neon_narrow_op(int op, int u, int size, TCGv dest, TCGv_i64 src)
4428 {
4429 if (op) {
4430 if (u) {
4431 gen_neon_unarrow_sats(size, dest, src);
4432 } else {
4433 gen_neon_narrow(size, dest, src);
4434 }
4435 } else {
4436 if (u) {
4437 gen_neon_narrow_satu(size, dest, src);
4438 } else {
4439 gen_neon_narrow_sats(size, dest, src);
4440 }
4441 }
4442 }
4443
4444 /* Symbolic constants for op fields for Neon 3-register same-length.
4445 * The values correspond to bits [11:8,4]; see the ARM ARM DDI0406B
4446 * table A7-9.
4447 */
4448 #define NEON_3R_VHADD 0
4449 #define NEON_3R_VQADD 1
4450 #define NEON_3R_VRHADD 2
4451 #define NEON_3R_LOGIC 3 /* VAND,VBIC,VORR,VMOV,VORN,VEOR,VBIF,VBIT,VBSL */
4452 #define NEON_3R_VHSUB 4
4453 #define NEON_3R_VQSUB 5
4454 #define NEON_3R_VCGT 6
4455 #define NEON_3R_VCGE 7
4456 #define NEON_3R_VSHL 8
4457 #define NEON_3R_VQSHL 9
4458 #define NEON_3R_VRSHL 10
4459 #define NEON_3R_VQRSHL 11
4460 #define NEON_3R_VMAX 12
4461 #define NEON_3R_VMIN 13
4462 #define NEON_3R_VABD 14
4463 #define NEON_3R_VABA 15
4464 #define NEON_3R_VADD_VSUB 16
4465 #define NEON_3R_VTST_VCEQ 17
4466 #define NEON_3R_VML 18 /* VMLA, VMLAL, VMLS, VMLSL */
4467 #define NEON_3R_VMUL 19
4468 #define NEON_3R_VPMAX 20
4469 #define NEON_3R_VPMIN 21
4470 #define NEON_3R_VQDMULH_VQRDMULH 22
4471 #define NEON_3R_VPADD 23
4472 #define NEON_3R_VFM 25 /* VFMA, VFMS : float fused multiply-add */
4473 #define NEON_3R_FLOAT_ARITH 26 /* float VADD, VSUB, VPADD, VABD */
4474 #define NEON_3R_FLOAT_MULTIPLY 27 /* float VMLA, VMLS, VMUL */
4475 #define NEON_3R_FLOAT_CMP 28 /* float VCEQ, VCGE, VCGT */
4476 #define NEON_3R_FLOAT_ACMP 29 /* float VACGE, VACGT, VACLE, VACLT */
4477 #define NEON_3R_FLOAT_MINMAX 30 /* float VMIN, VMAX */
4478 #define NEON_3R_VRECPS_VRSQRTS 31 /* float VRECPS, VRSQRTS */
4479
4480 static const uint8_t neon_3r_sizes[] = {
4481 [NEON_3R_VHADD] = 0x7,
4482 [NEON_3R_VQADD] = 0xf,
4483 [NEON_3R_VRHADD] = 0x7,
4484 [NEON_3R_LOGIC] = 0xf, /* size field encodes op type */
4485 [NEON_3R_VHSUB] = 0x7,
4486 [NEON_3R_VQSUB] = 0xf,
4487 [NEON_3R_VCGT] = 0x7,
4488 [NEON_3R_VCGE] = 0x7,
4489 [NEON_3R_VSHL] = 0xf,
4490 [NEON_3R_VQSHL] = 0xf,
4491 [NEON_3R_VRSHL] = 0xf,
4492 [NEON_3R_VQRSHL] = 0xf,
4493 [NEON_3R_VMAX] = 0x7,
4494 [NEON_3R_VMIN] = 0x7,
4495 [NEON_3R_VABD] = 0x7,
4496 [NEON_3R_VABA] = 0x7,
4497 [NEON_3R_VADD_VSUB] = 0xf,
4498 [NEON_3R_VTST_VCEQ] = 0x7,
4499 [NEON_3R_VML] = 0x7,
4500 [NEON_3R_VMUL] = 0x7,
4501 [NEON_3R_VPMAX] = 0x7,
4502 [NEON_3R_VPMIN] = 0x7,
4503 [NEON_3R_VQDMULH_VQRDMULH] = 0x6,
4504 [NEON_3R_VPADD] = 0x7,
4505 [NEON_3R_VFM] = 0x5, /* size bit 1 encodes op */
4506 [NEON_3R_FLOAT_ARITH] = 0x5, /* size bit 1 encodes op */
4507 [NEON_3R_FLOAT_MULTIPLY] = 0x5, /* size bit 1 encodes op */
4508 [NEON_3R_FLOAT_CMP] = 0x5, /* size bit 1 encodes op */
4509 [NEON_3R_FLOAT_ACMP] = 0x5, /* size bit 1 encodes op */
4510 [NEON_3R_FLOAT_MINMAX] = 0x5, /* size bit 1 encodes op */
4511 [NEON_3R_VRECPS_VRSQRTS] = 0x5, /* size bit 1 encodes op */
4512 };
4513
4514 /* Symbolic constants for op fields for Neon 2-register miscellaneous.
4515 * The values correspond to bits [17:16,10:7]; see the ARM ARM DDI0406B
4516 * table A7-13.
4517 */
4518 #define NEON_2RM_VREV64 0
4519 #define NEON_2RM_VREV32 1
4520 #define NEON_2RM_VREV16 2
4521 #define NEON_2RM_VPADDL 4
4522 #define NEON_2RM_VPADDL_U 5
4523 #define NEON_2RM_VCLS 8
4524 #define NEON_2RM_VCLZ 9
4525 #define NEON_2RM_VCNT 10
4526 #define NEON_2RM_VMVN 11
4527 #define NEON_2RM_VPADAL 12
4528 #define NEON_2RM_VPADAL_U 13
4529 #define NEON_2RM_VQABS 14
4530 #define NEON_2RM_VQNEG 15
4531 #define NEON_2RM_VCGT0 16
4532 #define NEON_2RM_VCGE0 17
4533 #define NEON_2RM_VCEQ0 18
4534 #define NEON_2RM_VCLE0 19
4535 #define NEON_2RM_VCLT0 20
4536 #define NEON_2RM_VABS 22
4537 #define NEON_2RM_VNEG 23
4538 #define NEON_2RM_VCGT0_F 24
4539 #define NEON_2RM_VCGE0_F 25
4540 #define NEON_2RM_VCEQ0_F 26
4541 #define NEON_2RM_VCLE0_F 27
4542 #define NEON_2RM_VCLT0_F 28
4543 #define NEON_2RM_VABS_F 30
4544 #define NEON_2RM_VNEG_F 31
4545 #define NEON_2RM_VSWP 32
4546 #define NEON_2RM_VTRN 33
4547 #define NEON_2RM_VUZP 34
4548 #define NEON_2RM_VZIP 35
4549 #define NEON_2RM_VMOVN 36 /* Includes VQMOVN, VQMOVUN */
4550 #define NEON_2RM_VQMOVN 37 /* Includes VQMOVUN */
4551 #define NEON_2RM_VSHLL 38
4552 #define NEON_2RM_VCVT_F16_F32 44
4553 #define NEON_2RM_VCVT_F32_F16 46
4554 #define NEON_2RM_VRECPE 56
4555 #define NEON_2RM_VRSQRTE 57
4556 #define NEON_2RM_VRECPE_F 58
4557 #define NEON_2RM_VRSQRTE_F 59
4558 #define NEON_2RM_VCVT_FS 60
4559 #define NEON_2RM_VCVT_FU 61
4560 #define NEON_2RM_VCVT_SF 62
4561 #define NEON_2RM_VCVT_UF 63
4562
4563 static int neon_2rm_is_float_op(int op)
4564 {
4565 /* Return true if this neon 2reg-misc op is float-to-float */
4566 return (op == NEON_2RM_VABS_F || op == NEON_2RM_VNEG_F ||
4567 op >= NEON_2RM_VRECPE_F);
4568 }
4569
4570 /* Each entry in this array has bit n set if the insn allows
4571 * size value n (otherwise it will UNDEF). Since unallocated
4572 * op values will have no bits set they always UNDEF.
4573 */
4574 static const uint8_t neon_2rm_sizes[] = {
4575 [NEON_2RM_VREV64] = 0x7,
4576 [NEON_2RM_VREV32] = 0x3,
4577 [NEON_2RM_VREV16] = 0x1,
4578 [NEON_2RM_VPADDL] = 0x7,
4579 [NEON_2RM_VPADDL_U] = 0x7,
4580 [NEON_2RM_VCLS] = 0x7,
4581 [NEON_2RM_VCLZ] = 0x7,
4582 [NEON_2RM_VCNT] = 0x1,
4583 [NEON_2RM_VMVN] = 0x1,
4584 [NEON_2RM_VPADAL] = 0x7,
4585 [NEON_2RM_VPADAL_U] = 0x7,
4586 [NEON_2RM_VQABS] = 0x7,
4587 [NEON_2RM_VQNEG] = 0x7,
4588 [NEON_2RM_VCGT0] = 0x7,
4589 [NEON_2RM_VCGE0] = 0x7,
4590 [NEON_2RM_VCEQ0] = 0x7,
4591 [NEON_2RM_VCLE0] = 0x7,
4592 [NEON_2RM_VCLT0] = 0x7,
4593 [NEON_2RM_VABS] = 0x7,
4594 [NEON_2RM_VNEG] = 0x7,
4595 [NEON_2RM_VCGT0_F] = 0x4,
4596 [NEON_2RM_VCGE0_F] = 0x4,
4597 [NEON_2RM_VCEQ0_F] = 0x4,
4598 [NEON_2RM_VCLE0_F] = 0x4,
4599 [NEON_2RM_VCLT0_F] = 0x4,
4600 [NEON_2RM_VABS_F] = 0x4,
4601 [NEON_2RM_VNEG_F] = 0x4,
4602 [NEON_2RM_VSWP] = 0x1,
4603 [NEON_2RM_VTRN] = 0x7,
4604 [NEON_2RM_VUZP] = 0x7,
4605 [NEON_2RM_VZIP] = 0x7,
4606 [NEON_2RM_VMOVN] = 0x7,
4607 [NEON_2RM_VQMOVN] = 0x7,
4608 [NEON_2RM_VSHLL] = 0x7,
4609 [NEON_2RM_VCVT_F16_F32] = 0x2,
4610 [NEON_2RM_VCVT_F32_F16] = 0x2,
4611 [NEON_2RM_VRECPE] = 0x4,
4612 [NEON_2RM_VRSQRTE] = 0x4,
4613 [NEON_2RM_VRECPE_F] = 0x4,
4614 [NEON_2RM_VRSQRTE_F] = 0x4,
4615 [NEON_2RM_VCVT_FS] = 0x4,
4616 [NEON_2RM_VCVT_FU] = 0x4,
4617 [NEON_2RM_VCVT_SF] = 0x4,
4618 [NEON_2RM_VCVT_UF] = 0x4,
4619 };
4620
4621 /* Translate a NEON data processing instruction. Return nonzero if the
4622 instruction is invalid.
4623 We process data in a mixture of 32-bit and 64-bit chunks.
4624 Mostly we use 32-bit chunks so we can use normal scalar instructions. */
4625
4626 static int disas_neon_data_insn(CPUARMState * env, DisasContext *s, uint32_t insn)
4627 {
4628 int op;
4629 int q;
4630 int rd, rn, rm;
4631 int size;
4632 int shift;
4633 int pass;
4634 int count;
4635 int pairwise;
4636 int u;
4637 uint32_t imm, mask;
4638 TCGv tmp, tmp2, tmp3, tmp4, tmp5;
4639 TCGv_i64 tmp64;
4640
4641 if (!s->vfp_enabled)
4642 return 1;
4643 q = (insn & (1 << 6)) != 0;
4644 u = (insn >> 24) & 1;
4645 VFP_DREG_D(rd, insn);
4646 VFP_DREG_N(rn, insn);
4647 VFP_DREG_M(rm, insn);
4648 size = (insn >> 20) & 3;
4649 if ((insn & (1 << 23)) == 0) {
4650 /* Three register same length. */
4651 op = ((insn >> 7) & 0x1e) | ((insn >> 4) & 1);
4652 /* Catch invalid op and bad size combinations: UNDEF */
4653 if ((neon_3r_sizes[op] & (1 << size)) == 0) {
4654 return 1;
4655 }
4656 /* All insns of this form UNDEF for either this condition or the
4657 * superset of cases "Q==1"; we catch the latter later.
4658 */
4659 if (q && ((rd | rn | rm) & 1)) {
4660 return 1;
4661 }
4662 if (size == 3 && op != NEON_3R_LOGIC) {
4663 /* 64-bit element instructions. */
4664 for (pass = 0; pass < (q ? 2 : 1); pass++) {
4665 neon_load_reg64(cpu_V0, rn + pass);
4666 neon_load_reg64(cpu_V1, rm + pass);
4667 switch (op) {
4668 case NEON_3R_VQADD:
4669 if (u) {
4670 gen_helper_neon_qadd_u64(cpu_V0, cpu_env,
4671 cpu_V0, cpu_V1);
4672 } else {
4673 gen_helper_neon_qadd_s64(cpu_V0, cpu_env,
4674 cpu_V0, cpu_V1);
4675 }
4676 break;
4677 case NEON_3R_VQSUB:
4678 if (u) {
4679 gen_helper_neon_qsub_u64(cpu_V0, cpu_env,
4680 cpu_V0, cpu_V1);
4681 } else {
4682 gen_helper_neon_qsub_s64(cpu_V0, cpu_env,
4683 cpu_V0, cpu_V1);
4684 }
4685 break;
4686 case NEON_3R_VSHL:
4687 if (u) {
4688 gen_helper_neon_shl_u64(cpu_V0, cpu_V1, cpu_V0);
4689 } else {
4690 gen_helper_neon_shl_s64(cpu_V0, cpu_V1, cpu_V0);
4691 }
4692 break;
4693 case NEON_3R_VQSHL:
4694 if (u) {
4695 gen_helper_neon_qshl_u64(cpu_V0, cpu_env,
4696 cpu_V1, cpu_V0);
4697 } else {
4698 gen_helper_neon_qshl_s64(cpu_V0, cpu_env,
4699 cpu_V1, cpu_V0);
4700 }
4701 break;
4702 case NEON_3R_VRSHL:
4703 if (u) {
4704 gen_helper_neon_rshl_u64(cpu_V0, cpu_V1, cpu_V0);
4705 } else {
4706 gen_helper_neon_rshl_s64(cpu_V0, cpu_V1, cpu_V0);
4707 }
4708 break;
4709 case NEON_3R_VQRSHL:
4710 if (u) {
4711 gen_helper_neon_qrshl_u64(cpu_V0, cpu_env,
4712 cpu_V1, cpu_V0);
4713 } else {
4714 gen_helper_neon_qrshl_s64(cpu_V0, cpu_env,
4715 cpu_V1, cpu_V0);
4716 }
4717 break;
4718 case NEON_3R_VADD_VSUB:
4719 if (u) {
4720 tcg_gen_sub_i64(CPU_V001);
4721 } else {
4722 tcg_gen_add_i64(CPU_V001);
4723 }
4724 break;
4725 default:
4726 abort();
4727 }
4728 neon_store_reg64(cpu_V0, rd + pass);
4729 }
4730 return 0;
4731 }
4732 pairwise = 0;
4733 switch (op) {
4734 case NEON_3R_VSHL:
4735 case NEON_3R_VQSHL:
4736 case NEON_3R_VRSHL:
4737 case NEON_3R_VQRSHL:
4738 {
4739 int rtmp;
4740 /* Shift instruction operands are reversed. */
4741 rtmp = rn;
4742 rn = rm;
4743 rm = rtmp;
4744 }
4745 break;
4746 case NEON_3R_VPADD:
4747 if (u) {
4748 return 1;
4749 }
4750 /* Fall through */
4751 case NEON_3R_VPMAX:
4752 case NEON_3R_VPMIN:
4753 pairwise = 1;
4754 break;
4755 case NEON_3R_FLOAT_ARITH:
4756 pairwise = (u && size < 2); /* if VPADD (float) */
4757 break;
4758 case NEON_3R_FLOAT_MINMAX:
4759 pairwise = u; /* if VPMIN/VPMAX (float) */
4760 break;
4761 case NEON_3R_FLOAT_CMP:
4762 if (!u && size) {
4763 /* no encoding for U=0 C=1x */
4764 return 1;
4765 }
4766 break;
4767 case NEON_3R_FLOAT_ACMP:
4768 if (!u) {
4769 return 1;
4770 }
4771 break;
4772 case NEON_3R_VRECPS_VRSQRTS:
4773 if (u) {
4774 return 1;
4775 }
4776 break;
4777 case NEON_3R_VMUL:
4778 if (u && (size != 0)) {
4779 /* UNDEF on invalid size for polynomial subcase */
4780 return 1;
4781 }
4782 break;
4783 case NEON_3R_VFM:
4784 if (!arm_feature(env, ARM_FEATURE_VFP4) || u) {
4785 return 1;
4786 }
4787 break;
4788 default:
4789 break;
4790 }
4791
4792 if (pairwise && q) {
4793 /* All the pairwise insns UNDEF if Q is set */
4794 return 1;
4795 }
4796
4797 for (pass = 0; pass < (q ? 4 : 2); pass++) {
4798
4799 if (pairwise) {
4800 /* Pairwise. */
4801 if (pass < 1) {
4802 tmp = neon_load_reg(rn, 0);
4803 tmp2 = neon_load_reg(rn, 1);
4804 } else {
4805 tmp = neon_load_reg(rm, 0);
4806 tmp2 = neon_load_reg(rm, 1);
4807 }
4808 } else {
4809 /* Elementwise. */
4810 tmp = neon_load_reg(rn, pass);
4811 tmp2 = neon_load_reg(rm, pass);
4812 }
4813 switch (op) {
4814 case NEON_3R_VHADD:
4815 GEN_NEON_INTEGER_OP(hadd);
4816 break;
4817 case NEON_3R_VQADD:
4818 GEN_NEON_INTEGER_OP_ENV(qadd);
4819 break;
4820 case NEON_3R_VRHADD:
4821 GEN_NEON_INTEGER_OP(rhadd);
4822 break;
4823 case NEON_3R_LOGIC: /* Logic ops. */
4824 switch ((u << 2) | size) {
4825 case 0: /* VAND */
4826 tcg_gen_and_i32(tmp, tmp, tmp2);
4827 break;
4828 case 1: /* BIC */
4829 tcg_gen_andc_i32(tmp, tmp, tmp2);
4830 break;
4831 case 2: /* VORR */
4832 tcg_gen_or_i32(tmp, tmp, tmp2);
4833 break;
4834 case 3: /* VORN */
4835 tcg_gen_orc_i32(tmp, tmp, tmp2);
4836 break;
4837 case 4: /* VEOR */
4838 tcg_gen_xor_i32(tmp, tmp, tmp2);
4839 break;
4840 case 5: /* VBSL */
4841 tmp3 = neon_load_reg(rd, pass);
4842 gen_neon_bsl(tmp, tmp, tmp2, tmp3);
4843 tcg_temp_free_i32(tmp3);
4844 break;
4845 case 6: /* VBIT */
4846 tmp3 = neon_load_reg(rd, pass);
4847 gen_neon_bsl(tmp, tmp, tmp3, tmp2);
4848 tcg_temp_free_i32(tmp3);
4849 break;
4850 case 7: /* VBIF */
4851 tmp3 = neon_load_reg(rd, pass);
4852 gen_neon_bsl(tmp, tmp3, tmp, tmp2);
4853 tcg_temp_free_i32(tmp3);
4854 break;
4855 }
4856 break;
4857 case NEON_3R_VHSUB:
4858 GEN_NEON_INTEGER_OP(hsub);
4859 break;
4860 case NEON_3R_VQSUB:
4861 GEN_NEON_INTEGER_OP_ENV(qsub);
4862 break;
4863 case NEON_3R_VCGT:
4864 GEN_NEON_INTEGER_OP(cgt);
4865 break;
4866 case NEON_3R_VCGE:
4867 GEN_NEON_INTEGER_OP(cge);
4868 break;
4869 case NEON_3R_VSHL:
4870 GEN_NEON_INTEGER_OP(shl);
4871 break;
4872 case NEON_3R_VQSHL:
4873 GEN_NEON_INTEGER_OP_ENV(qshl);
4874 break;
4875 case NEON_3R_VRSHL:
4876 GEN_NEON_INTEGER_OP(rshl);
4877 break;
4878 case NEON_3R_VQRSHL:
4879 GEN_NEON_INTEGER_OP_ENV(qrshl);
4880 break;
4881 case NEON_3R_VMAX:
4882 GEN_NEON_INTEGER_OP(max);
4883 break;
4884 case NEON_3R_VMIN:
4885 GEN_NEON_INTEGER_OP(min);
4886 break;
4887 case NEON_3R_VABD:
4888 GEN_NEON_INTEGER_OP(abd);
4889 break;
4890 case NEON_3R_VABA:
4891 GEN_NEON_INTEGER_OP(abd);
4892 tcg_temp_free_i32(tmp2);
4893 tmp2 = neon_load_reg(rd, pass);
4894 gen_neon_add(size, tmp, tmp2);
4895 break;
4896 case NEON_3R_VADD_VSUB:
4897 if (!u) { /* VADD */
4898 gen_neon_add(size, tmp, tmp2);
4899 } else { /* VSUB */
4900 switch (size) {
4901 case 0: gen_helper_neon_sub_u8(tmp, tmp, tmp2); break;
4902 case 1: gen_helper_neon_sub_u16(tmp, tmp, tmp2); break;
4903 case 2: tcg_gen_sub_i32(tmp, tmp, tmp2); break;
4904 default: abort();
4905 }
4906 }
4907 break;
4908 case NEON_3R_VTST_VCEQ:
4909 if (!u) { /* VTST */
4910 switch (size) {
4911 case 0: gen_helper_neon_tst_u8(tmp, tmp, tmp2); break;
4912 case 1: gen_helper_neon_tst_u16(tmp, tmp, tmp2); break;
4913 case 2: gen_helper_neon_tst_u32(tmp, tmp, tmp2); break;
4914 default: abort();
4915 }
4916 } else { /* VCEQ */
4917 switch (size) {
4918 case 0: gen_helper_neon_ceq_u8(tmp, tmp, tmp2); break;
4919 case 1: gen_helper_neon_ceq_u16(tmp, tmp, tmp2); break;
4920 case 2: gen_helper_neon_ceq_u32(tmp, tmp, tmp2); break;
4921 default: abort();
4922 }
4923 }
4924 break;
4925 case NEON_3R_VML: /* VMLA, VMLAL, VMLS,VMLSL */
4926 switch (size) {
4927 case 0: gen_helper_neon_mul_u8(tmp, tmp, tmp2); break;
4928 case 1: gen_helper_neon_mul_u16(tmp, tmp, tmp2); break;
4929 case 2: tcg_gen_mul_i32(tmp, tmp, tmp2); break;
4930 default: abort();
4931 }
4932 tcg_temp_free_i32(tmp2);
4933 tmp2 = neon_load_reg(rd, pass);
4934 if (u) { /* VMLS */
4935 gen_neon_rsb(size, tmp, tmp2);
4936 } else { /* VMLA */
4937 gen_neon_add(size, tmp, tmp2);
4938 }
4939 break;
4940 case NEON_3R_VMUL:
4941 if (u) { /* polynomial */
4942 gen_helper_neon_mul_p8(tmp, tmp, tmp2);
4943 } else { /* Integer */
4944 switch (size) {
4945 case 0: gen_helper_neon_mul_u8(tmp, tmp, tmp2); break;
4946 case 1: gen_helper_neon_mul_u16(tmp, tmp, tmp2); break;
4947 case 2: tcg_gen_mul_i32(tmp, tmp, tmp2); break;
4948 default: abort();
4949 }
4950 }
4951 break;
4952 case NEON_3R_VPMAX:
4953 GEN_NEON_INTEGER_OP(pmax);
4954 break;
4955 case NEON_3R_VPMIN:
4956 GEN_NEON_INTEGER_OP(pmin);
4957 break;
4958 case NEON_3R_VQDMULH_VQRDMULH: /* Multiply high. */
4959 if (!u) { /* VQDMULH */
4960 switch (size) {
4961 case 1:
4962 gen_helper_neon_qdmulh_s16(tmp, cpu_env, tmp, tmp2);
4963 break;
4964 case 2:
4965 gen_helper_neon_qdmulh_s32(tmp, cpu_env, tmp, tmp2);
4966 break;
4967 default: abort();
4968 }
4969 } else { /* VQRDMULH */
4970 switch (size) {
4971 case 1:
4972 gen_helper_neon_qrdmulh_s16(tmp, cpu_env, tmp, tmp2);
4973 break;
4974 case 2:
4975 gen_helper_neon_qrdmulh_s32(tmp, cpu_env, tmp, tmp2);
4976 break;
4977 default: abort();
4978 }
4979 }
4980 break;
4981 case NEON_3R_VPADD:
4982 switch (size) {
4983 case 0: gen_helper_neon_padd_u8(tmp, tmp, tmp2); break;
4984 case 1: gen_helper_neon_padd_u16(tmp, tmp, tmp2); break;
4985 case 2: tcg_gen_add_i32(tmp, tmp, tmp2); break;
4986 default: abort();
4987 }
4988 break;
4989 case NEON_3R_FLOAT_ARITH: /* Floating point arithmetic. */
4990 {
4991 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
4992 switch ((u << 2) | size) {
4993 case 0: /* VADD */
4994 case 4: /* VPADD */
4995 gen_helper_vfp_adds(tmp, tmp, tmp2, fpstatus);
4996 break;
4997 case 2: /* VSUB */
4998 gen_helper_vfp_subs(tmp, tmp, tmp2, fpstatus);
4999 break;
5000 case 6: /* VABD */
5001 gen_helper_neon_abd_f32(tmp, tmp, tmp2, fpstatus);
5002 break;
5003 default:
5004 abort();
5005 }
5006 tcg_temp_free_ptr(fpstatus);
5007 break;
5008 }
5009 case NEON_3R_FLOAT_MULTIPLY:
5010 {
5011 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5012 gen_helper_vfp_muls(tmp, tmp, tmp2, fpstatus);
5013 if (!u) {
5014 tcg_temp_free_i32(tmp2);
5015 tmp2 = neon_load_reg(rd, pass);
5016 if (size == 0) {
5017 gen_helper_vfp_adds(tmp, tmp, tmp2, fpstatus);
5018 } else {
5019 gen_helper_vfp_subs(tmp, tmp2, tmp, fpstatus);
5020 }
5021 }
5022 tcg_temp_free_ptr(fpstatus);
5023 break;
5024 }
5025 case NEON_3R_FLOAT_CMP:
5026 {
5027 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5028 if (!u) {
5029 gen_helper_neon_ceq_f32(tmp, tmp, tmp2, fpstatus);
5030 } else {
5031 if (size == 0) {
5032 gen_helper_neon_cge_f32(tmp, tmp, tmp2, fpstatus);
5033 } else {
5034 gen_helper_neon_cgt_f32(tmp, tmp, tmp2, fpstatus);
5035 }
5036 }
5037 tcg_temp_free_ptr(fpstatus);
5038 break;
5039 }
5040 case NEON_3R_FLOAT_ACMP:
5041 {
5042 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5043 if (size == 0) {
5044 gen_helper_neon_acge_f32(tmp, tmp, tmp2, fpstatus);
5045 } else {
5046 gen_helper_neon_acgt_f32(tmp, tmp, tmp2, fpstatus);
5047 }
5048 tcg_temp_free_ptr(fpstatus);
5049 break;
5050 }
5051 case NEON_3R_FLOAT_MINMAX:
5052 {
5053 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5054 if (size == 0) {
5055 gen_helper_neon_max_f32(tmp, tmp, tmp2, fpstatus);
5056 } else {
5057 gen_helper_neon_min_f32(tmp, tmp, tmp2, fpstatus);
5058 }
5059 tcg_temp_free_ptr(fpstatus);
5060 break;
5061 }
5062 case NEON_3R_VRECPS_VRSQRTS:
5063 if (size == 0)
5064 gen_helper_recps_f32(tmp, tmp, tmp2, cpu_env);
5065 else
5066 gen_helper_rsqrts_f32(tmp, tmp, tmp2, cpu_env);
5067 break;
5068 case NEON_3R_VFM:
5069 {
5070 /* VFMA, VFMS: fused multiply-add */
5071 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5072 TCGv_i32 tmp3 = neon_load_reg(rd, pass);
5073 if (size) {
5074 /* VFMS */
5075 gen_helper_vfp_negs(tmp, tmp);
5076 }
5077 gen_helper_vfp_muladds(tmp, tmp, tmp2, tmp3, fpstatus);
5078 tcg_temp_free_i32(tmp3);
5079 tcg_temp_free_ptr(fpstatus);
5080 break;
5081 }
5082 default:
5083 abort();
5084 }
5085 tcg_temp_free_i32(tmp2);
5086
5087 /* Save the result. For elementwise operations we can put it
5088 straight into the destination register. For pairwise operations
5089 we have to be careful to avoid clobbering the source operands. */
5090 if (pairwise && rd == rm) {
5091 neon_store_scratch(pass, tmp);
5092 } else {
5093 neon_store_reg(rd, pass, tmp);
5094 }
5095
5096 } /* for pass */
5097 if (pairwise && rd == rm) {
5098 for (pass = 0; pass < (q ? 4 : 2); pass++) {
5099 tmp = neon_load_scratch(pass);
5100 neon_store_reg(rd, pass, tmp);
5101 }
5102 }
5103 /* End of 3 register same size operations. */
5104 } else if (insn & (1 << 4)) {
5105 if ((insn & 0x00380080) != 0) {
5106 /* Two registers and shift. */
5107 op = (insn >> 8) & 0xf;
5108 if (insn & (1 << 7)) {
5109 /* 64-bit shift. */
5110 if (op > 7) {
5111 return 1;
5112 }
5113 size = 3;
5114 } else {
5115 size = 2;
5116 while ((insn & (1 << (size + 19))) == 0)
5117 size--;
5118 }
5119 shift = (insn >> 16) & ((1 << (3 + size)) - 1);
5120 /* To avoid excessive dumplication of ops we implement shift
5121 by immediate using the variable shift operations. */
5122 if (op < 8) {
5123 /* Shift by immediate:
5124 VSHR, VSRA, VRSHR, VRSRA, VSRI, VSHL, VQSHL, VQSHLU. */
5125 if (q && ((rd | rm) & 1)) {
5126 return 1;
5127 }
5128 if (!u && (op == 4 || op == 6)) {
5129 return 1;
5130 }
5131 /* Right shifts are encoded as N - shift, where N is the
5132 element size in bits. */
5133 if (op <= 4)
5134 shift = shift - (1 << (size + 3));
5135 if (size == 3) {
5136 count = q + 1;
5137 } else {
5138 count = q ? 4: 2;
5139 }
5140 switch (size) {
5141 case 0:
5142 imm = (uint8_t) shift;
5143 imm |= imm << 8;
5144 imm |= imm << 16;
5145 break;
5146 case 1:
5147 imm = (uint16_t) shift;
5148 imm |= imm << 16;
5149 break;
5150 case 2:
5151 case 3:
5152 imm = shift;
5153 break;
5154 default:
5155 abort();
5156 }
5157
5158 for (pass = 0; pass < count; pass++) {
5159 if (size == 3) {
5160 neon_load_reg64(cpu_V0, rm + pass);
5161 tcg_gen_movi_i64(cpu_V1, imm);
5162 switch (op) {
5163 case 0: /* VSHR */
5164 case 1: /* VSRA */
5165 if (u)
5166 gen_helper_neon_shl_u64(cpu_V0, cpu_V0, cpu_V1);
5167 else
5168 gen_helper_neon_shl_s64(cpu_V0, cpu_V0, cpu_V1);
5169 break;
5170 case 2: /* VRSHR */
5171 case 3: /* VRSRA */
5172 if (u)
5173 gen_helper_neon_rshl_u64(cpu_V0, cpu_V0, cpu_V1);
5174 else
5175 gen_helper_neon_rshl_s64(cpu_V0, cpu_V0, cpu_V1);
5176 break;
5177 case 4: /* VSRI */
5178 case 5: /* VSHL, VSLI */
5179 gen_helper_neon_shl_u64(cpu_V0, cpu_V0, cpu_V1);
5180 break;
5181 case 6: /* VQSHLU */
5182 gen_helper_neon_qshlu_s64(cpu_V0, cpu_env,
5183 cpu_V0, cpu_V1);
5184 break;
5185 case 7: /* VQSHL */
5186 if (u) {
5187 gen_helper_neon_qshl_u64(cpu_V0, cpu_env,
5188 cpu_V0, cpu_V1);
5189 } else {
5190 gen_helper_neon_qshl_s64(cpu_V0, cpu_env,
5191 cpu_V0, cpu_V1);
5192 }
5193 break;
5194 }
5195 if (op == 1 || op == 3) {
5196 /* Accumulate. */
5197 neon_load_reg64(cpu_V1, rd + pass);
5198 tcg_gen_add_i64(cpu_V0, cpu_V0, cpu_V1);
5199 } else if (op == 4 || (op == 5 && u)) {
5200 /* Insert */
5201 neon_load_reg64(cpu_V1, rd + pass);
5202 uint64_t mask;
5203 if (shift < -63 || shift > 63) {
5204 mask = 0;
5205 } else {
5206 if (op == 4) {
5207 mask = 0xffffffffffffffffull >> -shift;
5208 } else {
5209 mask = 0xffffffffffffffffull << shift;
5210 }
5211 }
5212 tcg_gen_andi_i64(cpu_V1, cpu_V1, ~mask);
5213 tcg_gen_or_i64(cpu_V0, cpu_V0, cpu_V1);
5214 }
5215 neon_store_reg64(cpu_V0, rd + pass);
5216 } else { /* size < 3 */
5217 /* Operands in T0 and T1. */
5218 tmp = neon_load_reg(rm, pass);
5219 tmp2 = tcg_temp_new_i32();
5220 tcg_gen_movi_i32(tmp2, imm);
5221 switch (op) {
5222 case 0: /* VSHR */
5223 case 1: /* VSRA */
5224 GEN_NEON_INTEGER_OP(shl);
5225 break;
5226 case 2: /* VRSHR */
5227 case 3: /* VRSRA */
5228 GEN_NEON_INTEGER_OP(rshl);
5229 break;
5230 case 4: /* VSRI */
5231 case 5: /* VSHL, VSLI */
5232 switch (size) {
5233 case 0: gen_helper_neon_shl_u8(tmp, tmp, tmp2); break;
5234 case 1: gen_helper_neon_shl_u16(tmp, tmp, tmp2); break;
5235 case 2: gen_helper_neon_shl_u32(tmp, tmp, tmp2); break;
5236 default: abort();
5237 }
5238 break;
5239 case 6: /* VQSHLU */
5240 switch (size) {
5241 case 0:
5242 gen_helper_neon_qshlu_s8(tmp, cpu_env,
5243 tmp, tmp2);
5244 break;
5245 case 1:
5246 gen_helper_neon_qshlu_s16(tmp, cpu_env,
5247 tmp, tmp2);
5248 break;
5249 case 2:
5250 gen_helper_neon_qshlu_s32(tmp, cpu_env,
5251 tmp, tmp2);
5252 break;
5253 default:
5254 abort();
5255 }
5256 break;
5257 case 7: /* VQSHL */
5258 GEN_NEON_INTEGER_OP_ENV(qshl);
5259 break;
5260 }
5261 tcg_temp_free_i32(tmp2);
5262
5263 if (op == 1 || op == 3) {
5264 /* Accumulate. */
5265 tmp2 = neon_load_reg(rd, pass);
5266 gen_neon_add(size, tmp, tmp2);
5267 tcg_temp_free_i32(tmp2);
5268 } else if (op == 4 || (op == 5 && u)) {
5269 /* Insert */
5270 switch (size) {
5271 case 0:
5272 if (op == 4)
5273 mask = 0xff >> -shift;
5274 else
5275 mask = (uint8_t)(0xff << shift);
5276 mask |= mask << 8;
5277 mask |= mask << 16;
5278 break;
5279 case 1:
5280 if (op == 4)
5281 mask = 0xffff >> -shift;
5282 else
5283 mask = (uint16_t)(0xffff << shift);
5284 mask |= mask << 16;
5285 break;
5286 case 2:
5287 if (shift < -31 || shift > 31) {
5288 mask = 0;
5289 } else {
5290 if (op == 4)
5291 mask = 0xffffffffu >> -shift;
5292 else
5293 mask = 0xffffffffu << shift;
5294 }
5295 break;
5296 default:
5297 abort();
5298 }
5299 tmp2 = neon_load_reg(rd, pass);
5300 tcg_gen_andi_i32(tmp, tmp, mask);
5301 tcg_gen_andi_i32(tmp2, tmp2, ~mask);
5302 tcg_gen_or_i32(tmp, tmp, tmp2);
5303 tcg_temp_free_i32(tmp2);
5304 }
5305 neon_store_reg(rd, pass, tmp);
5306 }
5307 } /* for pass */
5308 } else if (op < 10) {
5309 /* Shift by immediate and narrow:
5310 VSHRN, VRSHRN, VQSHRN, VQRSHRN. */
5311 int input_unsigned = (op == 8) ? !u : u;
5312 if (rm & 1) {
5313 return 1;
5314 }
5315 shift = shift - (1 << (size + 3));
5316 size++;
5317 if (size == 3) {
5318 tmp64 = tcg_const_i64(shift);
5319 neon_load_reg64(cpu_V0, rm);
5320 neon_load_reg64(cpu_V1, rm + 1);
5321 for (pass = 0; pass < 2; pass++) {
5322 TCGv_i64 in;
5323 if (pass == 0) {
5324 in = cpu_V0;
5325 } else {
5326 in = cpu_V1;
5327 }
5328 if (q) {
5329 if (input_unsigned) {
5330 gen_helper_neon_rshl_u64(cpu_V0, in, tmp64);
5331 } else {
5332 gen_helper_neon_rshl_s64(cpu_V0, in, tmp64);
5333 }
5334 } else {
5335 if (input_unsigned) {
5336 gen_helper_neon_shl_u64(cpu_V0, in, tmp64);
5337 } else {
5338 gen_helper_neon_shl_s64(cpu_V0, in, tmp64);
5339 }
5340 }
5341 tmp = tcg_temp_new_i32();
5342 gen_neon_narrow_op(op == 8, u, size - 1, tmp, cpu_V0);
5343 neon_store_reg(rd, pass, tmp);
5344 } /* for pass */
5345 tcg_temp_free_i64(tmp64);
5346 } else {
5347 if (size == 1) {
5348 imm = (uint16_t)shift;
5349 imm |= imm << 16;
5350 } else {
5351 /* size == 2 */
5352 imm = (uint32_t)shift;
5353 }
5354 tmp2 = tcg_const_i32(imm);
5355 tmp4 = neon_load_reg(rm + 1, 0);
5356 tmp5 = neon_load_reg(rm + 1, 1);
5357 for (pass = 0; pass < 2; pass++) {
5358 if (pass == 0) {
5359 tmp = neon_load_reg(rm, 0);
5360 } else {
5361 tmp = tmp4;
5362 }
5363 gen_neon_shift_narrow(size, tmp, tmp2, q,
5364 input_unsigned);
5365 if (pass == 0) {
5366 tmp3 = neon_load_reg(rm, 1);
5367 } else {
5368 tmp3 = tmp5;
5369 }
5370 gen_neon_shift_narrow(size, tmp3, tmp2, q,
5371 input_unsigned);
5372 tcg_gen_concat_i32_i64(cpu_V0, tmp, tmp3);
5373 tcg_temp_free_i32(tmp);
5374 tcg_temp_free_i32(tmp3);
5375 tmp = tcg_temp_new_i32();
5376 gen_neon_narrow_op(op == 8, u, size - 1, tmp, cpu_V0);
5377 neon_store_reg(rd, pass, tmp);
5378 } /* for pass */
5379 tcg_temp_free_i32(tmp2);
5380 }
5381 } else if (op == 10) {
5382 /* VSHLL, VMOVL */
5383 if (q || (rd & 1)) {
5384 return 1;
5385 }
5386 tmp = neon_load_reg(rm, 0);
5387 tmp2 = neon_load_reg(rm, 1);
5388 for (pass = 0; pass < 2; pass++) {
5389 if (pass == 1)
5390 tmp = tmp2;
5391
5392 gen_neon_widen(cpu_V0, tmp, size, u);
5393
5394 if (shift != 0) {
5395 /* The shift is less than the width of the source
5396 type, so we can just shift the whole register. */
5397 tcg_gen_shli_i64(cpu_V0, cpu_V0, shift);
5398 /* Widen the result of shift: we need to clear
5399 * the potential overflow bits resulting from
5400 * left bits of the narrow input appearing as
5401 * right bits of left the neighbour narrow
5402 * input. */
5403 if (size < 2 || !u) {
5404 uint64_t imm64;
5405 if (size == 0) {
5406 imm = (0xffu >> (8 - shift));
5407 imm |= imm << 16;
5408 } else if (size == 1) {
5409 imm = 0xffff >> (16 - shift);
5410 } else {
5411 /* size == 2 */
5412 imm = 0xffffffff >> (32 - shift);
5413 }
5414 if (size < 2) {
5415 imm64 = imm | (((uint64_t)imm) << 32);
5416 } else {
5417 imm64 = imm;
5418 }
5419 tcg_gen_andi_i64(cpu_V0, cpu_V0, ~imm64);
5420 }
5421 }
5422 neon_store_reg64(cpu_V0, rd + pass);
5423 }
5424 } else if (op >= 14) {
5425 /* VCVT fixed-point. */
5426 if (!(insn & (1 << 21)) || (q && ((rd | rm) & 1))) {
5427 return 1;
5428 }
5429 /* We have already masked out the must-be-1 top bit of imm6,
5430 * hence this 32-shift where the ARM ARM has 64-imm6.
5431 */
5432 shift = 32 - shift;
5433 for (pass = 0; pass < (q ? 4 : 2); pass++) {
5434 tcg_gen_ld_f32(cpu_F0s, cpu_env, neon_reg_offset(rm, pass));
5435 if (!(op & 1)) {
5436 if (u)
5437 gen_vfp_ulto(0, shift, 1);
5438 else
5439 gen_vfp_slto(0, shift, 1);
5440 } else {
5441 if (u)
5442 gen_vfp_toul(0, shift, 1);
5443 else
5444 gen_vfp_tosl(0, shift, 1);
5445 }
5446 tcg_gen_st_f32(cpu_F0s, cpu_env, neon_reg_offset(rd, pass));
5447 }
5448 } else {
5449 return 1;
5450 }
5451 } else { /* (insn & 0x00380080) == 0 */
5452 int invert;
5453 if (q && (rd & 1)) {
5454 return 1;
5455 }
5456
5457 op = (insn >> 8) & 0xf;
5458 /* One register and immediate. */
5459 imm = (u << 7) | ((insn >> 12) & 0x70) | (insn & 0xf);
5460 invert = (insn & (1 << 5)) != 0;
5461 /* Note that op = 2,3,4,5,6,7,10,11,12,13 imm=0 is UNPREDICTABLE.
5462 * We choose to not special-case this and will behave as if a
5463 * valid constant encoding of 0 had been given.
5464 */
5465 switch (op) {
5466 case 0: case 1:
5467 /* no-op */
5468 break;
5469 case 2: case 3:
5470 imm <<= 8;
5471 break;
5472 case 4: case 5:
5473 imm <<= 16;
5474 break;
5475 case 6: case 7:
5476 imm <<= 24;
5477 break;
5478 case 8: case 9:
5479 imm |= imm << 16;
5480 break;
5481 case 10: case 11:
5482 imm = (imm << 8) | (imm << 24);
5483 break;
5484 case 12:
5485 imm = (imm << 8) | 0xff;
5486 break;
5487 case 13:
5488 imm = (imm << 16) | 0xffff;
5489 break;
5490 case 14:
5491 imm |= (imm << 8) | (imm << 16) | (imm << 24);
5492 if (invert)
5493 imm = ~imm;
5494 break;
5495 case 15:
5496 if (invert) {
5497 return 1;
5498 }
5499 imm = ((imm & 0x80) << 24) | ((imm & 0x3f) << 19)
5500 | ((imm & 0x40) ? (0x1f << 25) : (1 << 30));
5501 break;
5502 }
5503 if (invert)
5504 imm = ~imm;
5505
5506 for (pass = 0; pass < (q ? 4 : 2); pass++) {
5507 if (op & 1 && op < 12) {
5508 tmp = neon_load_reg(rd, pass);
5509 if (invert) {
5510 /* The immediate value has already been inverted, so
5511 BIC becomes AND. */
5512 tcg_gen_andi_i32(tmp, tmp, imm);
5513 } else {
5514 tcg_gen_ori_i32(tmp, tmp, imm);
5515 }
5516 } else {
5517 /* VMOV, VMVN. */
5518 tmp = tcg_temp_new_i32();
5519 if (op == 14 && invert) {
5520 int n;
5521 uint32_t val;
5522 val = 0;
5523 for (n = 0; n < 4; n++) {
5524 if (imm & (1 << (n + (pass & 1) * 4)))
5525 val |= 0xff << (n * 8);
5526 }
5527 tcg_gen_movi_i32(tmp, val);
5528 } else {
5529 tcg_gen_movi_i32(tmp, imm);
5530 }
5531 }
5532 neon_store_reg(rd, pass, tmp);
5533 }
5534 }
5535 } else { /* (insn & 0x00800010 == 0x00800000) */
5536 if (size != 3) {
5537 op = (insn >> 8) & 0xf;
5538 if ((insn & (1 << 6)) == 0) {
5539 /* Three registers of different lengths. */
5540 int src1_wide;
5541 int src2_wide;
5542 int prewiden;
5543 /* undefreq: bit 0 : UNDEF if size != 0
5544 * bit 1 : UNDEF if size == 0
5545 * bit 2 : UNDEF if U == 1
5546 * Note that [1:0] set implies 'always UNDEF'
5547 */
5548 int undefreq;
5549 /* prewiden, src1_wide, src2_wide, undefreq */
5550 static const int neon_3reg_wide[16][4] = {
5551 {1, 0, 0, 0}, /* VADDL */
5552 {1, 1, 0, 0}, /* VADDW */
5553 {1, 0, 0, 0}, /* VSUBL */
5554 {1, 1, 0, 0}, /* VSUBW */
5555 {0, 1, 1, 0}, /* VADDHN */
5556 {0, 0, 0, 0}, /* VABAL */
5557 {0, 1, 1, 0}, /* VSUBHN */
5558 {0, 0, 0, 0}, /* VABDL */
5559 {0, 0, 0, 0}, /* VMLAL */
5560 {0, 0, 0, 6}, /* VQDMLAL */
5561 {0, 0, 0, 0}, /* VMLSL */
5562 {0, 0, 0, 6}, /* VQDMLSL */
5563 {0, 0, 0, 0}, /* Integer VMULL */
5564 {0, 0, 0, 2}, /* VQDMULL */
5565 {0, 0, 0, 5}, /* Polynomial VMULL */
5566 {0, 0, 0, 3}, /* Reserved: always UNDEF */
5567 };
5568
5569 prewiden = neon_3reg_wide[op][0];
5570 src1_wide = neon_3reg_wide[op][1];
5571 src2_wide = neon_3reg_wide[op][2];
5572 undefreq = neon_3reg_wide[op][3];
5573
5574 if (((undefreq & 1) && (size != 0)) ||
5575 ((undefreq & 2) && (size == 0)) ||
5576 ((undefreq & 4) && u)) {
5577 return 1;
5578 }
5579 if ((src1_wide && (rn & 1)) ||
5580 (src2_wide && (rm & 1)) ||
5581 (!src2_wide && (rd & 1))) {
5582 return 1;
5583 }
5584
5585 /* Avoid overlapping operands. Wide source operands are
5586 always aligned so will never overlap with wide
5587 destinations in problematic ways. */
5588 if (rd == rm && !src2_wide) {
5589 tmp = neon_load_reg(rm, 1);
5590 neon_store_scratch(2, tmp);
5591 } else if (rd == rn && !src1_wide) {
5592 tmp = neon_load_reg(rn, 1);
5593 neon_store_scratch(2, tmp);
5594 }
5595 TCGV_UNUSED(tmp3);
5596 for (pass = 0; pass < 2; pass++) {
5597 if (src1_wide) {
5598 neon_load_reg64(cpu_V0, rn + pass);
5599 TCGV_UNUSED(tmp);
5600 } else {
5601 if (pass == 1 && rd == rn) {
5602 tmp = neon_load_scratch(2);
5603 } else {
5604 tmp = neon_load_reg(rn, pass);
5605 }
5606 if (prewiden) {
5607 gen_neon_widen(cpu_V0, tmp, size, u);
5608 }
5609 }
5610 if (src2_wide) {
5611 neon_load_reg64(cpu_V1, rm + pass);
5612 TCGV_UNUSED(tmp2);
5613 } else {
5614 if (pass == 1 && rd == rm) {
5615 tmp2 = neon_load_scratch(2);
5616 } else {
5617 tmp2 = neon_load_reg(rm, pass);
5618 }
5619 if (prewiden) {
5620 gen_neon_widen(cpu_V1, tmp2, size, u);
5621 }
5622 }
5623 switch (op) {
5624 case 0: case 1: case 4: /* VADDL, VADDW, VADDHN, VRADDHN */
5625 gen_neon_addl(size);
5626 break;
5627 case 2: case 3: case 6: /* VSUBL, VSUBW, VSUBHN, VRSUBHN */
5628 gen_neon_subl(size);
5629 break;
5630 case 5: case 7: /* VABAL, VABDL */
5631 switch ((size << 1) | u) {
5632 case 0:
5633 gen_helper_neon_abdl_s16(cpu_V0, tmp, tmp2);
5634 break;
5635 case 1:
5636 gen_helper_neon_abdl_u16(cpu_V0, tmp, tmp2);
5637 break;
5638 case 2:
5639 gen_helper_neon_abdl_s32(cpu_V0, tmp, tmp2);
5640 break;
5641 case 3:
5642 gen_helper_neon_abdl_u32(cpu_V0, tmp, tmp2);
5643 break;
5644 case 4:
5645 gen_helper_neon_abdl_s64(cpu_V0, tmp, tmp2);
5646 break;
5647 case 5:
5648 gen_helper_neon_abdl_u64(cpu_V0, tmp, tmp2);
5649 break;
5650 default: abort();
5651 }
5652 tcg_temp_free_i32(tmp2);
5653 tcg_temp_free_i32(tmp);
5654 break;
5655 case 8: case 9: case 10: case 11: case 12: case 13:
5656 /* VMLAL, VQDMLAL, VMLSL, VQDMLSL, VMULL, VQDMULL */
5657 gen_neon_mull(cpu_V0, tmp, tmp2, size, u);
5658 break;
5659 case 14: /* Polynomial VMULL */
5660 gen_helper_neon_mull_p8(cpu_V0, tmp, tmp2);
5661 tcg_temp_free_i32(tmp2);
5662 tcg_temp_free_i32(tmp);
5663 break;
5664 default: /* 15 is RESERVED: caught earlier */
5665 abort();
5666 }
5667 if (op == 13) {
5668 /* VQDMULL */
5669 gen_neon_addl_saturate(cpu_V0, cpu_V0, size);
5670 neon_store_reg64(cpu_V0, rd + pass);
5671 } else if (op == 5 || (op >= 8 && op <= 11)) {
5672 /* Accumulate. */
5673 neon_load_reg64(cpu_V1, rd + pass);
5674 switch (op) {
5675 case 10: /* VMLSL */
5676 gen_neon_negl(cpu_V0, size);
5677 /* Fall through */
5678 case 5: case 8: /* VABAL, VMLAL */
5679 gen_neon_addl(size);
5680 break;
5681 case 9: case 11: /* VQDMLAL, VQDMLSL */
5682 gen_neon_addl_saturate(cpu_V0, cpu_V0, size);
5683 if (op == 11) {
5684 gen_neon_negl(cpu_V0, size);
5685 }
5686 gen_neon_addl_saturate(cpu_V0, cpu_V1, size);
5687 break;
5688 default:
5689 abort();
5690 }
5691 neon_store_reg64(cpu_V0, rd + pass);
5692 } else if (op == 4 || op == 6) {
5693 /* Narrowing operation. */
5694 tmp = tcg_temp_new_i32();
5695 if (!u) {
5696 switch (size) {
5697 case 0:
5698 gen_helper_neon_narrow_high_u8(tmp, cpu_V0);
5699 break;
5700 case 1:
5701 gen_helper_neon_narrow_high_u16(tmp, cpu_V0);
5702 break;
5703 case 2:
5704 tcg_gen_shri_i64(cpu_V0, cpu_V0, 32);
5705 tcg_gen_trunc_i64_i32(tmp, cpu_V0);
5706 break;
5707 default: abort();
5708 }
5709 } else {
5710 switch (size) {
5711 case 0:
5712 gen_helper_neon_narrow_round_high_u8(tmp, cpu_V0);
5713 break;
5714 case 1:
5715 gen_helper_neon_narrow_round_high_u16(tmp, cpu_V0);
5716 break;
5717 case 2:
5718 tcg_gen_addi_i64(cpu_V0, cpu_V0, 1u << 31);
5719 tcg_gen_shri_i64(cpu_V0, cpu_V0, 32);
5720 tcg_gen_trunc_i64_i32(tmp, cpu_V0);
5721 break;
5722 default: abort();
5723 }
5724 }
5725 if (pass == 0) {
5726 tmp3 = tmp;
5727 } else {
5728 neon_store_reg(rd, 0, tmp3);
5729 neon_store_reg(rd, 1, tmp);
5730 }
5731 } else {
5732 /* Write back the result. */
5733 neon_store_reg64(cpu_V0, rd + pass);
5734 }
5735 }
5736 } else {
5737 /* Two registers and a scalar. NB that for ops of this form
5738 * the ARM ARM labels bit 24 as Q, but it is in our variable
5739 * 'u', not 'q'.
5740 */
5741 if (size == 0) {
5742 return 1;
5743 }
5744 switch (op) {
5745 case 1: /* Float VMLA scalar */
5746 case 5: /* Floating point VMLS scalar */
5747 case 9: /* Floating point VMUL scalar */
5748 if (size == 1) {
5749 return 1;
5750 }
5751 /* fall through */
5752 case 0: /* Integer VMLA scalar */
5753 case 4: /* Integer VMLS scalar */
5754 case 8: /* Integer VMUL scalar */
5755 case 12: /* VQDMULH scalar */
5756 case 13: /* VQRDMULH scalar */
5757 if (u && ((rd | rn) & 1)) {
5758 return 1;
5759 }
5760 tmp = neon_get_scalar(size, rm);
5761 neon_store_scratch(0, tmp);
5762 for (pass = 0; pass < (u ? 4 : 2); pass++) {
5763 tmp = neon_load_scratch(0);
5764 tmp2 = neon_load_reg(rn, pass);
5765 if (op == 12) {
5766 if (size == 1) {
5767 gen_helper_neon_qdmulh_s16(tmp, cpu_env, tmp, tmp2);
5768 } else {
5769 gen_helper_neon_qdmulh_s32(tmp, cpu_env, tmp, tmp2);
5770 }
5771 } else if (op == 13) {
5772 if (size == 1) {
5773 gen_helper_neon_qrdmulh_s16(tmp, cpu_env, tmp, tmp2);
5774 } else {
5775 gen_helper_neon_qrdmulh_s32(tmp, cpu_env, tmp, tmp2);
5776 }
5777 } else if (op & 1) {
5778 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5779 gen_helper_vfp_muls(tmp, tmp, tmp2, fpstatus);
5780 tcg_temp_free_ptr(fpstatus);
5781 } else {
5782 switch (size) {
5783 case 0: gen_helper_neon_mul_u8(tmp, tmp, tmp2); break;
5784 case 1: gen_helper_neon_mul_u16(tmp, tmp, tmp2); break;
5785 case 2: tcg_gen_mul_i32(tmp, tmp, tmp2); break;
5786 default: abort();
5787 }
5788 }
5789 tcg_temp_free_i32(tmp2);
5790 if (op < 8) {
5791 /* Accumulate. */
5792 tmp2 = neon_load_reg(rd, pass);
5793 switch (op) {
5794 case 0:
5795 gen_neon_add(size, tmp, tmp2);
5796 break;
5797 case 1:
5798 {
5799 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5800 gen_helper_vfp_adds(tmp, tmp, tmp2, fpstatus);
5801 tcg_temp_free_ptr(fpstatus);
5802 break;
5803 }
5804 case 4:
5805 gen_neon_rsb(size, tmp, tmp2);
5806 break;
5807 case 5:
5808 {
5809 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5810 gen_helper_vfp_subs(tmp, tmp2, tmp, fpstatus);
5811 tcg_temp_free_ptr(fpstatus);
5812 break;
5813 }
5814 default:
5815 abort();
5816 }
5817 tcg_temp_free_i32(tmp2);
5818 }
5819 neon_store_reg(rd, pass, tmp);
5820 }
5821 break;
5822 case 3: /* VQDMLAL scalar */
5823 case 7: /* VQDMLSL scalar */
5824 case 11: /* VQDMULL scalar */
5825 if (u == 1) {
5826 return 1;
5827 }
5828 /* fall through */
5829 case 2: /* VMLAL sclar */
5830 case 6: /* VMLSL scalar */
5831 case 10: /* VMULL scalar */
5832 if (rd & 1) {
5833 return 1;
5834 }
5835 tmp2 = neon_get_scalar(size, rm);
5836 /* We need a copy of tmp2 because gen_neon_mull
5837 * deletes it during pass 0. */
5838 tmp4 = tcg_temp_new_i32();
5839 tcg_gen_mov_i32(tmp4, tmp2);
5840 tmp3 = neon_load_reg(rn, 1);
5841
5842 for (pass = 0; pass < 2; pass++) {
5843 if (pass == 0) {
5844 tmp = neon_load_reg(rn, 0);
5845 } else {
5846 tmp = tmp3;
5847 tmp2 = tmp4;
5848 }
5849 gen_neon_mull(cpu_V0, tmp, tmp2, size, u);
5850 if (op != 11) {
5851 neon_load_reg64(cpu_V1, rd + pass);
5852 }
5853 switch (op) {
5854 case 6:
5855 gen_neon_negl(cpu_V0, size);
5856 /* Fall through */
5857 case 2:
5858 gen_neon_addl(size);
5859 break;
5860 case 3: case 7:
5861 gen_neon_addl_saturate(cpu_V0, cpu_V0, size);
5862 if (op == 7) {
5863 gen_neon_negl(cpu_V0, size);
5864 }
5865 gen_neon_addl_saturate(cpu_V0, cpu_V1, size);
5866 break;
5867 case 10:
5868 /* no-op */
5869 break;
5870 case 11:
5871 gen_neon_addl_saturate(cpu_V0, cpu_V0, size);
5872 break;
5873 default:
5874 abort();
5875 }
5876 neon_store_reg64(cpu_V0, rd + pass);
5877 }
5878
5879
5880 break;
5881 default: /* 14 and 15 are RESERVED */
5882 return 1;
5883 }
5884 }
5885 } else { /* size == 3 */
5886 if (!u) {
5887 /* Extract. */
5888 imm = (insn >> 8) & 0xf;
5889
5890 if (imm > 7 && !q)
5891 return 1;
5892
5893 if (q && ((rd | rn | rm) & 1)) {
5894 return 1;
5895 }
5896
5897 if (imm == 0) {
5898 neon_load_reg64(cpu_V0, rn);
5899 if (q) {
5900 neon_load_reg64(cpu_V1, rn + 1);
5901 }
5902 } else if (imm == 8) {
5903 neon_load_reg64(cpu_V0, rn + 1);
5904 if (q) {
5905 neon_load_reg64(cpu_V1, rm);
5906 }
5907 } else if (q) {
5908 tmp64 = tcg_temp_new_i64();
5909 if (imm < 8) {
5910 neon_load_reg64(cpu_V0, rn);
5911 neon_load_reg64(tmp64, rn + 1);
5912 } else {
5913 neon_load_reg64(cpu_V0, rn + 1);
5914 neon_load_reg64(tmp64, rm);
5915 }
5916 tcg_gen_shri_i64(cpu_V0, cpu_V0, (imm & 7) * 8);
5917 tcg_gen_shli_i64(cpu_V1, tmp64, 64 - ((imm & 7) * 8));
5918 tcg_gen_or_i64(cpu_V0, cpu_V0, cpu_V1);
5919 if (imm < 8) {
5920 neon_load_reg64(cpu_V1, rm);
5921 } else {
5922 neon_load_reg64(cpu_V1, rm + 1);
5923 imm -= 8;
5924 }
5925 tcg_gen_shli_i64(cpu_V1, cpu_V1, 64 - (imm * 8));
5926 tcg_gen_shri_i64(tmp64, tmp64, imm * 8);
5927 tcg_gen_or_i64(cpu_V1, cpu_V1, tmp64);
5928 tcg_temp_free_i64(tmp64);
5929 } else {
5930 /* BUGFIX */
5931 neon_load_reg64(cpu_V0, rn);
5932 tcg_gen_shri_i64(cpu_V0, cpu_V0, imm * 8);
5933 neon_load_reg64(cpu_V1, rm);
5934 tcg_gen_shli_i64(cpu_V1, cpu_V1, 64 - (imm * 8));
5935 tcg_gen_or_i64(cpu_V0, cpu_V0, cpu_V1);
5936 }
5937 neon_store_reg64(cpu_V0, rd);
5938 if (q) {
5939 neon_store_reg64(cpu_V1, rd + 1);
5940 }
5941 } else if ((insn & (1 << 11)) == 0) {
5942 /* Two register misc. */
5943 op = ((insn >> 12) & 0x30) | ((insn >> 7) & 0xf);
5944 size = (insn >> 18) & 3;
5945 /* UNDEF for unknown op values and bad op-size combinations */
5946 if ((neon_2rm_sizes[op] & (1 << size)) == 0) {
5947 return 1;
5948 }
5949 if ((op != NEON_2RM_VMOVN && op != NEON_2RM_VQMOVN) &&
5950 q && ((rm | rd) & 1)) {
5951 return 1;
5952 }
5953 switch (op) {
5954 case NEON_2RM_VREV64:
5955 for (pass = 0; pass < (q ? 2 : 1); pass++) {
5956 tmp = neon_load_reg(rm, pass * 2);
5957 tmp2 = neon_load_reg(rm, pass * 2 + 1);
5958 switch (size) {
5959 case 0: tcg_gen_bswap32_i32(tmp, tmp); break;
5960 case 1: gen_swap_half(tmp); break;
5961 case 2: /* no-op */ break;
5962 default: abort();
5963 }
5964 neon_store_reg(rd, pass * 2 + 1, tmp);
5965 if (size == 2) {
5966 neon_store_reg(rd, pass * 2, tmp2);
5967 } else {
5968 switch (size) {
5969 case 0: tcg_gen_bswap32_i32(tmp2, tmp2); break;
5970 case 1: gen_swap_half(tmp2); break;
5971 default: abort();
5972 }
5973 neon_store_reg(rd, pass * 2, tmp2);
5974 }
5975 }
5976 break;
5977 case NEON_2RM_VPADDL: case NEON_2RM_VPADDL_U:
5978 case NEON_2RM_VPADAL: case NEON_2RM_VPADAL_U:
5979 for (pass = 0; pass < q + 1; pass++) {
5980 tmp = neon_load_reg(rm, pass * 2);
5981 gen_neon_widen(cpu_V0, tmp, size, op & 1);
5982 tmp = neon_load_reg(rm, pass * 2 + 1);
5983 gen_neon_widen(cpu_V1, tmp, size, op & 1);
5984 switch (size) {
5985 case 0: gen_helper_neon_paddl_u16(CPU_V001); break;
5986 case 1: gen_helper_neon_paddl_u32(CPU_V001); break;
5987 case 2: tcg_gen_add_i64(CPU_V001); break;
5988 default: abort();
5989 }
5990 if (op >= NEON_2RM_VPADAL) {
5991 /* Accumulate. */
5992 neon_load_reg64(cpu_V1, rd + pass);
5993 gen_neon_addl(size);
5994 }
5995 neon_store_reg64(cpu_V0, rd + pass);
5996 }
5997 break;
5998 case NEON_2RM_VTRN:
5999 if (size == 2) {
6000 int n;
6001 for (n = 0; n < (q ? 4 : 2); n += 2) {
6002 tmp = neon_load_reg(rm, n);
6003 tmp2 = neon_load_reg(rd, n + 1);
6004 neon_store_reg(rm, n, tmp2);
6005 neon_store_reg(rd, n + 1, tmp);
6006 }
6007 } else {
6008 goto elementwise;
6009 }
6010 break;
6011 case NEON_2RM_VUZP:
6012 if (gen_neon_unzip(rd, rm, size, q)) {
6013 return 1;
6014 }
6015 break;
6016 case NEON_2RM_VZIP:
6017 if (gen_neon_zip(rd, rm, size, q)) {
6018 return 1;
6019 }
6020 break;
6021 case NEON_2RM_VMOVN: case NEON_2RM_VQMOVN:
6022 /* also VQMOVUN; op field and mnemonics don't line up */
6023 if (rm & 1) {
6024 return 1;
6025 }
6026 TCGV_UNUSED(tmp2);
6027 for (pass = 0; pass < 2; pass++) {
6028 neon_load_reg64(cpu_V0, rm + pass);
6029 tmp = tcg_temp_new_i32();
6030 gen_neon_narrow_op(op == NEON_2RM_VMOVN, q, size,
6031 tmp, cpu_V0);
6032 if (pass == 0) {
6033 tmp2 = tmp;
6034 } else {
6035 neon_store_reg(rd, 0, tmp2);
6036 neon_store_reg(rd, 1, tmp);
6037 }
6038 }
6039 break;
6040 case NEON_2RM_VSHLL:
6041 if (q || (rd & 1)) {
6042 return 1;
6043 }
6044 tmp = neon_load_reg(rm, 0);
6045 tmp2 = neon_load_reg(rm, 1);
6046 for (pass = 0; pass < 2; pass++) {
6047 if (pass == 1)
6048 tmp = tmp2;
6049 gen_neon_widen(cpu_V0, tmp, size, 1);
6050 tcg_gen_shli_i64(cpu_V0, cpu_V0, 8 << size);
6051 neon_store_reg64(cpu_V0, rd + pass);
6052 }
6053 break;
6054 case NEON_2RM_VCVT_F16_F32:
6055 if (!arm_feature(env, ARM_FEATURE_VFP_FP16) ||
6056 q || (rm & 1)) {
6057 return 1;
6058 }
6059 tmp = tcg_temp_new_i32();
6060 tmp2 = tcg_temp_new_i32();
6061 tcg_gen_ld_f32(cpu_F0s, cpu_env, neon_reg_offset(rm, 0));
6062 gen_helper_neon_fcvt_f32_to_f16(tmp, cpu_F0s, cpu_env);
6063 tcg_gen_ld_f32(cpu_F0s, cpu_env, neon_reg_offset(rm, 1));
6064 gen_helper_neon_fcvt_f32_to_f16(tmp2, cpu_F0s, cpu_env);
6065 tcg_gen_shli_i32(tmp2, tmp2, 16);
6066 tcg_gen_or_i32(tmp2, tmp2, tmp);
6067 tcg_gen_ld_f32(cpu_F0s, cpu_env, neon_reg_offset(rm, 2));
6068 gen_helper_neon_fcvt_f32_to_f16(tmp, cpu_F0s, cpu_env);
6069 tcg_gen_ld_f32(cpu_F0s, cpu_env, neon_reg_offset(rm, 3));
6070 neon_store_reg(rd, 0, tmp2);
6071 tmp2 = tcg_temp_new_i32();
6072 gen_helper_neon_fcvt_f32_to_f16(tmp2, cpu_F0s, cpu_env);
6073 tcg_gen_shli_i32(tmp2, tmp2, 16);
6074 tcg_gen_or_i32(tmp2, tmp2, tmp);
6075 neon_store_reg(rd, 1, tmp2);
6076 tcg_temp_free_i32(tmp);
6077 break;
6078 case NEON_2RM_VCVT_F32_F16:
6079 if (!arm_feature(env, ARM_FEATURE_VFP_FP16) ||
6080 q || (rd & 1)) {
6081 return 1;
6082 }
6083 tmp3 = tcg_temp_new_i32();
6084 tmp = neon_load_reg(rm, 0);
6085 tmp2 = neon_load_reg(rm, 1);
6086 tcg_gen_ext16u_i32(tmp3, tmp);
6087 gen_helper_neon_fcvt_f16_to_f32(cpu_F0s, tmp3, cpu_env);
6088 tcg_gen_st_f32(cpu_F0s, cpu_env, neon_reg_offset(rd, 0));
6089 tcg_gen_shri_i32(tmp3, tmp, 16);
6090 gen_helper_neon_fcvt_f16_to_f32(cpu_F0s, tmp3, cpu_env);
6091 tcg_gen_st_f32(cpu_F0s, cpu_env, neon_reg_offset(rd, 1));
6092 tcg_temp_free_i32(tmp);
6093 tcg_gen_ext16u_i32(tmp3, tmp2);
6094 gen_helper_neon_fcvt_f16_to_f32(cpu_F0s, tmp3, cpu_env);
6095 tcg_gen_st_f32(cpu_F0s, cpu_env, neon_reg_offset(rd, 2));
6096 tcg_gen_shri_i32(tmp3, tmp2, 16);
6097 gen_helper_neon_fcvt_f16_to_f32(cpu_F0s, tmp3, cpu_env);
6098 tcg_gen_st_f32(cpu_F0s, cpu_env, neon_reg_offset(rd, 3));
6099 tcg_temp_free_i32(tmp2);
6100 tcg_temp_free_i32(tmp3);
6101 break;
6102 default:
6103 elementwise:
6104 for (pass = 0; pass < (q ? 4 : 2); pass++) {
6105 if (neon_2rm_is_float_op(op)) {
6106 tcg_gen_ld_f32(cpu_F0s, cpu_env,
6107 neon_reg_offset(rm, pass));
6108 TCGV_UNUSED(tmp);
6109 } else {
6110 tmp = neon_load_reg(rm, pass);
6111 }
6112 switch (op) {
6113 case NEON_2RM_VREV32:
6114 switch (size) {
6115 case 0: tcg_gen_bswap32_i32(tmp, tmp); break;
6116 case 1: gen_swap_half(tmp); break;
6117 default: abort();
6118 }
6119 break;
6120 case NEON_2RM_VREV16:
6121 gen_rev16(tmp);
6122 break;
6123 case NEON_2RM_VCLS:
6124 switch (size) {
6125 case 0: gen_helper_neon_cls_s8(tmp, tmp); break;
6126 case 1: gen_helper_neon_cls_s16(tmp, tmp); break;
6127 case 2: gen_helper_neon_cls_s32(tmp, tmp); break;
6128 default: abort();
6129 }
6130 break;
6131 case NEON_2RM_VCLZ:
6132 switch (size) {
6133 case 0: gen_helper_neon_clz_u8(tmp, tmp); break;
6134 case 1: gen_helper_neon_clz_u16(tmp, tmp); break;
6135 case 2: gen_helper_clz(tmp, tmp); break;
6136 default: abort();
6137 }
6138 break;
6139 case NEON_2RM_VCNT:
6140 gen_helper_neon_cnt_u8(tmp, tmp);
6141 break;
6142 case NEON_2RM_VMVN:
6143 tcg_gen_not_i32(tmp, tmp);
6144 break;
6145 case NEON_2RM_VQABS:
6146 switch (size) {
6147 case 0:
6148 gen_helper_neon_qabs_s8(tmp, cpu_env, tmp);
6149 break;
6150 case 1:
6151 gen_helper_neon_qabs_s16(tmp, cpu_env, tmp);
6152 break;
6153 case 2:
6154 gen_helper_neon_qabs_s32(tmp, cpu_env, tmp);
6155 break;
6156 default: abort();
6157 }
6158 break;
6159 case NEON_2RM_VQNEG:
6160 switch (size) {
6161 case 0:
6162 gen_helper_neon_qneg_s8(tmp, cpu_env, tmp);
6163 break;
6164 case 1:
6165 gen_helper_neon_qneg_s16(tmp, cpu_env, tmp);
6166 break;
6167 case 2:
6168 gen_helper_neon_qneg_s32(tmp, cpu_env, tmp);
6169 break;
6170 default: abort();
6171 }
6172 break;
6173 case NEON_2RM_VCGT0: case NEON_2RM_VCLE0:
6174 tmp2 = tcg_const_i32(0);
6175 switch(size) {
6176 case 0: gen_helper_neon_cgt_s8(tmp, tmp, tmp2); break;
6177 case 1: gen_helper_neon_cgt_s16(tmp, tmp, tmp2); break;
6178 case 2: gen_helper_neon_cgt_s32(tmp, tmp, tmp2); break;
6179 default: abort();
6180 }
6181 tcg_temp_free(tmp2);
6182 if (op == NEON_2RM_VCLE0) {
6183 tcg_gen_not_i32(tmp, tmp);
6184 }
6185 break;
6186 case NEON_2RM_VCGE0: case NEON_2RM_VCLT0:
6187 tmp2 = tcg_const_i32(0);
6188 switch(size) {
6189 case 0: gen_helper_neon_cge_s8(tmp, tmp, tmp2); break;
6190 case 1: gen_helper_neon_cge_s16(tmp, tmp, tmp2); break;
6191 case 2: gen_helper_neon_cge_s32(tmp, tmp, tmp2); break;
6192 default: abort();
6193 }
6194 tcg_temp_free(tmp2);
6195 if (op == NEON_2RM_VCLT0) {
6196 tcg_gen_not_i32(tmp, tmp);
6197 }
6198 break;
6199 case NEON_2RM_VCEQ0:
6200 tmp2 = tcg_const_i32(0);
6201 switch(size) {
6202 case 0: gen_helper_neon_ceq_u8(tmp, tmp, tmp2); break;
6203 case 1: gen_helper_neon_ceq_u16(tmp, tmp, tmp2); break;
6204 case 2: gen_helper_neon_ceq_u32(tmp, tmp, tmp2); break;
6205 default: abort();
6206 }
6207 tcg_temp_free(tmp2);
6208 break;
6209 case NEON_2RM_VABS:
6210 switch(size) {
6211 case 0: gen_helper_neon_abs_s8(tmp, tmp); break;
6212 case 1: gen_helper_neon_abs_s16(tmp, tmp); break;
6213 case 2: tcg_gen_abs_i32(tmp, tmp); break;
6214 default: abort();
6215 }
6216 break;
6217 case NEON_2RM_VNEG:
6218 tmp2 = tcg_const_i32(0);
6219 gen_neon_rsb(size, tmp, tmp2);
6220 tcg_temp_free(tmp2);
6221 break;
6222 case NEON_2RM_VCGT0_F:
6223 {
6224 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6225 tmp2 = tcg_const_i32(0);
6226 gen_helper_neon_cgt_f32(tmp, tmp, tmp2, fpstatus);
6227 tcg_temp_free(tmp2);
6228 tcg_temp_free_ptr(fpstatus);
6229 break;
6230 }
6231 case NEON_2RM_VCGE0_F:
6232 {
6233 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6234 tmp2 = tcg_const_i32(0);
6235 gen_helper_neon_cge_f32(tmp, tmp, tmp2, fpstatus);
6236 tcg_temp_free(tmp2);
6237 tcg_temp_free_ptr(fpstatus);
6238 break;
6239 }
6240 case NEON_2RM_VCEQ0_F:
6241 {
6242 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6243 tmp2 = tcg_const_i32(0);
6244 gen_helper_neon_ceq_f32(tmp, tmp, tmp2, fpstatus);
6245 tcg_temp_free(tmp2);
6246 tcg_temp_free_ptr(fpstatus);
6247 break;
6248 }
6249 case NEON_2RM_VCLE0_F:
6250 {
6251 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6252 tmp2 = tcg_const_i32(0);
6253 gen_helper_neon_cge_f32(tmp, tmp2, tmp, fpstatus);
6254 tcg_temp_free(tmp2);
6255 tcg_temp_free_ptr(fpstatus);
6256 break;
6257 }
6258 case NEON_2RM_VCLT0_F:
6259 {
6260 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6261 tmp2 = tcg_const_i32(0);
6262 gen_helper_neon_cgt_f32(tmp, tmp2, tmp, fpstatus);
6263 tcg_temp_free(tmp2);
6264 tcg_temp_free_ptr(fpstatus);
6265 break;
6266 }
6267 case NEON_2RM_VABS_F:
6268 gen_vfp_abs(0);
6269 break;
6270 case NEON_2RM_VNEG_F:
6271 gen_vfp_neg(0);
6272 break;
6273 case NEON_2RM_VSWP:
6274 tmp2 = neon_load_reg(rd, pass);
6275 neon_store_reg(rm, pass, tmp2);
6276 break;
6277 case NEON_2RM_VTRN:
6278 tmp2 = neon_load_reg(rd, pass);
6279 switch (size) {
6280 case 0: gen_neon_trn_u8(tmp, tmp2); break;
6281 case 1: gen_neon_trn_u16(tmp, tmp2); break;
6282 default: abort();
6283 }
6284 neon_store_reg(rm, pass, tmp2);
6285 break;
6286 case NEON_2RM_VRECPE:
6287 gen_helper_recpe_u32(tmp, tmp, cpu_env);
6288 break;
6289 case NEON_2RM_VRSQRTE:
6290 gen_helper_rsqrte_u32(tmp, tmp, cpu_env);
6291 break;
6292 case NEON_2RM_VRECPE_F:
6293 gen_helper_recpe_f32(cpu_F0s, cpu_F0s, cpu_env);
6294 break;
6295 case NEON_2RM_VRSQRTE_F:
6296 gen_helper_rsqrte_f32(cpu_F0s, cpu_F0s, cpu_env);
6297 break;
6298 case NEON_2RM_VCVT_FS: /* VCVT.F32.S32 */
6299 gen_vfp_sito(0, 1);
6300 break;
6301 case NEON_2RM_VCVT_FU: /* VCVT.F32.U32 */
6302 gen_vfp_uito(0, 1);
6303 break;
6304 case NEON_2RM_VCVT_SF: /* VCVT.S32.F32 */
6305 gen_vfp_tosiz(0, 1);
6306 break;
6307 case NEON_2RM_VCVT_UF: /* VCVT.U32.F32 */
6308 gen_vfp_touiz(0, 1);
6309 break;
6310 default:
6311 /* Reserved op values were caught by the
6312 * neon_2rm_sizes[] check earlier.
6313 */
6314 abort();
6315 }
6316 if (neon_2rm_is_float_op(op)) {
6317 tcg_gen_st_f32(cpu_F0s, cpu_env,
6318 neon_reg_offset(rd, pass));
6319 } else {
6320 neon_store_reg(rd, pass, tmp);
6321 }
6322 }
6323 break;
6324 }
6325 } else if ((insn & (1 << 10)) == 0) {
6326 /* VTBL, VTBX. */
6327 int n = ((insn >> 8) & 3) + 1;
6328 if ((rn + n) > 32) {
6329 /* This is UNPREDICTABLE; we choose to UNDEF to avoid the
6330 * helper function running off the end of the register file.
6331 */
6332 return 1;
6333 }
6334 n <<= 3;
6335 if (insn & (1 << 6)) {
6336 tmp = neon_load_reg(rd, 0);
6337 } else {
6338 tmp = tcg_temp_new_i32();
6339 tcg_gen_movi_i32(tmp, 0);
6340 }
6341 tmp2 = neon_load_reg(rm, 0);
6342 tmp4 = tcg_const_i32(rn);
6343 tmp5 = tcg_const_i32(n);
6344 gen_helper_neon_tbl(tmp2, tmp2, tmp, tmp4, tmp5);
6345 tcg_temp_free_i32(tmp);
6346 if (insn & (1 << 6)) {
6347 tmp = neon_load_reg(rd, 1);
6348 } else {
6349 tmp = tcg_temp_new_i32();
6350 tcg_gen_movi_i32(tmp, 0);
6351 }
6352 tmp3 = neon_load_reg(rm, 1);
6353 gen_helper_neon_tbl(tmp3, tmp3, tmp, tmp4, tmp5);
6354 tcg_temp_free_i32(tmp5);
6355 tcg_temp_free_i32(tmp4);
6356 neon_store_reg(rd, 0, tmp2);
6357 neon_store_reg(rd, 1, tmp3);
6358 tcg_temp_free_i32(tmp);
6359 } else if ((insn & 0x380) == 0) {
6360 /* VDUP */
6361 if ((insn & (7 << 16)) == 0 || (q && (rd & 1))) {
6362 return 1;
6363 }
6364 if (insn & (1 << 19)) {
6365 tmp = neon_load_reg(rm, 1);
6366 } else {
6367 tmp = neon_load_reg(rm, 0);
6368 }
6369 if (insn & (1 << 16)) {
6370 gen_neon_dup_u8(tmp, ((insn >> 17) & 3) * 8);
6371 } else if (insn & (1 << 17)) {
6372 if ((insn >> 18) & 1)
6373 gen_neon_dup_high16(tmp);
6374 else
6375 gen_neon_dup_low16(tmp);
6376 }
6377 for (pass = 0; pass < (q ? 4 : 2); pass++) {
6378 tmp2 = tcg_temp_new_i32();
6379 tcg_gen_mov_i32(tmp2, tmp);
6380 neon_store_reg(rd, pass, tmp2);
6381 }
6382 tcg_temp_free_i32(tmp);
6383 } else {
6384 return 1;
6385 }
6386 }
6387 }
6388 return 0;
6389 }
6390
6391 static int disas_cp14_read(CPUARMState * env, DisasContext *s, uint32_t insn)
6392 {
6393 int crn = (insn >> 16) & 0xf;
6394 int crm = insn & 0xf;
6395 int op1 = (insn >> 21) & 7;
6396 int op2 = (insn >> 5) & 7;
6397 int rt = (insn >> 12) & 0xf;
6398 TCGv tmp;
6399
6400 /* Minimal set of debug registers, since we don't support debug */
6401 if (op1 == 0 && crn == 0 && op2 == 0) {
6402 switch (crm) {
6403 case 0:
6404 /* DBGDIDR: just RAZ. In particular this means the
6405 * "debug architecture version" bits will read as
6406 * a reserved value, which should cause Linux to
6407 * not try to use the debug hardware.
6408 */
6409 tmp = tcg_const_i32(0);
6410 store_reg(s, rt, tmp);
6411 return 0;
6412 case 1:
6413 case 2:
6414 /* DBGDRAR and DBGDSAR: v7 only. Always RAZ since we
6415 * don't implement memory mapped debug components
6416 */
6417 if (ENABLE_ARCH_7) {
6418 tmp = tcg_const_i32(0);
6419 store_reg(s, rt, tmp);
6420 return 0;
6421 }
6422 break;
6423 default:
6424 break;
6425 }
6426 }
6427
6428 if (arm_feature(env, ARM_FEATURE_THUMB2EE)) {
6429 if (op1 == 6 && crn == 0 && crm == 0 && op2 == 0) {
6430 /* TEECR */
6431 if (IS_USER(s))
6432 return 1;
6433 tmp = load_cpu_field(teecr);
6434 store_reg(s, rt, tmp);
6435 return 0;
6436 }
6437 if (op1 == 6 && crn == 1 && crm == 0 && op2 == 0) {
6438 /* TEEHBR */
6439 if (IS_USER(s) && (env->teecr & 1))
6440 return 1;
6441 tmp = load_cpu_field(teehbr);
6442 store_reg(s, rt, tmp);
6443 return 0;
6444 }
6445 }
6446 return 1;
6447 }
6448
6449 static int disas_cp14_write(CPUARMState * env, DisasContext *s, uint32_t insn)
6450 {
6451 int crn = (insn >> 16) & 0xf;
6452 int crm = insn & 0xf;
6453 int op1 = (insn >> 21) & 7;
6454 int op2 = (insn >> 5) & 7;
6455 int rt = (insn >> 12) & 0xf;
6456 TCGv tmp;
6457
6458 if (arm_feature(env, ARM_FEATURE_THUMB2EE)) {
6459 if (op1 == 6 && crn == 0 && crm == 0 && op2 == 0) {
6460 /* TEECR */
6461 if (IS_USER(s))
6462 return 1;
6463 tmp = load_reg(s, rt);
6464 gen_helper_set_teecr(cpu_env, tmp);
6465 tcg_temp_free_i32(tmp);
6466 return 0;
6467 }
6468 if (op1 == 6 && crn == 1 && crm == 0 && op2 == 0) {
6469 /* TEEHBR */
6470 if (IS_USER(s) && (env->teecr & 1))
6471 return 1;
6472 tmp = load_reg(s, rt);
6473 store_cpu_field(tmp, teehbr);
6474 return 0;
6475 }
6476 }
6477 return 1;
6478 }
6479
6480 static int disas_coproc_insn(CPUARMState * env, DisasContext *s, uint32_t insn)
6481 {
6482 int cpnum;
6483
6484 cpnum = (insn >> 8) & 0xf;
6485 if (arm_feature(env, ARM_FEATURE_XSCALE)
6486 && ((env->cp15.c15_cpar ^ 0x3fff) & (1 << cpnum)))
6487 return 1;
6488
6489 switch (cpnum) {
6490 case 0:
6491 case 1:
6492 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
6493 return disas_iwmmxt_insn(env, s, insn);
6494 } else if (arm_feature(env, ARM_FEATURE_XSCALE)) {
6495 return disas_dsp_insn(env, s, insn);
6496 }
6497 return 1;
6498 case 10:
6499 case 11:
6500 return disas_vfp_insn (env, s, insn);
6501 case 14:
6502 /* Coprocessors 7-15 are architecturally reserved by ARM.
6503 Unfortunately Intel decided to ignore this. */
6504 if (arm_feature(env, ARM_FEATURE_XSCALE))
6505 goto board;
6506 if (insn & (1 << 20))
6507 return disas_cp14_read(env, s, insn);
6508 else
6509 return disas_cp14_write(env, s, insn);
6510 case 15:
6511 return disas_cp15_insn (env, s, insn);
6512 default:
6513 board:
6514 /* Unknown coprocessor. See if the board has hooked it. */
6515 return disas_cp_insn (env, s, insn);
6516 }
6517 }
6518
6519
6520 /* Store a 64-bit value to a register pair. Clobbers val. */
6521 static void gen_storeq_reg(DisasContext *s, int rlow, int rhigh, TCGv_i64 val)
6522 {
6523 TCGv tmp;
6524 tmp = tcg_temp_new_i32();
6525 tcg_gen_trunc_i64_i32(tmp, val);
6526 store_reg(s, rlow, tmp);
6527 tmp = tcg_temp_new_i32();
6528 tcg_gen_shri_i64(val, val, 32);
6529 tcg_gen_trunc_i64_i32(tmp, val);
6530 store_reg(s, rhigh, tmp);
6531 }
6532
6533 /* load a 32-bit value from a register and perform a 64-bit accumulate. */
6534 static void gen_addq_lo(DisasContext *s, TCGv_i64 val, int rlow)
6535 {
6536 TCGv_i64 tmp;
6537 TCGv tmp2;
6538
6539 /* Load value and extend to 64 bits. */
6540 tmp = tcg_temp_new_i64();
6541 tmp2 = load_reg(s, rlow);
6542 tcg_gen_extu_i32_i64(tmp, tmp2);
6543 tcg_temp_free_i32(tmp2);
6544 tcg_gen_add_i64(val, val, tmp);
6545 tcg_temp_free_i64(tmp);
6546 }
6547
6548 /* load and add a 64-bit value from a register pair. */
6549 static void gen_addq(DisasContext *s, TCGv_i64 val, int rlow, int rhigh)
6550 {
6551 TCGv_i64 tmp;
6552 TCGv tmpl;
6553 TCGv tmph;
6554
6555 /* Load 64-bit value rd:rn. */
6556 tmpl = load_reg(s, rlow);
6557 tmph = load_reg(s, rhigh);
6558 tmp = tcg_temp_new_i64();
6559 tcg_gen_concat_i32_i64(tmp, tmpl, tmph);
6560 tcg_temp_free_i32(tmpl);
6561 tcg_temp_free_i32(tmph);
6562 tcg_gen_add_i64(val, val, tmp);
6563 tcg_temp_free_i64(tmp);
6564 }
6565
6566 /* Set N and Z flags from a 64-bit value. */
6567 static void gen_logicq_cc(TCGv_i64 val)
6568 {
6569 TCGv tmp = tcg_temp_new_i32();
6570 gen_helper_logicq_cc(tmp, val);
6571 gen_logic_CC(tmp);
6572 tcg_temp_free_i32(tmp);
6573 }
6574
6575 /* Load/Store exclusive instructions are implemented by remembering
6576 the value/address loaded, and seeing if these are the same
6577 when the store is performed. This should be is sufficient to implement
6578 the architecturally mandated semantics, and avoids having to monitor
6579 regular stores.
6580
6581 In system emulation mode only one CPU will be running at once, so
6582 this sequence is effectively atomic. In user emulation mode we
6583 throw an exception and handle the atomic operation elsewhere. */
6584 static void gen_load_exclusive(DisasContext *s, int rt, int rt2,
6585 TCGv addr, int size)
6586 {
6587 TCGv tmp;
6588
6589 switch (size) {
6590 case 0:
6591 tmp = gen_ld8u(addr, IS_USER(s));
6592 break;
6593 case 1:
6594 tmp = gen_ld16u(addr, IS_USER(s));
6595 break;
6596 case 2:
6597 case 3:
6598 tmp = gen_ld32(addr, IS_USER(s));
6599 break;
6600 default:
6601 abort();
6602 }
6603 tcg_gen_mov_i32(cpu_exclusive_val, tmp);
6604 store_reg(s, rt, tmp);
6605 if (size == 3) {
6606 TCGv tmp2 = tcg_temp_new_i32();
6607 tcg_gen_addi_i32(tmp2, addr, 4);
6608 tmp = gen_ld32(tmp2, IS_USER(s));
6609 tcg_temp_free_i32(tmp2);
6610 tcg_gen_mov_i32(cpu_exclusive_high, tmp);
6611 store_reg(s, rt2, tmp);
6612 }
6613 tcg_gen_mov_i32(cpu_exclusive_addr, addr);
6614 }
6615
6616 static void gen_clrex(DisasContext *s)
6617 {
6618 tcg_gen_movi_i32(cpu_exclusive_addr, -1);
6619 }
6620
6621 #ifdef CONFIG_USER_ONLY
6622 static void gen_store_exclusive(DisasContext *s, int rd, int rt, int rt2,
6623 TCGv addr, int size)
6624 {
6625 tcg_gen_mov_i32(cpu_exclusive_test, addr);
6626 tcg_gen_movi_i32(cpu_exclusive_info,
6627 size | (rd << 4) | (rt << 8) | (rt2 << 12));
6628 gen_exception_insn(s, 4, EXCP_STREX);
6629 }
6630 #else
6631 static void gen_store_exclusive(DisasContext *s, int rd, int rt, int rt2,
6632 TCGv addr, int size)
6633 {
6634 TCGv tmp;
6635 int done_label;
6636 int fail_label;
6637
6638 /* if (env->exclusive_addr == addr && env->exclusive_val == [addr]) {
6639 [addr] = {Rt};
6640 {Rd} = 0;
6641 } else {
6642 {Rd} = 1;
6643 } */
6644 fail_label = gen_new_label();
6645 done_label = gen_new_label();
6646 tcg_gen_brcond_i32(TCG_COND_NE, addr, cpu_exclusive_addr, fail_label);
6647 switch (size) {
6648 case 0:
6649 tmp = gen_ld8u(addr, IS_USER(s));
6650 break;
6651 case 1:
6652 tmp = gen_ld16u(addr, IS_USER(s));
6653 break;
6654 case 2:
6655 case 3:
6656 tmp = gen_ld32(addr, IS_USER(s));
6657 break;
6658 default:
6659 abort();
6660 }
6661 tcg_gen_brcond_i32(TCG_COND_NE, tmp, cpu_exclusive_val, fail_label);
6662 tcg_temp_free_i32(tmp);
6663 if (size == 3) {
6664 TCGv tmp2 = tcg_temp_new_i32();
6665 tcg_gen_addi_i32(tmp2, addr, 4);
6666 tmp = gen_ld32(tmp2, IS_USER(s));
6667 tcg_temp_free_i32(tmp2);
6668 tcg_gen_brcond_i32(TCG_COND_NE, tmp, cpu_exclusive_high, fail_label);
6669 tcg_temp_free_i32(tmp);
6670 }
6671 tmp = load_reg(s, rt);
6672 switch (size) {
6673 case 0:
6674 gen_st8(tmp, addr, IS_USER(s));
6675 break;
6676 case 1:
6677 gen_st16(tmp, addr, IS_USER(s));
6678 break;
6679 case 2:
6680 case 3:
6681 gen_st32(tmp, addr, IS_USER(s));
6682 break;
6683 default:
6684 abort();
6685 }
6686 if (size == 3) {
6687 tcg_gen_addi_i32(addr, addr, 4);
6688 tmp = load_reg(s, rt2);
6689 gen_st32(tmp, addr, IS_USER(s));
6690 }
6691 tcg_gen_movi_i32(cpu_R[rd], 0);
6692 tcg_gen_br(done_label);
6693 gen_set_label(fail_label);
6694 tcg_gen_movi_i32(cpu_R[rd], 1);
6695 gen_set_label(done_label);
6696 tcg_gen_movi_i32(cpu_exclusive_addr, -1);
6697 }
6698 #endif
6699
6700 static void disas_arm_insn(CPUARMState * env, DisasContext *s)
6701 {
6702 unsigned int cond, insn, val, op1, i, shift, rm, rs, rn, rd, sh;
6703 TCGv tmp;
6704 TCGv tmp2;
6705 TCGv tmp3;
6706 TCGv addr;
6707 TCGv_i64 tmp64;
6708
6709 insn = arm_ldl_code(s->pc, s->bswap_code);
6710 s->pc += 4;
6711
6712 /* M variants do not implement ARM mode. */
6713 if (IS_M(env))
6714 goto illegal_op;
6715 cond = insn >> 28;
6716 if (cond == 0xf){
6717 /* In ARMv3 and v4 the NV condition is UNPREDICTABLE; we
6718 * choose to UNDEF. In ARMv5 and above the space is used
6719 * for miscellaneous unconditional instructions.
6720 */
6721 ARCH(5);
6722
6723 /* Unconditional instructions. */
6724 if (((insn >> 25) & 7) == 1) {
6725 /* NEON Data processing. */
6726 if (!arm_feature(env, ARM_FEATURE_NEON))
6727 goto illegal_op;
6728
6729 if (disas_neon_data_insn(env, s, insn))
6730 goto illegal_op;
6731 return;
6732 }
6733 if ((insn & 0x0f100000) == 0x04000000) {
6734 /* NEON load/store. */
6735 if (!arm_feature(env, ARM_FEATURE_NEON))
6736 goto illegal_op;
6737
6738 if (disas_neon_ls_insn(env, s, insn))
6739 goto illegal_op;
6740 return;
6741 }
6742 if (((insn & 0x0f30f000) == 0x0510f000) ||
6743 ((insn & 0x0f30f010) == 0x0710f000)) {
6744 if ((insn & (1 << 22)) == 0) {
6745 /* PLDW; v7MP */
6746 if (!arm_feature(env, ARM_FEATURE_V7MP)) {
6747 goto illegal_op;
6748 }
6749 }
6750 /* Otherwise PLD; v5TE+ */
6751 ARCH(5TE);
6752 return;
6753 }
6754 if (((insn & 0x0f70f000) == 0x0450f000) ||
6755 ((insn & 0x0f70f010) == 0x0650f000)) {
6756 ARCH(7);
6757 return; /* PLI; V7 */
6758 }
6759 if (((insn & 0x0f700000) == 0x04100000) ||
6760 ((insn & 0x0f700010) == 0x06100000)) {
6761 if (!arm_feature(env, ARM_FEATURE_V7MP)) {
6762 goto illegal_op;
6763 }
6764 return; /* v7MP: Unallocated memory hint: must NOP */
6765 }
6766
6767 if ((insn & 0x0ffffdff) == 0x01010000) {
6768 ARCH(6);
6769 /* setend */
6770 if (insn & (1 << 9)) {
6771 /* BE8 mode not implemented. */
6772 goto illegal_op;
6773 }
6774 return;
6775 } else if ((insn & 0x0fffff00) == 0x057ff000) {
6776 switch ((insn >> 4) & 0xf) {
6777 case 1: /* clrex */
6778 ARCH(6K);
6779 gen_clrex(s);
6780 return;
6781 case 4: /* dsb */
6782 case 5: /* dmb */
6783 case 6: /* isb */
6784 ARCH(7);
6785 /* We don't emulate caches so these are a no-op. */
6786 return;
6787 default:
6788 goto illegal_op;
6789 }
6790 } else if ((insn & 0x0e5fffe0) == 0x084d0500) {
6791 /* srs */
6792 int32_t offset;
6793 if (IS_USER(s))
6794 goto illegal_op;
6795 ARCH(6);
6796 op1 = (insn & 0x1f);
6797 addr = tcg_temp_new_i32();
6798 tmp = tcg_const_i32(op1);
6799 gen_helper_get_r13_banked(addr, cpu_env, tmp);
6800 tcg_temp_free_i32(tmp);
6801 i = (insn >> 23) & 3;
6802 switch (i) {
6803 case 0: offset = -4; break; /* DA */
6804 case 1: offset = 0; break; /* IA */
6805 case 2: offset = -8; break; /* DB */
6806 case 3: offset = 4; break; /* IB */
6807 default: abort();
6808 }
6809 if (offset)
6810 tcg_gen_addi_i32(addr, addr, offset);
6811 tmp = load_reg(s, 14);
6812 gen_st32(tmp, addr, 0);
6813 tmp = load_cpu_field(spsr);
6814 tcg_gen_addi_i32(addr, addr, 4);
6815 gen_st32(tmp, addr, 0);
6816 if (insn & (1 << 21)) {
6817 /* Base writeback. */
6818 switch (i) {
6819 case 0: offset = -8; break;
6820 case 1: offset = 4; break;
6821 case 2: offset = -4; break;
6822 case 3: offset = 0; break;
6823 default: abort();
6824 }
6825 if (offset)
6826 tcg_gen_addi_i32(addr, addr, offset);
6827 tmp = tcg_const_i32(op1);
6828 gen_helper_set_r13_banked(cpu_env, tmp, addr);
6829 tcg_temp_free_i32(tmp);
6830 tcg_temp_free_i32(addr);
6831 } else {
6832 tcg_temp_free_i32(addr);
6833 }
6834 return;
6835 } else if ((insn & 0x0e50ffe0) == 0x08100a00) {
6836 /* rfe */
6837 int32_t offset;
6838 if (IS_USER(s))
6839 goto illegal_op;
6840 ARCH(6);
6841 rn = (insn >> 16) & 0xf;
6842 addr = load_reg(s, rn);
6843 i = (insn >> 23) & 3;
6844 switch (i) {
6845 case 0: offset = -4; break; /* DA */
6846 case 1: offset = 0; break; /* IA */
6847 case 2: offset = -8; break; /* DB */
6848 case 3: offset = 4; break; /* IB */
6849 default: abort();
6850 }
6851 if (offset)
6852 tcg_gen_addi_i32(addr, addr, offset);
6853 /* Load PC into tmp and CPSR into tmp2. */
6854 tmp = gen_ld32(addr, 0);
6855 tcg_gen_addi_i32(addr, addr, 4);
6856 tmp2 = gen_ld32(addr, 0);
6857 if (insn & (1 << 21)) {
6858 /* Base writeback. */
6859 switch (i) {
6860 case 0: offset = -8; break;
6861 case 1: offset = 4; break;
6862 case 2: offset = -4; break;
6863 case 3: offset = 0; break;
6864 default: abort();
6865 }
6866 if (offset)
6867 tcg_gen_addi_i32(addr, addr, offset);
6868 store_reg(s, rn, addr);
6869 } else {
6870 tcg_temp_free_i32(addr);
6871 }
6872 gen_rfe(s, tmp, tmp2);
6873 return;
6874 } else if ((insn & 0x0e000000) == 0x0a000000) {
6875 /* branch link and change to thumb (blx <offset>) */
6876 int32_t offset;
6877
6878 val = (uint32_t)s->pc;
6879 tmp = tcg_temp_new_i32();
6880 tcg_gen_movi_i32(tmp, val);
6881 store_reg(s, 14, tmp);
6882 /* Sign-extend the 24-bit offset */
6883 offset = (((int32_t)insn) << 8) >> 8;
6884 /* offset * 4 + bit24 * 2 + (thumb bit) */
6885 val += (offset << 2) | ((insn >> 23) & 2) | 1;
6886 /* pipeline offset */
6887 val += 4;
6888 /* protected by ARCH(5); above, near the start of uncond block */
6889 gen_bx_im(s, val);
6890 return;
6891 } else if ((insn & 0x0e000f00) == 0x0c000100) {
6892 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
6893 /* iWMMXt register transfer. */
6894 if (env->cp15.c15_cpar & (1 << 1))
6895 if (!disas_iwmmxt_insn(env, s, insn))
6896 return;
6897 }
6898 } else if ((insn & 0x0fe00000) == 0x0c400000) {
6899 /* Coprocessor double register transfer. */
6900 ARCH(5TE);
6901 } else if ((insn & 0x0f000010) == 0x0e000010) {
6902 /* Additional coprocessor register transfer. */
6903 } else if ((insn & 0x0ff10020) == 0x01000000) {
6904 uint32_t mask;
6905 uint32_t val;
6906 /* cps (privileged) */
6907 if (IS_USER(s))
6908 return;
6909 mask = val = 0;
6910 if (insn & (1 << 19)) {
6911 if (insn & (1 << 8))
6912 mask |= CPSR_A;
6913 if (insn & (1 << 7))
6914 mask |= CPSR_I;
6915 if (insn & (1 << 6))
6916 mask |= CPSR_F;
6917 if (insn & (1 << 18))
6918 val |= mask;
6919 }
6920 if (insn & (1 << 17)) {
6921 mask |= CPSR_M;
6922 val |= (insn & 0x1f);
6923 }
6924 if (mask) {
6925 gen_set_psr_im(s, mask, 0, val);
6926 }
6927 return;
6928 }
6929 goto illegal_op;
6930 }
6931 if (cond != 0xe) {
6932 /* if not always execute, we generate a conditional jump to
6933 next instruction */
6934 s->condlabel = gen_new_label();
6935 gen_test_cc(cond ^ 1, s->condlabel);
6936 s->condjmp = 1;
6937 }
6938 if ((insn & 0x0f900000) == 0x03000000) {
6939 if ((insn & (1 << 21)) == 0) {
6940 ARCH(6T2);
6941 rd = (insn >> 12) & 0xf;
6942 val = ((insn >> 4) & 0xf000) | (insn & 0xfff);
6943 if ((insn & (1 << 22)) == 0) {
6944 /* MOVW */
6945 tmp = tcg_temp_new_i32();
6946 tcg_gen_movi_i32(tmp, val);
6947 } else {
6948 /* MOVT */
6949 tmp = load_reg(s, rd);
6950 tcg_gen_ext16u_i32(tmp, tmp);
6951 tcg_gen_ori_i32(tmp, tmp, val << 16);
6952 }
6953 store_reg(s, rd, tmp);
6954 } else {
6955 if (((insn >> 12) & 0xf) != 0xf)
6956 goto illegal_op;
6957 if (((insn >> 16) & 0xf) == 0) {
6958 gen_nop_hint(s, insn & 0xff);
6959 } else {
6960 /* CPSR = immediate */
6961 val = insn & 0xff;
6962 shift = ((insn >> 8) & 0xf) * 2;
6963 if (shift)
6964 val = (val >> shift) | (val << (32 - shift));
6965 i = ((insn & (1 << 22)) != 0);
6966 if (gen_set_psr_im(s, msr_mask(env, s, (insn >> 16) & 0xf, i), i, val))
6967 goto illegal_op;
6968 }
6969 }
6970 } else if ((insn & 0x0f900000) == 0x01000000
6971 && (insn & 0x00000090) != 0x00000090) {
6972 /* miscellaneous instructions */
6973 op1 = (insn >> 21) & 3;
6974 sh = (insn >> 4) & 0xf;
6975 rm = insn & 0xf;
6976 switch (sh) {
6977 case 0x0: /* move program status register */
6978 if (op1 & 1) {
6979 /* PSR = reg */
6980 tmp = load_reg(s, rm);
6981 i = ((op1 & 2) != 0);
6982 if (gen_set_psr(s, msr_mask(env, s, (insn >> 16) & 0xf, i), i, tmp))
6983 goto illegal_op;
6984 } else {
6985 /* reg = PSR */
6986 rd = (insn >> 12) & 0xf;
6987 if (op1 & 2) {
6988 if (IS_USER(s))
6989 goto illegal_op;
6990 tmp = load_cpu_field(spsr);
6991 } else {
6992 tmp = tcg_temp_new_i32();
6993 gen_helper_cpsr_read(tmp);
6994 }
6995 store_reg(s, rd, tmp);
6996 }
6997 break;
6998 case 0x1:
6999 if (op1 == 1) {
7000 /* branch/exchange thumb (bx). */
7001 ARCH(4T);
7002 tmp = load_reg(s, rm);
7003 gen_bx(s, tmp);
7004 } else if (op1 == 3) {
7005 /* clz */
7006 ARCH(5);
7007 rd = (insn >> 12) & 0xf;
7008 tmp = load_reg(s, rm);
7009 gen_helper_clz(tmp, tmp);
7010 store_reg(s, rd, tmp);
7011 } else {
7012 goto illegal_op;
7013 }
7014 break;
7015 case 0x2:
7016 if (op1 == 1) {
7017 ARCH(5J); /* bxj */
7018 /* Trivial implementation equivalent to bx. */
7019 tmp = load_reg(s, rm);
7020 gen_bx(s, tmp);
7021 } else {
7022 goto illegal_op;
7023 }
7024 break;
7025 case 0x3:
7026 if (op1 != 1)
7027 goto illegal_op;
7028
7029 ARCH(5);
7030 /* branch link/exchange thumb (blx) */
7031 tmp = load_reg(s, rm);
7032 tmp2 = tcg_temp_new_i32();
7033 tcg_gen_movi_i32(tmp2, s->pc);
7034 store_reg(s, 14, tmp2);
7035 gen_bx(s, tmp);
7036 break;
7037 case 0x5: /* saturating add/subtract */
7038 ARCH(5TE);
7039 rd = (insn >> 12) & 0xf;
7040 rn = (insn >> 16) & 0xf;
7041 tmp = load_reg(s, rm);
7042 tmp2 = load_reg(s, rn);
7043 if (op1 & 2)
7044 gen_helper_double_saturate(tmp2, tmp2);
7045 if (op1 & 1)
7046 gen_helper_sub_saturate(tmp, tmp, tmp2);
7047 else
7048 gen_helper_add_saturate(tmp, tmp, tmp2);
7049 tcg_temp_free_i32(tmp2);
7050 store_reg(s, rd, tmp);
7051 break;
7052 case 7:
7053 /* SMC instruction (op1 == 3)
7054 and undefined instructions (op1 == 0 || op1 == 2)
7055 will trap */
7056 if (op1 != 1) {
7057 goto illegal_op;
7058 }
7059 /* bkpt */
7060 ARCH(5);
7061 gen_exception_insn(s, 4, EXCP_BKPT);
7062 break;
7063 case 0x8: /* signed multiply */
7064 case 0xa:
7065 case 0xc:
7066 case 0xe:
7067 ARCH(5TE);
7068 rs = (insn >> 8) & 0xf;
7069 rn = (insn >> 12) & 0xf;
7070 rd = (insn >> 16) & 0xf;
7071 if (op1 == 1) {
7072 /* (32 * 16) >> 16 */
7073 tmp = load_reg(s, rm);
7074 tmp2 = load_reg(s, rs);
7075 if (sh & 4)
7076 tcg_gen_sari_i32(tmp2, tmp2, 16);
7077 else
7078 gen_sxth(tmp2);
7079 tmp64 = gen_muls_i64_i32(tmp, tmp2);
7080 tcg_gen_shri_i64(tmp64, tmp64, 16);
7081 tmp = tcg_temp_new_i32();
7082 tcg_gen_trunc_i64_i32(tmp, tmp64);
7083 tcg_temp_free_i64(tmp64);
7084 if ((sh & 2) == 0) {
7085 tmp2 = load_reg(s, rn);
7086 gen_helper_add_setq(tmp, tmp, tmp2);
7087 tcg_temp_free_i32(tmp2);
7088 }
7089 store_reg(s, rd, tmp);
7090 } else {
7091 /* 16 * 16 */
7092 tmp = load_reg(s, rm);
7093 tmp2 = load_reg(s, rs);
7094 gen_mulxy(tmp, tmp2, sh & 2, sh & 4);
7095 tcg_temp_free_i32(tmp2);
7096 if (op1 == 2) {
7097 tmp64 = tcg_temp_new_i64();
7098 tcg_gen_ext_i32_i64(tmp64, tmp);
7099 tcg_temp_free_i32(tmp);
7100 gen_addq(s, tmp64, rn, rd);
7101 gen_storeq_reg(s, rn, rd, tmp64);
7102 tcg_temp_free_i64(tmp64);
7103 } else {
7104 if (op1 == 0) {
7105 tmp2 = load_reg(s, rn);
7106 gen_helper_add_setq(tmp, tmp, tmp2);
7107 tcg_temp_free_i32(tmp2);
7108 }
7109 store_reg(s, rd, tmp);
7110 }
7111 }
7112 break;
7113 default:
7114 goto illegal_op;
7115 }
7116 } else if (((insn & 0x0e000000) == 0 &&
7117 (insn & 0x00000090) != 0x90) ||
7118 ((insn & 0x0e000000) == (1 << 25))) {
7119 int set_cc, logic_cc, shiftop;
7120
7121 op1 = (insn >> 21) & 0xf;
7122 set_cc = (insn >> 20) & 1;
7123 logic_cc = table_logic_cc[op1] & set_cc;
7124
7125 /* data processing instruction */
7126 if (insn & (1 << 25)) {
7127 /* immediate operand */
7128 val = insn & 0xff;
7129 shift = ((insn >> 8) & 0xf) * 2;
7130 if (shift) {
7131 val = (val >> shift) | (val << (32 - shift));
7132 }
7133 tmp2 = tcg_temp_new_i32();
7134 tcg_gen_movi_i32(tmp2, val);
7135 if (logic_cc && shift) {
7136 gen_set_CF_bit31(tmp2);
7137 }
7138 } else {
7139 /* register */
7140 rm = (insn) & 0xf;
7141 tmp2 = load_reg(s, rm);
7142 shiftop = (insn >> 5) & 3;
7143 if (!(insn & (1 << 4))) {
7144 shift = (insn >> 7) & 0x1f;
7145 gen_arm_shift_im(tmp2, shiftop, shift, logic_cc);
7146 } else {
7147 rs = (insn >> 8) & 0xf;
7148 tmp = load_reg(s, rs);
7149 gen_arm_shift_reg(tmp2, shiftop, tmp, logic_cc);
7150 }
7151 }
7152 if (op1 != 0x0f && op1 != 0x0d) {
7153 rn = (insn >> 16) & 0xf;
7154 tmp = load_reg(s, rn);
7155 } else {
7156 TCGV_UNUSED(tmp);
7157 }
7158 rd = (insn >> 12) & 0xf;
7159 switch(op1) {
7160 case 0x00:
7161 tcg_gen_and_i32(tmp, tmp, tmp2);
7162 if (logic_cc) {
7163 gen_logic_CC(tmp);
7164 }
7165 store_reg_bx(env, s, rd, tmp);
7166 break;
7167 case 0x01:
7168 tcg_gen_xor_i32(tmp, tmp, tmp2);
7169 if (logic_cc) {
7170 gen_logic_CC(tmp);
7171 }
7172 store_reg_bx(env, s, rd, tmp);
7173 break;
7174 case 0x02:
7175 if (set_cc && rd == 15) {
7176 /* SUBS r15, ... is used for exception return. */
7177 if (IS_USER(s)) {
7178 goto illegal_op;
7179 }
7180 gen_helper_sub_cc(tmp, tmp, tmp2);
7181 gen_exception_return(s, tmp);
7182 } else {
7183 if (set_cc) {
7184 gen_helper_sub_cc(tmp, tmp, tmp2);
7185 } else {
7186 tcg_gen_sub_i32(tmp, tmp, tmp2);
7187 }
7188 store_reg_bx(env, s, rd, tmp);
7189 }
7190 break;
7191 case 0x03:
7192 if (set_cc) {
7193 gen_helper_sub_cc(tmp, tmp2, tmp);
7194 } else {
7195 tcg_gen_sub_i32(tmp, tmp2, tmp);
7196 }
7197 store_reg_bx(env, s, rd, tmp);
7198 break;
7199 case 0x04:
7200 if (set_cc) {
7201 gen_helper_add_cc(tmp, tmp, tmp2);
7202 } else {
7203 tcg_gen_add_i32(tmp, tmp, tmp2);
7204 }
7205 store_reg_bx(env, s, rd, tmp);
7206 break;
7207 case 0x05:
7208 if (set_cc) {
7209 gen_helper_adc_cc(tmp, tmp, tmp2);
7210 } else {
7211 gen_add_carry(tmp, tmp, tmp2);
7212 }
7213 store_reg_bx(env, s, rd, tmp);
7214 break;
7215 case 0x06:
7216 if (set_cc) {
7217 gen_helper_sbc_cc(tmp, tmp, tmp2);
7218 } else {
7219 gen_sub_carry(tmp, tmp, tmp2);
7220 }
7221 store_reg_bx(env, s, rd, tmp);
7222 break;
7223 case 0x07:
7224 if (set_cc) {
7225 gen_helper_sbc_cc(tmp, tmp2, tmp);
7226 } else {
7227 gen_sub_carry(tmp, tmp2, tmp);
7228 }
7229 store_reg_bx(env, s, rd, tmp);
7230 break;
7231 case 0x08:
7232 if (set_cc) {
7233 tcg_gen_and_i32(tmp, tmp, tmp2);
7234 gen_logic_CC(tmp);
7235 }
7236 tcg_temp_free_i32(tmp);
7237 break;
7238 case 0x09:
7239 if (set_cc) {
7240 tcg_gen_xor_i32(tmp, tmp, tmp2);
7241 gen_logic_CC(tmp);
7242 }
7243 tcg_temp_free_i32(tmp);
7244 break;
7245 case 0x0a:
7246 if (set_cc) {
7247 gen_helper_sub_cc(tmp, tmp, tmp2);
7248 }
7249 tcg_temp_free_i32(tmp);
7250 break;
7251 case 0x0b:
7252 if (set_cc) {
7253 gen_helper_add_cc(tmp, tmp, tmp2);
7254 }
7255 tcg_temp_free_i32(tmp);
7256 break;
7257 case 0x0c:
7258 tcg_gen_or_i32(tmp, tmp, tmp2);
7259 if (logic_cc) {
7260 gen_logic_CC(tmp);
7261 }
7262 store_reg_bx(env, s, rd, tmp);
7263 break;
7264 case 0x0d:
7265 if (logic_cc && rd == 15) {
7266 /* MOVS r15, ... is used for exception return. */
7267 if (IS_USER(s)) {
7268 goto illegal_op;
7269 }
7270 gen_exception_return(s, tmp2);
7271 } else {
7272 if (logic_cc) {
7273 gen_logic_CC(tmp2);
7274 }
7275 store_reg_bx(env, s, rd, tmp2);
7276 }
7277 break;
7278 case 0x0e:
7279 tcg_gen_andc_i32(tmp, tmp, tmp2);
7280 if (logic_cc) {
7281 gen_logic_CC(tmp);
7282 }
7283 store_reg_bx(env, s, rd, tmp);
7284 break;
7285 default:
7286 case 0x0f:
7287 tcg_gen_not_i32(tmp2, tmp2);
7288 if (logic_cc) {
7289 gen_logic_CC(tmp2);
7290 }
7291 store_reg_bx(env, s, rd, tmp2);
7292 break;
7293 }
7294 if (op1 != 0x0f && op1 != 0x0d) {
7295 tcg_temp_free_i32(tmp2);
7296 }
7297 } else {
7298 /* other instructions */
7299 op1 = (insn >> 24) & 0xf;
7300 switch(op1) {
7301 case 0x0:
7302 case 0x1:
7303 /* multiplies, extra load/stores */
7304 sh = (insn >> 5) & 3;
7305 if (sh == 0) {
7306 if (op1 == 0x0) {
7307 rd = (insn >> 16) & 0xf;
7308 rn = (insn >> 12) & 0xf;
7309 rs = (insn >> 8) & 0xf;
7310 rm = (insn) & 0xf;
7311 op1 = (insn >> 20) & 0xf;
7312 switch (op1) {
7313 case 0: case 1: case 2: case 3: case 6:
7314 /* 32 bit mul */
7315 tmp = load_reg(s, rs);
7316 tmp2 = load_reg(s, rm);
7317 tcg_gen_mul_i32(tmp, tmp, tmp2);
7318 tcg_temp_free_i32(tmp2);
7319 if (insn & (1 << 22)) {
7320 /* Subtract (mls) */
7321 ARCH(6T2);
7322 tmp2 = load_reg(s, rn);
7323 tcg_gen_sub_i32(tmp, tmp2, tmp);
7324 tcg_temp_free_i32(tmp2);
7325 } else if (insn & (1 << 21)) {
7326 /* Add */
7327 tmp2 = load_reg(s, rn);
7328 tcg_gen_add_i32(tmp, tmp, tmp2);
7329 tcg_temp_free_i32(tmp2);
7330 }
7331 if (insn & (1 << 20))
7332 gen_logic_CC(tmp);
7333 store_reg(s, rd, tmp);
7334 break;
7335 case 4:
7336 /* 64 bit mul double accumulate (UMAAL) */
7337 ARCH(6);
7338 tmp = load_reg(s, rs);
7339 tmp2 = load_reg(s, rm);
7340 tmp64 = gen_mulu_i64_i32(tmp, tmp2);
7341 gen_addq_lo(s, tmp64, rn);
7342 gen_addq_lo(s, tmp64, rd);
7343 gen_storeq_reg(s, rn, rd, tmp64);
7344 tcg_temp_free_i64(tmp64);
7345 break;
7346 case 8: case 9: case 10: case 11:
7347 case 12: case 13: case 14: case 15:
7348 /* 64 bit mul: UMULL, UMLAL, SMULL, SMLAL. */
7349 tmp = load_reg(s, rs);
7350 tmp2 = load_reg(s, rm);
7351 if (insn & (1 << 22)) {
7352 tmp64 = gen_muls_i64_i32(tmp, tmp2);
7353 } else {
7354 tmp64 = gen_mulu_i64_i32(tmp, tmp2);
7355 }
7356 if (insn & (1 << 21)) { /* mult accumulate */
7357 gen_addq(s, tmp64, rn, rd);
7358 }
7359 if (insn & (1 << 20)) {
7360 gen_logicq_cc(tmp64);
7361 }
7362 gen_storeq_reg(s, rn, rd, tmp64);
7363 tcg_temp_free_i64(tmp64);
7364 break;
7365 default:
7366 goto illegal_op;
7367 }
7368 } else {
7369 rn = (insn >> 16) & 0xf;
7370 rd = (insn >> 12) & 0xf;
7371 if (insn & (1 << 23)) {
7372 /* load/store exclusive */
7373 op1 = (insn >> 21) & 0x3;
7374 if (op1)
7375 ARCH(6K);
7376 else
7377 ARCH(6);
7378 addr = tcg_temp_local_new_i32();
7379 load_reg_var(s, addr, rn);
7380 if (insn & (1 << 20)) {
7381 switch (op1) {
7382 case 0: /* ldrex */
7383 gen_load_exclusive(s, rd, 15, addr, 2);
7384 break;
7385 case 1: /* ldrexd */
7386 gen_load_exclusive(s, rd, rd + 1, addr, 3);
7387 break;
7388 case 2: /* ldrexb */
7389 gen_load_exclusive(s, rd, 15, addr, 0);
7390 break;
7391 case 3: /* ldrexh */
7392 gen_load_exclusive(s, rd, 15, addr, 1);
7393 break;
7394 default:
7395 abort();
7396 }
7397 } else {
7398 rm = insn & 0xf;
7399 switch (op1) {
7400 case 0: /* strex */
7401 gen_store_exclusive(s, rd, rm, 15, addr, 2);
7402 break;
7403 case 1: /* strexd */
7404 gen_store_exclusive(s, rd, rm, rm + 1, addr, 3);
7405 break;
7406 case 2: /* strexb */
7407 gen_store_exclusive(s, rd, rm, 15, addr, 0);
7408 break;
7409 case 3: /* strexh */
7410 gen_store_exclusive(s, rd, rm, 15, addr, 1);
7411 break;
7412 default:
7413 abort();
7414 }
7415 }
7416 tcg_temp_free(addr);
7417 } else {
7418 /* SWP instruction */
7419 rm = (insn) & 0xf;
7420
7421 /* ??? This is not really atomic. However we know
7422 we never have multiple CPUs running in parallel,
7423 so it is good enough. */
7424 addr = load_reg(s, rn);
7425 tmp = load_reg(s, rm);
7426 if (insn & (1 << 22)) {
7427 tmp2 = gen_ld8u(addr, IS_USER(s));
7428 gen_st8(tmp, addr, IS_USER(s));
7429 } else {
7430 tmp2 = gen_ld32(addr, IS_USER(s));
7431 gen_st32(tmp, addr, IS_USER(s));
7432 }
7433 tcg_temp_free_i32(addr);
7434 store_reg(s, rd, tmp2);
7435 }
7436 }
7437 } else {
7438 int address_offset;
7439 int load;
7440 /* Misc load/store */
7441 rn = (insn >> 16) & 0xf;
7442 rd = (insn >> 12) & 0xf;
7443 addr = load_reg(s, rn);
7444 if (insn & (1 << 24))
7445 gen_add_datah_offset(s, insn, 0, addr);
7446 address_offset = 0;
7447 if (insn & (1 << 20)) {
7448 /* load */
7449 switch(sh) {
7450 case 1:
7451 tmp = gen_ld16u(addr, IS_USER(s));
7452 break;
7453 case 2:
7454 tmp = gen_ld8s(addr, IS_USER(s));
7455 break;
7456 default:
7457 case 3:
7458 tmp = gen_ld16s(addr, IS_USER(s));
7459 break;
7460 }
7461 load = 1;
7462 } else if (sh & 2) {
7463 ARCH(5TE);
7464 /* doubleword */
7465 if (sh & 1) {
7466 /* store */
7467 tmp = load_reg(s, rd);
7468 gen_st32(tmp, addr, IS_USER(s));
7469 tcg_gen_addi_i32(addr, addr, 4);
7470 tmp = load_reg(s, rd + 1);
7471 gen_st32(tmp, addr, IS_USER(s));
7472 load = 0;
7473 } else {
7474 /* load */
7475 tmp = gen_ld32(addr, IS_USER(s));
7476 store_reg(s, rd, tmp);
7477 tcg_gen_addi_i32(addr, addr, 4);
7478 tmp = gen_ld32(addr, IS_USER(s));
7479 rd++;
7480 load = 1;
7481 }
7482 address_offset = -4;
7483 } else {
7484 /* store */
7485 tmp = load_reg(s, rd);
7486 gen_st16(tmp, addr, IS_USER(s));
7487 load = 0;
7488 }
7489 /* Perform base writeback before the loaded value to
7490 ensure correct behavior with overlapping index registers.
7491 ldrd with base writeback is is undefined if the
7492 destination and index registers overlap. */
7493 if (!(insn & (1 << 24))) {
7494 gen_add_datah_offset(s, insn, address_offset, addr);
7495 store_reg(s, rn, addr);
7496 } else if (insn & (1 << 21)) {
7497 if (address_offset)
7498 tcg_gen_addi_i32(addr, addr, address_offset);
7499 store_reg(s, rn, addr);
7500 } else {
7501 tcg_temp_free_i32(addr);
7502 }
7503 if (load) {
7504 /* Complete the load. */
7505 store_reg(s, rd, tmp);
7506 }
7507 }
7508 break;
7509 case 0x4:
7510 case 0x5:
7511 goto do_ldst;
7512 case 0x6:
7513 case 0x7:
7514 if (insn & (1 << 4)) {
7515 ARCH(6);
7516 /* Armv6 Media instructions. */
7517 rm = insn & 0xf;
7518 rn = (insn >> 16) & 0xf;
7519 rd = (insn >> 12) & 0xf;
7520 rs = (insn >> 8) & 0xf;
7521 switch ((insn >> 23) & 3) {
7522 case 0: /* Parallel add/subtract. */
7523 op1 = (insn >> 20) & 7;
7524 tmp = load_reg(s, rn);
7525 tmp2 = load_reg(s, rm);
7526 sh = (insn >> 5) & 7;
7527 if ((op1 & 3) == 0 || sh == 5 || sh == 6)
7528 goto illegal_op;
7529 gen_arm_parallel_addsub(op1, sh, tmp, tmp2);
7530 tcg_temp_free_i32(tmp2);
7531 store_reg(s, rd, tmp);
7532 break;
7533 case 1:
7534 if ((insn & 0x00700020) == 0) {
7535 /* Halfword pack. */
7536 tmp = load_reg(s, rn);
7537 tmp2 = load_reg(s, rm);
7538 shift = (insn >> 7) & 0x1f;
7539 if (insn & (1 << 6)) {
7540 /* pkhtb */
7541 if (shift == 0)
7542 shift = 31;
7543 tcg_gen_sari_i32(tmp2, tmp2, shift);
7544 tcg_gen_andi_i32(tmp, tmp, 0xffff0000);
7545 tcg_gen_ext16u_i32(tmp2, tmp2);
7546 } else {
7547 /* pkhbt */
7548 if (shift)
7549 tcg_gen_shli_i32(tmp2, tmp2, shift);
7550 tcg_gen_ext16u_i32(tmp, tmp);
7551 tcg_gen_andi_i32(tmp2, tmp2, 0xffff0000);
7552 }
7553 tcg_gen_or_i32(tmp, tmp, tmp2);
7554 tcg_temp_free_i32(tmp2);
7555 store_reg(s, rd, tmp);
7556 } else if ((insn & 0x00200020) == 0x00200000) {
7557 /* [us]sat */
7558 tmp = load_reg(s, rm);
7559 shift = (insn >> 7) & 0x1f;
7560 if (insn & (1 << 6)) {
7561 if (shift == 0)
7562 shift = 31;
7563 tcg_gen_sari_i32(tmp, tmp, shift);
7564 } else {
7565 tcg_gen_shli_i32(tmp, tmp, shift);
7566 }
7567 sh = (insn >> 16) & 0x1f;
7568 tmp2 = tcg_const_i32(sh);
7569 if (insn & (1 << 22))
7570 gen_helper_usat(tmp, tmp, tmp2);
7571 else
7572 gen_helper_ssat(tmp, tmp, tmp2);
7573 tcg_temp_free_i32(tmp2);
7574 store_reg(s, rd, tmp);
7575 } else if ((insn & 0x00300fe0) == 0x00200f20) {
7576 /* [us]sat16 */
7577 tmp = load_reg(s, rm);
7578 sh = (insn >> 16) & 0x1f;
7579 tmp2 = tcg_const_i32(sh);
7580 if (insn & (1 << 22))
7581 gen_helper_usat16(tmp, tmp, tmp2);
7582 else
7583 gen_helper_ssat16(tmp, tmp, tmp2);
7584 tcg_temp_free_i32(tmp2);
7585 store_reg(s, rd, tmp);
7586 } else if ((insn & 0x00700fe0) == 0x00000fa0) {
7587 /* Select bytes. */
7588 tmp = load_reg(s, rn);
7589 tmp2 = load_reg(s, rm);
7590 tmp3 = tcg_temp_new_i32();
7591 tcg_gen_ld_i32(tmp3, cpu_env, offsetof(CPUARMState, GE));
7592 gen_helper_sel_flags(tmp, tmp3, tmp, tmp2);
7593 tcg_temp_free_i32(tmp3);
7594 tcg_temp_free_i32(tmp2);
7595 store_reg(s, rd, tmp);
7596 } else if ((insn & 0x000003e0) == 0x00000060) {
7597 tmp = load_reg(s, rm);
7598 shift = (insn >> 10) & 3;
7599 /* ??? In many cases it's not necessary to do a
7600 rotate, a shift is sufficient. */
7601 if (shift != 0)
7602 tcg_gen_rotri_i32(tmp, tmp, shift * 8);
7603 op1 = (insn >> 20) & 7;
7604 switch (op1) {
7605 case 0: gen_sxtb16(tmp); break;
7606 case 2: gen_sxtb(tmp); break;
7607 case 3: gen_sxth(tmp); break;
7608 case 4: gen_uxtb16(tmp); break;
7609 case 6: gen_uxtb(tmp); break;
7610 case 7: gen_uxth(tmp); break;
7611 default: goto illegal_op;
7612 }
7613 if (rn != 15) {
7614 tmp2 = load_reg(s, rn);
7615 if ((op1 & 3) == 0) {
7616 gen_add16(tmp, tmp2);
7617 } else {
7618 tcg_gen_add_i32(tmp, tmp, tmp2);
7619 tcg_temp_free_i32(tmp2);
7620 }
7621 }
7622 store_reg(s, rd, tmp);
7623 } else if ((insn & 0x003f0f60) == 0x003f0f20) {
7624 /* rev */
7625 tmp = load_reg(s, rm);
7626 if (insn & (1 << 22)) {
7627 if (insn & (1 << 7)) {
7628 gen_revsh(tmp);
7629 } else {
7630 ARCH(6T2);
7631 gen_helper_rbit(tmp, tmp);
7632 }
7633 } else {
7634 if (insn & (1 << 7))
7635 gen_rev16(tmp);
7636 else
7637 tcg_gen_bswap32_i32(tmp, tmp);
7638 }
7639 store_reg(s, rd, tmp);
7640 } else {
7641 goto illegal_op;
7642 }
7643 break;
7644 case 2: /* Multiplies (Type 3). */
7645 switch ((insn >> 20) & 0x7) {
7646 case 5:
7647 if (((insn >> 6) ^ (insn >> 7)) & 1) {
7648 /* op2 not 00x or 11x : UNDEF */
7649 goto illegal_op;
7650 }
7651 /* Signed multiply most significant [accumulate].
7652 (SMMUL, SMMLA, SMMLS) */
7653 tmp = load_reg(s, rm);
7654 tmp2 = load_reg(s, rs);
7655 tmp64 = gen_muls_i64_i32(tmp, tmp2);
7656
7657 if (rd != 15) {
7658 tmp = load_reg(s, rd);
7659 if (insn & (1 << 6)) {
7660 tmp64 = gen_subq_msw(tmp64, tmp);
7661 } else {
7662 tmp64 = gen_addq_msw(tmp64, tmp);
7663 }
7664 }
7665 if (insn & (1 << 5)) {
7666 tcg_gen_addi_i64(tmp64, tmp64, 0x80000000u);
7667 }
7668 tcg_gen_shri_i64(tmp64, tmp64, 32);
7669 tmp = tcg_temp_new_i32();
7670 tcg_gen_trunc_i64_i32(tmp, tmp64);
7671 tcg_temp_free_i64(tmp64);
7672 store_reg(s, rn, tmp);
7673 break;
7674 case 0:
7675 case 4:
7676 /* SMLAD, SMUAD, SMLSD, SMUSD, SMLALD, SMLSLD */
7677 if (insn & (1 << 7)) {
7678 goto illegal_op;
7679 }
7680 tmp = load_reg(s, rm);
7681 tmp2 = load_reg(s, rs);
7682 if (insn & (1 << 5))
7683 gen_swap_half(tmp2);
7684 gen_smul_dual(tmp, tmp2);
7685 if (insn & (1 << 6)) {
7686 /* This subtraction cannot overflow. */
7687 tcg_gen_sub_i32(tmp, tmp, tmp2);
7688 } else {
7689 /* This addition cannot overflow 32 bits;
7690 * however it may overflow considered as a signed
7691 * operation, in which case we must set the Q flag.
7692 */
7693 gen_helper_add_setq(tmp, tmp, tmp2);
7694 }
7695 tcg_temp_free_i32(tmp2);
7696 if (insn & (1 << 22)) {
7697 /* smlald, smlsld */
7698 tmp64 = tcg_temp_new_i64();
7699 tcg_gen_ext_i32_i64(tmp64, tmp);
7700 tcg_temp_free_i32(tmp);
7701 gen_addq(s, tmp64, rd, rn);
7702 gen_storeq_reg(s, rd, rn, tmp64);
7703 tcg_temp_free_i64(tmp64);
7704 } else {
7705 /* smuad, smusd, smlad, smlsd */
7706 if (rd != 15)
7707 {
7708 tmp2 = load_reg(s, rd);
7709 gen_helper_add_setq(tmp, tmp, tmp2);
7710 tcg_temp_free_i32(tmp2);
7711 }
7712 store_reg(s, rn, tmp);
7713 }
7714 break;
7715 case 1:
7716 case 3:
7717 /* SDIV, UDIV */
7718 if (!arm_feature(env, ARM_FEATURE_ARM_DIV)) {
7719 goto illegal_op;
7720 }
7721 if (((insn >> 5) & 7) || (rd != 15)) {
7722 goto illegal_op;
7723 }
7724 tmp = load_reg(s, rm);
7725 tmp2 = load_reg(s, rs);
7726 if (insn & (1 << 21)) {
7727 gen_helper_udiv(tmp, tmp, tmp2);
7728 } else {
7729 gen_helper_sdiv(tmp, tmp, tmp2);
7730 }
7731 tcg_temp_free_i32(tmp2);
7732 store_reg(s, rn, tmp);
7733 break;
7734 default:
7735 goto illegal_op;
7736 }
7737 break;
7738 case 3:
7739 op1 = ((insn >> 17) & 0x38) | ((insn >> 5) & 7);
7740 switch (op1) {
7741 case 0: /* Unsigned sum of absolute differences. */
7742 ARCH(6);
7743 tmp = load_reg(s, rm);
7744 tmp2 = load_reg(s, rs);
7745 gen_helper_usad8(tmp, tmp, tmp2);
7746 tcg_temp_free_i32(tmp2);
7747 if (rd != 15) {
7748 tmp2 = load_reg(s, rd);
7749 tcg_gen_add_i32(tmp, tmp, tmp2);
7750 tcg_temp_free_i32(tmp2);
7751 }
7752 store_reg(s, rn, tmp);
7753 break;
7754 case 0x20: case 0x24: case 0x28: case 0x2c:
7755 /* Bitfield insert/clear. */
7756 ARCH(6T2);
7757 shift = (insn >> 7) & 0x1f;
7758 i = (insn >> 16) & 0x1f;
7759 i = i + 1 - shift;
7760 if (rm == 15) {
7761 tmp = tcg_temp_new_i32();
7762 tcg_gen_movi_i32(tmp, 0);
7763 } else {
7764 tmp = load_reg(s, rm);
7765 }
7766 if (i != 32) {
7767 tmp2 = load_reg(s, rd);
7768 gen_bfi(tmp, tmp2, tmp, shift, (1u << i) - 1);
7769 tcg_temp_free_i32(tmp2);
7770 }
7771 store_reg(s, rd, tmp);
7772 break;
7773 case 0x12: case 0x16: case 0x1a: case 0x1e: /* sbfx */
7774 case 0x32: case 0x36: case 0x3a: case 0x3e: /* ubfx */
7775 ARCH(6T2);
7776 tmp = load_reg(s, rm);
7777 shift = (insn >> 7) & 0x1f;
7778 i = ((insn >> 16) & 0x1f) + 1;
7779 if (shift + i > 32)
7780 goto illegal_op;
7781 if (i < 32) {
7782 if (op1 & 0x20) {
7783 gen_ubfx(tmp, shift, (1u << i) - 1);
7784 } else {
7785 gen_sbfx(tmp, shift, i);
7786 }
7787 }
7788 store_reg(s, rd, tmp);
7789 break;
7790 default:
7791 goto illegal_op;
7792 }
7793 break;
7794 }
7795 break;
7796 }
7797 do_ldst:
7798 /* Check for undefined extension instructions
7799 * per the ARM Bible IE:
7800 * xxxx 0111 1111 xxxx xxxx xxxx 1111 xxxx
7801 */
7802 sh = (0xf << 20) | (0xf << 4);
7803 if (op1 == 0x7 && ((insn & sh) == sh))
7804 {
7805 goto illegal_op;
7806 }
7807 /* load/store byte/word */
7808 rn = (insn >> 16) & 0xf;
7809 rd = (insn >> 12) & 0xf;
7810 tmp2 = load_reg(s, rn);
7811 i = (IS_USER(s) || (insn & 0x01200000) == 0x00200000);
7812 if (insn & (1 << 24))
7813 gen_add_data_offset(s, insn, tmp2);
7814 if (insn & (1 << 20)) {
7815 /* load */
7816 if (insn & (1 << 22)) {
7817 tmp = gen_ld8u(tmp2, i);
7818 } else {
7819 tmp = gen_ld32(tmp2, i);
7820 }
7821 } else {
7822 /* store */
7823 tmp = load_reg(s, rd);
7824 if (insn & (1 << 22))
7825 gen_st8(tmp, tmp2, i);
7826 else
7827 gen_st32(tmp, tmp2, i);
7828 }
7829 if (!(insn & (1 << 24))) {
7830 gen_add_data_offset(s, insn, tmp2);
7831 store_reg(s, rn, tmp2);
7832 } else if (insn & (1 << 21)) {
7833 store_reg(s, rn, tmp2);
7834 } else {
7835 tcg_temp_free_i32(tmp2);
7836 }
7837 if (insn & (1 << 20)) {
7838 /* Complete the load. */
7839 store_reg_from_load(env, s, rd, tmp);
7840 }
7841 break;
7842 case 0x08:
7843 case 0x09:
7844 {
7845 int j, n, user, loaded_base;
7846 TCGv loaded_var;
7847 /* load/store multiple words */
7848 /* XXX: store correct base if write back */
7849 user = 0;
7850 if (insn & (1 << 22)) {
7851 if (IS_USER(s))
7852 goto illegal_op; /* only usable in supervisor mode */
7853
7854 if ((insn & (1 << 15)) == 0)
7855 user = 1;
7856 }
7857 rn = (insn >> 16) & 0xf;
7858 addr = load_reg(s, rn);
7859
7860 /* compute total size */
7861 loaded_base = 0;
7862 TCGV_UNUSED(loaded_var);
7863 n = 0;
7864 for(i=0;i<16;i++) {
7865 if (insn & (1 << i))
7866 n++;
7867 }
7868 /* XXX: test invalid n == 0 case ? */
7869 if (insn & (1 << 23)) {
7870 if (insn & (1 << 24)) {
7871 /* pre increment */
7872 tcg_gen_addi_i32(addr, addr, 4);
7873 } else {
7874 /* post increment */
7875 }
7876 } else {
7877 if (insn & (1 << 24)) {
7878 /* pre decrement */
7879 tcg_gen_addi_i32(addr, addr, -(n * 4));
7880 } else {
7881 /* post decrement */
7882 if (n != 1)
7883 tcg_gen_addi_i32(addr, addr, -((n - 1) * 4));
7884 }
7885 }
7886 j = 0;
7887 for(i=0;i<16;i++) {
7888 if (insn & (1 << i)) {
7889 if (insn & (1 << 20)) {
7890 /* load */
7891 tmp = gen_ld32(addr, IS_USER(s));
7892 if (user) {
7893 tmp2 = tcg_const_i32(i);
7894 gen_helper_set_user_reg(tmp2, tmp);
7895 tcg_temp_free_i32(tmp2);
7896 tcg_temp_free_i32(tmp);
7897 } else if (i == rn) {
7898 loaded_var = tmp;
7899 loaded_base = 1;
7900 } else {
7901 store_reg_from_load(env, s, i, tmp);
7902 }
7903 } else {
7904 /* store */
7905 if (i == 15) {
7906 /* special case: r15 = PC + 8 */
7907 val = (long)s->pc + 4;
7908 tmp = tcg_temp_new_i32();
7909 tcg_gen_movi_i32(tmp, val);
7910 } else if (user) {
7911 tmp = tcg_temp_new_i32();
7912 tmp2 = tcg_const_i32(i);
7913 gen_helper_get_user_reg(tmp, tmp2);
7914 tcg_temp_free_i32(tmp2);
7915 } else {
7916 tmp = load_reg(s, i);
7917 }
7918 gen_st32(tmp, addr, IS_USER(s));
7919 }
7920 j++;
7921 /* no need to add after the last transfer */
7922 if (j != n)
7923 tcg_gen_addi_i32(addr, addr, 4);
7924 }
7925 }
7926 if (insn & (1 << 21)) {
7927 /* write back */
7928 if (insn & (1 << 23)) {
7929 if (insn & (1 << 24)) {
7930 /* pre increment */
7931 } else {
7932 /* post increment */
7933 tcg_gen_addi_i32(addr, addr, 4);
7934 }
7935 } else {
7936 if (insn & (1 << 24)) {
7937 /* pre decrement */
7938 if (n != 1)
7939 tcg_gen_addi_i32(addr, addr, -((n - 1) * 4));
7940 } else {
7941 /* post decrement */
7942 tcg_gen_addi_i32(addr, addr, -(n * 4));
7943 }
7944 }
7945 store_reg(s, rn, addr);
7946 } else {
7947 tcg_temp_free_i32(addr);
7948 }
7949 if (loaded_base) {
7950 store_reg(s, rn, loaded_var);
7951 }
7952 if ((insn & (1 << 22)) && !user) {
7953 /* Restore CPSR from SPSR. */
7954 tmp = load_cpu_field(spsr);
7955 gen_set_cpsr(tmp, 0xffffffff);
7956 tcg_temp_free_i32(tmp);
7957 s->is_jmp = DISAS_UPDATE;
7958 }
7959 }
7960 break;
7961 case 0xa:
7962 case 0xb:
7963 {
7964 int32_t offset;
7965
7966 /* branch (and link) */
7967 val = (int32_t)s->pc;
7968 if (insn & (1 << 24)) {
7969 tmp = tcg_temp_new_i32();
7970 tcg_gen_movi_i32(tmp, val);
7971 store_reg(s, 14, tmp);
7972 }
7973 offset = (((int32_t)insn << 8) >> 8);
7974 val += (offset << 2) + 4;
7975 gen_jmp(s, val);
7976 }
7977 break;
7978 case 0xc:
7979 case 0xd:
7980 case 0xe:
7981 /* Coprocessor. */
7982 if (disas_coproc_insn(env, s, insn))
7983 goto illegal_op;
7984 break;
7985 case 0xf:
7986 /* swi */
7987 gen_set_pc_im(s->pc);
7988 s->is_jmp = DISAS_SWI;
7989 break;
7990 default:
7991 illegal_op:
7992 gen_exception_insn(s, 4, EXCP_UDEF);
7993 break;
7994 }
7995 }
7996 }
7997
7998 /* Return true if this is a Thumb-2 logical op. */
7999 static int
8000 thumb2_logic_op(int op)
8001 {
8002 return (op < 8);
8003 }
8004
8005 /* Generate code for a Thumb-2 data processing operation. If CONDS is nonzero
8006 then set condition code flags based on the result of the operation.
8007 If SHIFTER_OUT is nonzero then set the carry flag for logical operations
8008 to the high bit of T1.
8009 Returns zero if the opcode is valid. */
8010
8011 static int
8012 gen_thumb2_data_op(DisasContext *s, int op, int conds, uint32_t shifter_out, TCGv t0, TCGv t1)
8013 {
8014 int logic_cc;
8015
8016 logic_cc = 0;
8017 switch (op) {
8018 case 0: /* and */
8019 tcg_gen_and_i32(t0, t0, t1);
8020 logic_cc = conds;
8021 break;
8022 case 1: /* bic */
8023 tcg_gen_andc_i32(t0, t0, t1);
8024 logic_cc = conds;
8025 break;
8026 case 2: /* orr */
8027 tcg_gen_or_i32(t0, t0, t1);
8028 logic_cc = conds;
8029 break;
8030 case 3: /* orn */
8031 tcg_gen_orc_i32(t0, t0, t1);
8032 logic_cc = conds;
8033 break;
8034 case 4: /* eor */
8035 tcg_gen_xor_i32(t0, t0, t1);
8036 logic_cc = conds;
8037 break;
8038 case 8: /* add */
8039 if (conds)
8040 gen_helper_add_cc(t0, t0, t1);
8041 else
8042 tcg_gen_add_i32(t0, t0, t1);
8043 break;
8044 case 10: /* adc */
8045 if (conds)
8046 gen_helper_adc_cc(t0, t0, t1);
8047 else
8048 gen_adc(t0, t1);
8049 break;
8050 case 11: /* sbc */
8051 if (conds)
8052 gen_helper_sbc_cc(t0, t0, t1);
8053 else
8054 gen_sub_carry(t0, t0, t1);
8055 break;
8056 case 13: /* sub */
8057 if (conds)
8058 gen_helper_sub_cc(t0, t0, t1);
8059 else
8060 tcg_gen_sub_i32(t0, t0, t1);
8061 break;
8062 case 14: /* rsb */
8063 if (conds)
8064 gen_helper_sub_cc(t0, t1, t0);
8065 else
8066 tcg_gen_sub_i32(t0, t1, t0);
8067 break;
8068 default: /* 5, 6, 7, 9, 12, 15. */
8069 return 1;
8070 }
8071 if (logic_cc) {
8072 gen_logic_CC(t0);
8073 if (shifter_out)
8074 gen_set_CF_bit31(t1);
8075 }
8076 return 0;
8077 }
8078
8079 /* Translate a 32-bit thumb instruction. Returns nonzero if the instruction
8080 is not legal. */
8081 static int disas_thumb2_insn(CPUARMState *env, DisasContext *s, uint16_t insn_hw1)
8082 {
8083 uint32_t insn, imm, shift, offset;
8084 uint32_t rd, rn, rm, rs;
8085 TCGv tmp;
8086 TCGv tmp2;
8087 TCGv tmp3;
8088 TCGv addr;
8089 TCGv_i64 tmp64;
8090 int op;
8091 int shiftop;
8092 int conds;
8093 int logic_cc;
8094
8095 if (!(arm_feature(env, ARM_FEATURE_THUMB2)
8096 || arm_feature (env, ARM_FEATURE_M))) {
8097 /* Thumb-1 cores may need to treat bl and blx as a pair of
8098 16-bit instructions to get correct prefetch abort behavior. */
8099 insn = insn_hw1;
8100 if ((insn & (1 << 12)) == 0) {
8101 ARCH(5);
8102 /* Second half of blx. */
8103 offset = ((insn & 0x7ff) << 1);
8104 tmp = load_reg(s, 14);
8105 tcg_gen_addi_i32(tmp, tmp, offset);
8106 tcg_gen_andi_i32(tmp, tmp, 0xfffffffc);
8107
8108 tmp2 = tcg_temp_new_i32();
8109 tcg_gen_movi_i32(tmp2, s->pc | 1);
8110 store_reg(s, 14, tmp2);
8111 gen_bx(s, tmp);
8112 return 0;
8113 }
8114 if (insn & (1 << 11)) {
8115 /* Second half of bl. */
8116 offset = ((insn & 0x7ff) << 1) | 1;
8117 tmp = load_reg(s, 14);
8118 tcg_gen_addi_i32(tmp, tmp, offset);
8119
8120 tmp2 = tcg_temp_new_i32();
8121 tcg_gen_movi_i32(tmp2, s->pc | 1);
8122 store_reg(s, 14, tmp2);
8123 gen_bx(s, tmp);
8124 return 0;
8125 }
8126 if ((s->pc & ~TARGET_PAGE_MASK) == 0) {
8127 /* Instruction spans a page boundary. Implement it as two
8128 16-bit instructions in case the second half causes an
8129 prefetch abort. */
8130 offset = ((int32_t)insn << 21) >> 9;
8131 tcg_gen_movi_i32(cpu_R[14], s->pc + 2 + offset);
8132 return 0;
8133 }
8134 /* Fall through to 32-bit decode. */
8135 }
8136
8137 insn = arm_lduw_code(s->pc, s->bswap_code);
8138 s->pc += 2;
8139 insn |= (uint32_t)insn_hw1 << 16;
8140
8141 if ((insn & 0xf800e800) != 0xf000e800) {
8142 ARCH(6T2);
8143 }
8144
8145 rn = (insn >> 16) & 0xf;
8146 rs = (insn >> 12) & 0xf;
8147 rd = (insn >> 8) & 0xf;
8148 rm = insn & 0xf;
8149 switch ((insn >> 25) & 0xf) {
8150 case 0: case 1: case 2: case 3:
8151 /* 16-bit instructions. Should never happen. */
8152 abort();
8153 case 4:
8154 if (insn & (1 << 22)) {
8155 /* Other load/store, table branch. */
8156 if (insn & 0x01200000) {
8157 /* Load/store doubleword. */
8158 if (rn == 15) {
8159 addr = tcg_temp_new_i32();
8160 tcg_gen_movi_i32(addr, s->pc & ~3);
8161 } else {
8162 addr = load_reg(s, rn);
8163 }
8164 offset = (insn & 0xff) * 4;
8165 if ((insn & (1 << 23)) == 0)
8166 offset = -offset;
8167 if (insn & (1 << 24)) {
8168 tcg_gen_addi_i32(addr, addr, offset);
8169 offset = 0;
8170 }
8171 if (insn & (1 << 20)) {
8172 /* ldrd */
8173 tmp = gen_ld32(addr, IS_USER(s));
8174 store_reg(s, rs, tmp);
8175 tcg_gen_addi_i32(addr, addr, 4);
8176 tmp = gen_ld32(addr, IS_USER(s));
8177 store_reg(s, rd, tmp);
8178 } else {
8179 /* strd */
8180 tmp = load_reg(s, rs);
8181 gen_st32(tmp, addr, IS_USER(s));
8182 tcg_gen_addi_i32(addr, addr, 4);
8183 tmp = load_reg(s, rd);
8184 gen_st32(tmp, addr, IS_USER(s));
8185 }
8186 if (insn & (1 << 21)) {
8187 /* Base writeback. */
8188 if (rn == 15)
8189 goto illegal_op;
8190 tcg_gen_addi_i32(addr, addr, offset - 4);
8191 store_reg(s, rn, addr);
8192 } else {
8193 tcg_temp_free_i32(addr);
8194 }
8195 } else if ((insn & (1 << 23)) == 0) {
8196 /* Load/store exclusive word. */
8197 addr = tcg_temp_local_new();
8198 load_reg_var(s, addr, rn);
8199 tcg_gen_addi_i32(addr, addr, (insn & 0xff) << 2);
8200 if (insn & (1 << 20)) {
8201 gen_load_exclusive(s, rs, 15, addr, 2);
8202 } else {
8203 gen_store_exclusive(s, rd, rs, 15, addr, 2);
8204 }
8205 tcg_temp_free(addr);
8206 } else if ((insn & (1 << 6)) == 0) {
8207 /* Table Branch. */
8208 if (rn == 15) {
8209 addr = tcg_temp_new_i32();
8210 tcg_gen_movi_i32(addr, s->pc);
8211 } else {
8212 addr = load_reg(s, rn);
8213 }
8214 tmp = load_reg(s, rm);
8215 tcg_gen_add_i32(addr, addr, tmp);
8216 if (insn & (1 << 4)) {
8217 /* tbh */
8218 tcg_gen_add_i32(addr, addr, tmp);
8219 tcg_temp_free_i32(tmp);
8220 tmp = gen_ld16u(addr, IS_USER(s));
8221 } else { /* tbb */
8222 tcg_temp_free_i32(tmp);
8223 tmp = gen_ld8u(addr, IS_USER(s));
8224 }
8225 tcg_temp_free_i32(addr);
8226 tcg_gen_shli_i32(tmp, tmp, 1);
8227 tcg_gen_addi_i32(tmp, tmp, s->pc);
8228 store_reg(s, 15, tmp);
8229 } else {
8230 /* Load/store exclusive byte/halfword/doubleword. */
8231 ARCH(7);
8232 op = (insn >> 4) & 0x3;
8233 if (op == 2) {
8234 goto illegal_op;
8235 }
8236 addr = tcg_temp_local_new();
8237 load_reg_var(s, addr, rn);
8238 if (insn & (1 << 20)) {
8239 gen_load_exclusive(s, rs, rd, addr, op);
8240 } else {
8241 gen_store_exclusive(s, rm, rs, rd, addr, op);
8242 }
8243 tcg_temp_free(addr);
8244 }
8245 } else {
8246 /* Load/store multiple, RFE, SRS. */
8247 if (((insn >> 23) & 1) == ((insn >> 24) & 1)) {
8248 /* Not available in user mode. */
8249 if (IS_USER(s))
8250 goto illegal_op;
8251 if (insn & (1 << 20)) {
8252 /* rfe */
8253 addr = load_reg(s, rn);
8254 if ((insn & (1 << 24)) == 0)
8255 tcg_gen_addi_i32(addr, addr, -8);
8256 /* Load PC into tmp and CPSR into tmp2. */
8257 tmp = gen_ld32(addr, 0);
8258 tcg_gen_addi_i32(addr, addr, 4);
8259 tmp2 = gen_ld32(addr, 0);
8260 if (insn & (1 << 21)) {
8261 /* Base writeback. */
8262 if (insn & (1 << 24)) {
8263 tcg_gen_addi_i32(addr, addr, 4);
8264 } else {
8265 tcg_gen_addi_i32(addr, addr, -4);
8266 }
8267 store_reg(s, rn, addr);
8268 } else {
8269 tcg_temp_free_i32(addr);
8270 }
8271 gen_rfe(s, tmp, tmp2);
8272 } else {
8273 /* srs */
8274 op = (insn & 0x1f);
8275 addr = tcg_temp_new_i32();
8276 tmp = tcg_const_i32(op);
8277 gen_helper_get_r13_banked(addr, cpu_env, tmp);
8278 tcg_temp_free_i32(tmp);
8279 if ((insn & (1 << 24)) == 0) {
8280 tcg_gen_addi_i32(addr, addr, -8);
8281 }
8282 tmp = load_reg(s, 14);
8283 gen_st32(tmp, addr, 0);
8284 tcg_gen_addi_i32(addr, addr, 4);
8285 tmp = tcg_temp_new_i32();
8286 gen_helper_cpsr_read(tmp);
8287 gen_st32(tmp, addr, 0);
8288 if (insn & (1 << 21)) {
8289 if ((insn & (1 << 24)) == 0) {
8290 tcg_gen_addi_i32(addr, addr, -4);
8291 } else {
8292 tcg_gen_addi_i32(addr, addr, 4);
8293 }
8294 tmp = tcg_const_i32(op);
8295 gen_helper_set_r13_banked(cpu_env, tmp, addr);
8296 tcg_temp_free_i32(tmp);
8297 } else {
8298 tcg_temp_free_i32(addr);
8299 }
8300 }
8301 } else {
8302 int i, loaded_base = 0;
8303 TCGv loaded_var;
8304 /* Load/store multiple. */
8305 addr = load_reg(s, rn);
8306 offset = 0;
8307 for (i = 0; i < 16; i++) {
8308 if (insn & (1 << i))
8309 offset += 4;
8310 }
8311 if (insn & (1 << 24)) {
8312 tcg_gen_addi_i32(addr, addr, -offset);
8313 }
8314
8315 TCGV_UNUSED(loaded_var);
8316 for (i = 0; i < 16; i++) {
8317 if ((insn & (1 << i)) == 0)
8318 continue;
8319 if (insn & (1 << 20)) {
8320 /* Load. */
8321 tmp = gen_ld32(addr, IS_USER(s));
8322 if (i == 15) {
8323 gen_bx(s, tmp);
8324 } else if (i == rn) {
8325 loaded_var = tmp;
8326 loaded_base = 1;
8327 } else {
8328 store_reg(s, i, tmp);
8329 }
8330 } else {
8331 /* Store. */
8332 tmp = load_reg(s, i);
8333 gen_st32(tmp, addr, IS_USER(s));
8334 }
8335 tcg_gen_addi_i32(addr, addr, 4);
8336 }
8337 if (loaded_base) {
8338 store_reg(s, rn, loaded_var);
8339 }
8340 if (insn & (1 << 21)) {
8341 /* Base register writeback. */
8342 if (insn & (1 << 24)) {
8343 tcg_gen_addi_i32(addr, addr, -offset);
8344 }
8345 /* Fault if writeback register is in register list. */
8346 if (insn & (1 << rn))
8347 goto illegal_op;
8348 store_reg(s, rn, addr);
8349 } else {
8350 tcg_temp_free_i32(addr);
8351 }
8352 }
8353 }
8354 break;
8355 case 5:
8356
8357 op = (insn >> 21) & 0xf;
8358 if (op == 6) {
8359 /* Halfword pack. */
8360 tmp = load_reg(s, rn);
8361 tmp2 = load_reg(s, rm);
8362 shift = ((insn >> 10) & 0x1c) | ((insn >> 6) & 0x3);
8363 if (insn & (1 << 5)) {
8364 /* pkhtb */
8365 if (shift == 0)
8366 shift = 31;
8367 tcg_gen_sari_i32(tmp2, tmp2, shift);
8368 tcg_gen_andi_i32(tmp, tmp, 0xffff0000);
8369 tcg_gen_ext16u_i32(tmp2, tmp2);
8370 } else {
8371 /* pkhbt */
8372 if (shift)
8373 tcg_gen_shli_i32(tmp2, tmp2, shift);
8374 tcg_gen_ext16u_i32(tmp, tmp);
8375 tcg_gen_andi_i32(tmp2, tmp2, 0xffff0000);
8376 }
8377 tcg_gen_or_i32(tmp, tmp, tmp2);
8378 tcg_temp_free_i32(tmp2);
8379 store_reg(s, rd, tmp);
8380 } else {
8381 /* Data processing register constant shift. */
8382 if (rn == 15) {
8383 tmp = tcg_temp_new_i32();
8384 tcg_gen_movi_i32(tmp, 0);
8385 } else {
8386 tmp = load_reg(s, rn);
8387 }
8388 tmp2 = load_reg(s, rm);
8389
8390 shiftop = (insn >> 4) & 3;
8391 shift = ((insn >> 6) & 3) | ((insn >> 10) & 0x1c);
8392 conds = (insn & (1 << 20)) != 0;
8393 logic_cc = (conds && thumb2_logic_op(op));
8394 gen_arm_shift_im(tmp2, shiftop, shift, logic_cc);
8395 if (gen_thumb2_data_op(s, op, conds, 0, tmp, tmp2))
8396 goto illegal_op;
8397 tcg_temp_free_i32(tmp2);
8398 if (rd != 15) {
8399 store_reg(s, rd, tmp);
8400 } else {
8401 tcg_temp_free_i32(tmp);
8402 }
8403 }
8404 break;
8405 case 13: /* Misc data processing. */
8406 op = ((insn >> 22) & 6) | ((insn >> 7) & 1);
8407 if (op < 4 && (insn & 0xf000) != 0xf000)
8408 goto illegal_op;
8409 switch (op) {
8410 case 0: /* Register controlled shift. */
8411 tmp = load_reg(s, rn);
8412 tmp2 = load_reg(s, rm);
8413 if ((insn & 0x70) != 0)
8414 goto illegal_op;
8415 op = (insn >> 21) & 3;
8416 logic_cc = (insn & (1 << 20)) != 0;
8417 gen_arm_shift_reg(tmp, op, tmp2, logic_cc);
8418 if (logic_cc)
8419 gen_logic_CC(tmp);
8420 store_reg_bx(env, s, rd, tmp);
8421 break;
8422 case 1: /* Sign/zero extend. */
8423 tmp = load_reg(s, rm);
8424 shift = (insn >> 4) & 3;
8425 /* ??? In many cases it's not necessary to do a
8426 rotate, a shift is sufficient. */
8427 if (shift != 0)
8428 tcg_gen_rotri_i32(tmp, tmp, shift * 8);
8429 op = (insn >> 20) & 7;
8430 switch (op) {
8431 case 0: gen_sxth(tmp); break;
8432 case 1: gen_uxth(tmp); break;
8433 case 2: gen_sxtb16(tmp); break;
8434 case 3: gen_uxtb16(tmp); break;
8435 case 4: gen_sxtb(tmp); break;
8436 case 5: gen_uxtb(tmp); break;
8437 default: goto illegal_op;
8438 }
8439 if (rn != 15) {
8440 tmp2 = load_reg(s, rn);
8441 if ((op >> 1) == 1) {
8442 gen_add16(tmp, tmp2);
8443 } else {
8444 tcg_gen_add_i32(tmp, tmp, tmp2);
8445 tcg_temp_free_i32(tmp2);
8446 }
8447 }
8448 store_reg(s, rd, tmp);
8449 break;
8450 case 2: /* SIMD add/subtract. */
8451 op = (insn >> 20) & 7;
8452 shift = (insn >> 4) & 7;
8453 if ((op & 3) == 3 || (shift & 3) == 3)
8454 goto illegal_op;
8455 tmp = load_reg(s, rn);
8456 tmp2 = load_reg(s, rm);
8457 gen_thumb2_parallel_addsub(op, shift, tmp, tmp2);
8458 tcg_temp_free_i32(tmp2);
8459 store_reg(s, rd, tmp);
8460 break;
8461 case 3: /* Other data processing. */
8462 op = ((insn >> 17) & 0x38) | ((insn >> 4) & 7);
8463 if (op < 4) {
8464 /* Saturating add/subtract. */
8465 tmp = load_reg(s, rn);
8466 tmp2 = load_reg(s, rm);
8467 if (op & 1)
8468 gen_helper_double_saturate(tmp, tmp);
8469 if (op & 2)
8470 gen_helper_sub_saturate(tmp, tmp2, tmp);
8471 else
8472 gen_helper_add_saturate(tmp, tmp, tmp2);
8473 tcg_temp_free_i32(tmp2);
8474 } else {
8475 tmp = load_reg(s, rn);
8476 switch (op) {
8477 case 0x0a: /* rbit */
8478 gen_helper_rbit(tmp, tmp);
8479 break;
8480 case 0x08: /* rev */
8481 tcg_gen_bswap32_i32(tmp, tmp);
8482 break;
8483 case 0x09: /* rev16 */
8484 gen_rev16(tmp);
8485 break;
8486 case 0x0b: /* revsh */
8487 gen_revsh(tmp);
8488 break;
8489 case 0x10: /* sel */
8490 tmp2 = load_reg(s, rm);
8491 tmp3 = tcg_temp_new_i32();
8492 tcg_gen_ld_i32(tmp3, cpu_env, offsetof(CPUARMState, GE));
8493 gen_helper_sel_flags(tmp, tmp3, tmp, tmp2);
8494 tcg_temp_free_i32(tmp3);
8495 tcg_temp_free_i32(tmp2);
8496 break;
8497 case 0x18: /* clz */
8498 gen_helper_clz(tmp, tmp);
8499 break;
8500 default:
8501 goto illegal_op;
8502 }
8503 }
8504 store_reg(s, rd, tmp);
8505 break;
8506 case 4: case 5: /* 32-bit multiply. Sum of absolute differences. */
8507 op = (insn >> 4) & 0xf;
8508 tmp = load_reg(s, rn);
8509 tmp2 = load_reg(s, rm);
8510 switch ((insn >> 20) & 7) {
8511 case 0: /* 32 x 32 -> 32 */
8512 tcg_gen_mul_i32(tmp, tmp, tmp2);
8513 tcg_temp_free_i32(tmp2);
8514 if (rs != 15) {
8515 tmp2 = load_reg(s, rs);
8516 if (op)
8517 tcg_gen_sub_i32(tmp, tmp2, tmp);
8518 else
8519 tcg_gen_add_i32(tmp, tmp, tmp2);
8520 tcg_temp_free_i32(tmp2);
8521 }
8522 break;
8523 case 1: /* 16 x 16 -> 32 */
8524 gen_mulxy(tmp, tmp2, op & 2, op & 1);
8525 tcg_temp_free_i32(tmp2);
8526 if (rs != 15) {
8527 tmp2 = load_reg(s, rs);
8528 gen_helper_add_setq(tmp, tmp, tmp2);
8529 tcg_temp_free_i32(tmp2);
8530 }
8531 break;
8532 case 2: /* Dual multiply add. */
8533 case 4: /* Dual multiply subtract. */
8534 if (op)
8535 gen_swap_half(tmp2);
8536 gen_smul_dual(tmp, tmp2);
8537 if (insn & (1 << 22)) {
8538 /* This subtraction cannot overflow. */
8539 tcg_gen_sub_i32(tmp, tmp, tmp2);
8540 } else {
8541 /* This addition cannot overflow 32 bits;
8542 * however it may overflow considered as a signed
8543 * operation, in which case we must set the Q flag.
8544 */
8545 gen_helper_add_setq(tmp, tmp, tmp2);
8546 }
8547 tcg_temp_free_i32(tmp2);
8548 if (rs != 15)
8549 {
8550 tmp2 = load_reg(s, rs);
8551 gen_helper_add_setq(tmp, tmp, tmp2);
8552 tcg_temp_free_i32(tmp2);
8553 }
8554 break;
8555 case 3: /* 32 * 16 -> 32msb */
8556 if (op)
8557 tcg_gen_sari_i32(tmp2, tmp2, 16);
8558 else
8559 gen_sxth(tmp2);
8560 tmp64 = gen_muls_i64_i32(tmp, tmp2);
8561 tcg_gen_shri_i64(tmp64, tmp64, 16);
8562 tmp = tcg_temp_new_i32();
8563 tcg_gen_trunc_i64_i32(tmp, tmp64);
8564 tcg_temp_free_i64(tmp64);
8565 if (rs != 15)
8566 {
8567 tmp2 = load_reg(s, rs);
8568 gen_helper_add_setq(tmp, tmp, tmp2);
8569 tcg_temp_free_i32(tmp2);
8570 }
8571 break;
8572 case 5: case 6: /* 32 * 32 -> 32msb (SMMUL, SMMLA, SMMLS) */
8573 tmp64 = gen_muls_i64_i32(tmp, tmp2);
8574 if (rs != 15) {
8575 tmp = load_reg(s, rs);
8576 if (insn & (1 << 20)) {
8577 tmp64 = gen_addq_msw(tmp64, tmp);
8578 } else {
8579 tmp64 = gen_subq_msw(tmp64, tmp);
8580 }
8581 }
8582 if (insn & (1 << 4)) {
8583 tcg_gen_addi_i64(tmp64, tmp64, 0x80000000u);
8584 }
8585 tcg_gen_shri_i64(tmp64, tmp64, 32);
8586 tmp = tcg_temp_new_i32();
8587 tcg_gen_trunc_i64_i32(tmp, tmp64);
8588 tcg_temp_free_i64(tmp64);
8589 break;
8590 case 7: /* Unsigned sum of absolute differences. */
8591 gen_helper_usad8(tmp, tmp, tmp2);
8592 tcg_temp_free_i32(tmp2);
8593 if (rs != 15) {
8594 tmp2 = load_reg(s, rs);
8595 tcg_gen_add_i32(tmp, tmp, tmp2);
8596 tcg_temp_free_i32(tmp2);
8597 }
8598 break;
8599 }
8600 store_reg(s, rd, tmp);
8601 break;
8602 case 6: case 7: /* 64-bit multiply, Divide. */
8603 op = ((insn >> 4) & 0xf) | ((insn >> 16) & 0x70);
8604 tmp = load_reg(s, rn);
8605 tmp2 = load_reg(s, rm);
8606 if ((op & 0x50) == 0x10) {
8607 /* sdiv, udiv */
8608 if (!arm_feature(env, ARM_FEATURE_THUMB_DIV)) {
8609 goto illegal_op;
8610 }
8611 if (op & 0x20)
8612 gen_helper_udiv(tmp, tmp, tmp2);
8613 else
8614 gen_helper_sdiv(tmp, tmp, tmp2);
8615 tcg_temp_free_i32(tmp2);
8616 store_reg(s, rd, tmp);
8617 } else if ((op & 0xe) == 0xc) {
8618 /* Dual multiply accumulate long. */
8619 if (op & 1)
8620 gen_swap_half(tmp2);
8621 gen_smul_dual(tmp, tmp2);
8622 if (op & 0x10) {
8623 tcg_gen_sub_i32(tmp, tmp, tmp2);
8624 } else {
8625 tcg_gen_add_i32(tmp, tmp, tmp2);
8626 }
8627 tcg_temp_free_i32(tmp2);
8628 /* BUGFIX */
8629 tmp64 = tcg_temp_new_i64();
8630 tcg_gen_ext_i32_i64(tmp64, tmp);
8631 tcg_temp_free_i32(tmp);
8632 gen_addq(s, tmp64, rs, rd);
8633 gen_storeq_reg(s, rs, rd, tmp64);
8634 tcg_temp_free_i64(tmp64);
8635 } else {
8636 if (op & 0x20) {
8637 /* Unsigned 64-bit multiply */
8638 tmp64 = gen_mulu_i64_i32(tmp, tmp2);
8639 } else {
8640 if (op & 8) {
8641 /* smlalxy */
8642 gen_mulxy(tmp, tmp2, op & 2, op & 1);
8643 tcg_temp_free_i32(tmp2);
8644 tmp64 = tcg_temp_new_i64();
8645 tcg_gen_ext_i32_i64(tmp64, tmp);
8646 tcg_temp_free_i32(tmp);
8647 } else {
8648 /* Signed 64-bit multiply */
8649 tmp64 = gen_muls_i64_i32(tmp, tmp2);
8650 }
8651 }
8652 if (op & 4) {
8653 /* umaal */
8654 gen_addq_lo(s, tmp64, rs);
8655 gen_addq_lo(s, tmp64, rd);
8656 } else if (op & 0x40) {
8657 /* 64-bit accumulate. */
8658 gen_addq(s, tmp64, rs, rd);
8659 }
8660 gen_storeq_reg(s, rs, rd, tmp64);
8661 tcg_temp_free_i64(tmp64);
8662 }
8663 break;
8664 }
8665 break;
8666 case 6: case 7: case 14: case 15:
8667 /* Coprocessor. */
8668 if (((insn >> 24) & 3) == 3) {
8669 /* Translate into the equivalent ARM encoding. */
8670 insn = (insn & 0xe2ffffff) | ((insn & (1 << 28)) >> 4) | (1 << 28);
8671 if (disas_neon_data_insn(env, s, insn))
8672 goto illegal_op;
8673 } else {
8674 if (insn & (1 << 28))
8675 goto illegal_op;
8676 if (disas_coproc_insn (env, s, insn))
8677 goto illegal_op;
8678 }
8679 break;
8680 case 8: case 9: case 10: case 11:
8681 if (insn & (1 << 15)) {
8682 /* Branches, misc control. */
8683 if (insn & 0x5000) {
8684 /* Unconditional branch. */
8685 /* signextend(hw1[10:0]) -> offset[:12]. */
8686 offset = ((int32_t)insn << 5) >> 9 & ~(int32_t)0xfff;
8687 /* hw1[10:0] -> offset[11:1]. */
8688 offset |= (insn & 0x7ff) << 1;
8689 /* (~hw2[13, 11] ^ offset[24]) -> offset[23,22]
8690 offset[24:22] already have the same value because of the
8691 sign extension above. */
8692 offset ^= ((~insn) & (1 << 13)) << 10;
8693 offset ^= ((~insn) & (1 << 11)) << 11;
8694
8695 if (insn & (1 << 14)) {
8696 /* Branch and link. */
8697 tcg_gen_movi_i32(cpu_R[14], s->pc | 1);
8698 }
8699
8700 offset += s->pc;
8701 if (insn & (1 << 12)) {
8702 /* b/bl */
8703 gen_jmp(s, offset);
8704 } else {
8705 /* blx */
8706 offset &= ~(uint32_t)2;
8707 /* thumb2 bx, no need to check */
8708 gen_bx_im(s, offset);
8709 }
8710 } else if (((insn >> 23) & 7) == 7) {
8711 /* Misc control */
8712 if (insn & (1 << 13))
8713 goto illegal_op;
8714
8715 if (insn & (1 << 26)) {
8716 /* Secure monitor call (v6Z) */
8717 goto illegal_op; /* not implemented. */
8718 } else {
8719 op = (insn >> 20) & 7;
8720 switch (op) {
8721 case 0: /* msr cpsr. */
8722 if (IS_M(env)) {
8723 tmp = load_reg(s, rn);
8724 addr = tcg_const_i32(insn & 0xff);
8725 gen_helper_v7m_msr(cpu_env, addr, tmp);
8726 tcg_temp_free_i32(addr);
8727 tcg_temp_free_i32(tmp);
8728 gen_lookup_tb(s);
8729 break;
8730 }
8731 /* fall through */
8732 case 1: /* msr spsr. */
8733 if (IS_M(env))
8734 goto illegal_op;
8735 tmp = load_reg(s, rn);
8736 if (gen_set_psr(s,
8737 msr_mask(env, s, (insn >> 8) & 0xf, op == 1),
8738 op == 1, tmp))
8739 goto illegal_op;
8740 break;
8741 case 2: /* cps, nop-hint. */
8742 if (((insn >> 8) & 7) == 0) {
8743 gen_nop_hint(s, insn & 0xff);
8744 }
8745 /* Implemented as NOP in user mode. */
8746 if (IS_USER(s))
8747 break;
8748 offset = 0;
8749 imm = 0;
8750 if (insn & (1 << 10)) {
8751 if (insn & (1 << 7))
8752 offset |= CPSR_A;
8753 if (insn & (1 << 6))
8754 offset |= CPSR_I;
8755 if (insn & (1 << 5))
8756 offset |= CPSR_F;
8757 if (insn & (1 << 9))
8758 imm = CPSR_A | CPSR_I | CPSR_F;
8759 }
8760 if (insn & (1 << 8)) {
8761 offset |= 0x1f;
8762 imm |= (insn & 0x1f);
8763 }
8764 if (offset) {
8765 gen_set_psr_im(s, offset, 0, imm);
8766 }
8767 break;
8768 case 3: /* Special control operations. */
8769 ARCH(7);
8770 op = (insn >> 4) & 0xf;
8771 switch (op) {
8772 case 2: /* clrex */
8773 gen_clrex(s);
8774 break;
8775 case 4: /* dsb */
8776 case 5: /* dmb */
8777 case 6: /* isb */
8778 /* These execute as NOPs. */
8779 break;
8780 default:
8781 goto illegal_op;
8782 }
8783 break;
8784 case 4: /* bxj */
8785 /* Trivial implementation equivalent to bx. */
8786 tmp = load_reg(s, rn);
8787 gen_bx(s, tmp);
8788 break;
8789 case 5: /* Exception return. */
8790 if (IS_USER(s)) {
8791 goto illegal_op;
8792 }
8793 if (rn != 14 || rd != 15) {
8794 goto illegal_op;
8795 }
8796 tmp = load_reg(s, rn);
8797 tcg_gen_subi_i32(tmp, tmp, insn & 0xff);
8798 gen_exception_return(s, tmp);
8799 break;
8800 case 6: /* mrs cpsr. */
8801 tmp = tcg_temp_new_i32();
8802 if (IS_M(env)) {
8803 addr = tcg_const_i32(insn & 0xff);
8804 gen_helper_v7m_mrs(tmp, cpu_env, addr);
8805 tcg_temp_free_i32(addr);
8806 } else {
8807 gen_helper_cpsr_read(tmp);
8808 }
8809 store_reg(s, rd, tmp);
8810 break;
8811 case 7: /* mrs spsr. */
8812 /* Not accessible in user mode. */
8813 if (IS_USER(s) || IS_M(env))
8814 goto illegal_op;
8815 tmp = load_cpu_field(spsr);
8816 store_reg(s, rd, tmp);
8817 break;
8818 }
8819 }
8820 } else {
8821 /* Conditional branch. */
8822 op = (insn >> 22) & 0xf;
8823 /* Generate a conditional jump to next instruction. */
8824 s->condlabel = gen_new_label();
8825 gen_test_cc(op ^ 1, s->condlabel);
8826 s->condjmp = 1;
8827
8828 /* offset[11:1] = insn[10:0] */
8829 offset = (insn & 0x7ff) << 1;
8830 /* offset[17:12] = insn[21:16]. */
8831 offset |= (insn & 0x003f0000) >> 4;
8832 /* offset[31:20] = insn[26]. */
8833 offset |= ((int32_t)((insn << 5) & 0x80000000)) >> 11;
8834 /* offset[18] = insn[13]. */
8835 offset |= (insn & (1 << 13)) << 5;
8836 /* offset[19] = insn[11]. */
8837 offset |= (insn & (1 << 11)) << 8;
8838
8839 /* jump to the offset */
8840 gen_jmp(s, s->pc + offset);
8841 }
8842 } else {
8843 /* Data processing immediate. */
8844 if (insn & (1 << 25)) {
8845 if (insn & (1 << 24)) {
8846 if (insn & (1 << 20))
8847 goto illegal_op;
8848 /* Bitfield/Saturate. */
8849 op = (insn >> 21) & 7;
8850 imm = insn & 0x1f;
8851 shift = ((insn >> 6) & 3) | ((insn >> 10) & 0x1c);
8852 if (rn == 15) {
8853 tmp = tcg_temp_new_i32();
8854 tcg_gen_movi_i32(tmp, 0);
8855 } else {
8856 tmp = load_reg(s, rn);
8857 }
8858 switch (op) {
8859 case 2: /* Signed bitfield extract. */
8860 imm++;
8861 if (shift + imm > 32)
8862 goto illegal_op;
8863 if (imm < 32)
8864 gen_sbfx(tmp, shift, imm);
8865 break;
8866 case 6: /* Unsigned bitfield extract. */
8867 imm++;
8868 if (shift + imm > 32)
8869 goto illegal_op;
8870 if (imm < 32)
8871 gen_ubfx(tmp, shift, (1u << imm) - 1);
8872 break;
8873 case 3: /* Bitfield insert/clear. */
8874 if (imm < shift)
8875 goto illegal_op;
8876 imm = imm + 1 - shift;
8877 if (imm != 32) {
8878 tmp2 = load_reg(s, rd);
8879 gen_bfi(tmp, tmp2, tmp, shift, (1u << imm) - 1);
8880 tcg_temp_free_i32(tmp2);
8881 }
8882 break;
8883 case 7:
8884 goto illegal_op;
8885 default: /* Saturate. */
8886 if (shift) {
8887 if (op & 1)
8888 tcg_gen_sari_i32(tmp, tmp, shift);
8889 else
8890 tcg_gen_shli_i32(tmp, tmp, shift);
8891 }
8892 tmp2 = tcg_const_i32(imm);
8893 if (op & 4) {
8894 /* Unsigned. */
8895 if ((op & 1) && shift == 0)
8896 gen_helper_usat16(tmp, tmp, tmp2);
8897 else
8898 gen_helper_usat(tmp, tmp, tmp2);
8899 } else {
8900 /* Signed. */
8901 if ((op & 1) && shift == 0)
8902 gen_helper_ssat16(tmp, tmp, tmp2);
8903 else
8904 gen_helper_ssat(tmp, tmp, tmp2);
8905 }
8906 tcg_temp_free_i32(tmp2);
8907 break;
8908 }
8909 store_reg(s, rd, tmp);
8910 } else {
8911 imm = ((insn & 0x04000000) >> 15)
8912 | ((insn & 0x7000) >> 4) | (insn & 0xff);
8913 if (insn & (1 << 22)) {
8914 /* 16-bit immediate. */
8915 imm |= (insn >> 4) & 0xf000;
8916 if (insn & (1 << 23)) {
8917 /* movt */
8918 tmp = load_reg(s, rd);
8919 tcg_gen_ext16u_i32(tmp, tmp);
8920 tcg_gen_ori_i32(tmp, tmp, imm << 16);
8921 } else {
8922 /* movw */
8923 tmp = tcg_temp_new_i32();
8924 tcg_gen_movi_i32(tmp, imm);
8925 }
8926 } else {
8927 /* Add/sub 12-bit immediate. */
8928 if (rn == 15) {
8929 offset = s->pc & ~(uint32_t)3;
8930 if (insn & (1 << 23))
8931 offset -= imm;
8932 else
8933 offset += imm;
8934 tmp = tcg_temp_new_i32();
8935 tcg_gen_movi_i32(tmp, offset);
8936 } else {
8937 tmp = load_reg(s, rn);
8938 if (insn & (1 << 23))
8939 tcg_gen_subi_i32(tmp, tmp, imm);
8940 else
8941 tcg_gen_addi_i32(tmp, tmp, imm);
8942 }
8943 }
8944 store_reg(s, rd, tmp);
8945 }
8946 } else {
8947 int shifter_out = 0;
8948 /* modified 12-bit immediate. */
8949 shift = ((insn & 0x04000000) >> 23) | ((insn & 0x7000) >> 12);
8950 imm = (insn & 0xff);
8951 switch (shift) {
8952 case 0: /* XY */
8953 /* Nothing to do. */
8954 break;
8955 case 1: /* 00XY00XY */
8956 imm |= imm << 16;
8957 break;
8958 case 2: /* XY00XY00 */
8959 imm |= imm << 16;
8960 imm <<= 8;
8961 break;
8962 case 3: /* XYXYXYXY */
8963 imm |= imm << 16;
8964 imm |= imm << 8;
8965 break;
8966 default: /* Rotated constant. */
8967 shift = (shift << 1) | (imm >> 7);
8968 imm |= 0x80;
8969 imm = imm << (32 - shift);
8970 shifter_out = 1;
8971 break;
8972 }
8973 tmp2 = tcg_temp_new_i32();
8974 tcg_gen_movi_i32(tmp2, imm);
8975 rn = (insn >> 16) & 0xf;
8976 if (rn == 15) {
8977 tmp = tcg_temp_new_i32();
8978 tcg_gen_movi_i32(tmp, 0);
8979 } else {
8980 tmp = load_reg(s, rn);
8981 }
8982 op = (insn >> 21) & 0xf;
8983 if (gen_thumb2_data_op(s, op, (insn & (1 << 20)) != 0,
8984 shifter_out, tmp, tmp2))
8985 goto illegal_op;
8986 tcg_temp_free_i32(tmp2);
8987 rd = (insn >> 8) & 0xf;
8988 if (rd != 15) {
8989 store_reg(s, rd, tmp);
8990 } else {
8991 tcg_temp_free_i32(tmp);
8992 }
8993 }
8994 }
8995 break;
8996 case 12: /* Load/store single data item. */
8997 {
8998 int postinc = 0;
8999 int writeback = 0;
9000 int user;
9001 if ((insn & 0x01100000) == 0x01000000) {
9002 if (disas_neon_ls_insn(env, s, insn))
9003 goto illegal_op;
9004 break;
9005 }
9006 op = ((insn >> 21) & 3) | ((insn >> 22) & 4);
9007 if (rs == 15) {
9008 if (!(insn & (1 << 20))) {
9009 goto illegal_op;
9010 }
9011 if (op != 2) {
9012 /* Byte or halfword load space with dest == r15 : memory hints.
9013 * Catch them early so we don't emit pointless addressing code.
9014 * This space is a mix of:
9015 * PLD/PLDW/PLI, which we implement as NOPs (note that unlike
9016 * the ARM encodings, PLDW space doesn't UNDEF for non-v7MP
9017 * cores)
9018 * unallocated hints, which must be treated as NOPs
9019 * UNPREDICTABLE space, which we NOP or UNDEF depending on
9020 * which is easiest for the decoding logic
9021 * Some space which must UNDEF
9022 */
9023 int op1 = (insn >> 23) & 3;
9024 int op2 = (insn >> 6) & 0x3f;
9025 if (op & 2) {
9026 goto illegal_op;
9027 }
9028 if (rn == 15) {
9029 /* UNPREDICTABLE, unallocated hint or
9030 * PLD/PLDW/PLI (literal)
9031 */
9032 return 0;
9033 }
9034 if (op1 & 1) {
9035 return 0; /* PLD/PLDW/PLI or unallocated hint */
9036 }
9037 if ((op2 == 0) || ((op2 & 0x3c) == 0x30)) {
9038 return 0; /* PLD/PLDW/PLI or unallocated hint */
9039 }
9040 /* UNDEF space, or an UNPREDICTABLE */
9041 return 1;
9042 }
9043 }
9044 user = IS_USER(s);
9045 if (rn == 15) {
9046 addr = tcg_temp_new_i32();
9047 /* PC relative. */
9048 /* s->pc has already been incremented by 4. */
9049 imm = s->pc & 0xfffffffc;
9050 if (insn & (1 << 23))
9051 imm += insn & 0xfff;
9052 else
9053 imm -= insn & 0xfff;
9054 tcg_gen_movi_i32(addr, imm);
9055 } else {
9056 addr = load_reg(s, rn);
9057 if (insn & (1 << 23)) {
9058 /* Positive offset. */
9059 imm = insn & 0xfff;
9060 tcg_gen_addi_i32(addr, addr, imm);
9061 } else {
9062 imm = insn & 0xff;
9063 switch ((insn >> 8) & 0xf) {
9064 case 0x0: /* Shifted Register. */
9065 shift = (insn >> 4) & 0xf;
9066 if (shift > 3) {
9067 tcg_temp_free_i32(addr);
9068 goto illegal_op;
9069 }
9070 tmp = load_reg(s, rm);
9071 if (shift)
9072 tcg_gen_shli_i32(tmp, tmp, shift);
9073 tcg_gen_add_i32(addr, addr, tmp);
9074 tcg_temp_free_i32(tmp);
9075 break;
9076 case 0xc: /* Negative offset. */
9077 tcg_gen_addi_i32(addr, addr, -imm);
9078 break;
9079 case 0xe: /* User privilege. */
9080 tcg_gen_addi_i32(addr, addr, imm);
9081 user = 1;
9082 break;
9083 case 0x9: /* Post-decrement. */
9084 imm = -imm;
9085 /* Fall through. */
9086 case 0xb: /* Post-increment. */
9087 postinc = 1;
9088 writeback = 1;
9089 break;
9090 case 0xd: /* Pre-decrement. */
9091 imm = -imm;
9092 /* Fall through. */
9093 case 0xf: /* Pre-increment. */
9094 tcg_gen_addi_i32(addr, addr, imm);
9095 writeback = 1;
9096 break;
9097 default:
9098 tcg_temp_free_i32(addr);
9099 goto illegal_op;
9100 }
9101 }
9102 }
9103 if (insn & (1 << 20)) {
9104 /* Load. */
9105 switch (op) {
9106 case 0: tmp = gen_ld8u(addr, user); break;
9107 case 4: tmp = gen_ld8s(addr, user); break;
9108 case 1: tmp = gen_ld16u(addr, user); break;
9109 case 5: tmp = gen_ld16s(addr, user); break;
9110 case 2: tmp = gen_ld32(addr, user); break;
9111 default:
9112 tcg_temp_free_i32(addr);
9113 goto illegal_op;
9114 }
9115 if (rs == 15) {
9116 gen_bx(s, tmp);
9117 } else {
9118 store_reg(s, rs, tmp);
9119 }
9120 } else {
9121 /* Store. */
9122 tmp = load_reg(s, rs);
9123 switch (op) {
9124 case 0: gen_st8(tmp, addr, user); break;
9125 case 1: gen_st16(tmp, addr, user); break;
9126 case 2: gen_st32(tmp, addr, user); break;
9127 default:
9128 tcg_temp_free_i32(addr);
9129 goto illegal_op;
9130 }
9131 }
9132 if (postinc)
9133 tcg_gen_addi_i32(addr, addr, imm);
9134 if (writeback) {
9135 store_reg(s, rn, addr);
9136 } else {
9137 tcg_temp_free_i32(addr);
9138 }
9139 }
9140 break;
9141 default:
9142 goto illegal_op;
9143 }
9144 return 0;
9145 illegal_op:
9146 return 1;
9147 }
9148
9149 static void disas_thumb_insn(CPUARMState *env, DisasContext *s)
9150 {
9151 uint32_t val, insn, op, rm, rn, rd, shift, cond;
9152 int32_t offset;
9153 int i;
9154 TCGv tmp;
9155 TCGv tmp2;
9156 TCGv addr;
9157
9158 if (s->condexec_mask) {
9159 cond = s->condexec_cond;
9160 if (cond != 0x0e) { /* Skip conditional when condition is AL. */
9161 s->condlabel = gen_new_label();
9162 gen_test_cc(cond ^ 1, s->condlabel);
9163 s->condjmp = 1;
9164 }
9165 }
9166
9167 insn = arm_lduw_code(s->pc, s->bswap_code);
9168 s->pc += 2;
9169
9170 switch (insn >> 12) {
9171 case 0: case 1:
9172
9173 rd = insn & 7;
9174 op = (insn >> 11) & 3;
9175 if (op == 3) {
9176 /* add/subtract */
9177 rn = (insn >> 3) & 7;
9178 tmp = load_reg(s, rn);
9179 if (insn & (1 << 10)) {
9180 /* immediate */
9181 tmp2 = tcg_temp_new_i32();
9182 tcg_gen_movi_i32(tmp2, (insn >> 6) & 7);
9183 } else {
9184 /* reg */
9185 rm = (insn >> 6) & 7;
9186 tmp2 = load_reg(s, rm);
9187 }
9188 if (insn & (1 << 9)) {
9189 if (s->condexec_mask)
9190 tcg_gen_sub_i32(tmp, tmp, tmp2);
9191 else
9192 gen_helper_sub_cc(tmp, tmp, tmp2);
9193 } else {
9194 if (s->condexec_mask)
9195 tcg_gen_add_i32(tmp, tmp, tmp2);
9196 else
9197 gen_helper_add_cc(tmp, tmp, tmp2);
9198 }
9199 tcg_temp_free_i32(tmp2);
9200 store_reg(s, rd, tmp);
9201 } else {
9202 /* shift immediate */
9203 rm = (insn >> 3) & 7;
9204 shift = (insn >> 6) & 0x1f;
9205 tmp = load_reg(s, rm);
9206 gen_arm_shift_im(tmp, op, shift, s->condexec_mask == 0);
9207 if (!s->condexec_mask)
9208 gen_logic_CC(tmp);
9209 store_reg(s, rd, tmp);
9210 }
9211 break;
9212 case 2: case 3:
9213 /* arithmetic large immediate */
9214 op = (insn >> 11) & 3;
9215 rd = (insn >> 8) & 0x7;
9216 if (op == 0) { /* mov */
9217 tmp = tcg_temp_new_i32();
9218 tcg_gen_movi_i32(tmp, insn & 0xff);
9219 if (!s->condexec_mask)
9220 gen_logic_CC(tmp);
9221 store_reg(s, rd, tmp);
9222 } else {
9223 tmp = load_reg(s, rd);
9224 tmp2 = tcg_temp_new_i32();
9225 tcg_gen_movi_i32(tmp2, insn & 0xff);
9226 switch (op) {
9227 case 1: /* cmp */
9228 gen_helper_sub_cc(tmp, tmp, tmp2);
9229 tcg_temp_free_i32(tmp);
9230 tcg_temp_free_i32(tmp2);
9231 break;
9232 case 2: /* add */
9233 if (s->condexec_mask)
9234 tcg_gen_add_i32(tmp, tmp, tmp2);
9235 else
9236 gen_helper_add_cc(tmp, tmp, tmp2);
9237 tcg_temp_free_i32(tmp2);
9238 store_reg(s, rd, tmp);
9239 break;
9240 case 3: /* sub */
9241 if (s->condexec_mask)
9242 tcg_gen_sub_i32(tmp, tmp, tmp2);
9243 else
9244 gen_helper_sub_cc(tmp, tmp, tmp2);
9245 tcg_temp_free_i32(tmp2);
9246 store_reg(s, rd, tmp);
9247 break;
9248 }
9249 }
9250 break;
9251 case 4:
9252 if (insn & (1 << 11)) {
9253 rd = (insn >> 8) & 7;
9254 /* load pc-relative. Bit 1 of PC is ignored. */
9255 val = s->pc + 2 + ((insn & 0xff) * 4);
9256 val &= ~(uint32_t)2;
9257 addr = tcg_temp_new_i32();
9258 tcg_gen_movi_i32(addr, val);
9259 tmp = gen_ld32(addr, IS_USER(s));
9260 tcg_temp_free_i32(addr);
9261 store_reg(s, rd, tmp);
9262 break;
9263 }
9264 if (insn & (1 << 10)) {
9265 /* data processing extended or blx */
9266 rd = (insn & 7) | ((insn >> 4) & 8);
9267 rm = (insn >> 3) & 0xf;
9268 op = (insn >> 8) & 3;
9269 switch (op) {
9270 case 0: /* add */
9271 tmp = load_reg(s, rd);
9272 tmp2 = load_reg(s, rm);
9273 tcg_gen_add_i32(tmp, tmp, tmp2);
9274 tcg_temp_free_i32(tmp2);
9275 store_reg(s, rd, tmp);
9276 break;
9277 case 1: /* cmp */
9278 tmp = load_reg(s, rd);
9279 tmp2 = load_reg(s, rm);
9280 gen_helper_sub_cc(tmp, tmp, tmp2);
9281 tcg_temp_free_i32(tmp2);
9282 tcg_temp_free_i32(tmp);
9283 break;
9284 case 2: /* mov/cpy */
9285 tmp = load_reg(s, rm);
9286 store_reg(s, rd, tmp);
9287 break;
9288 case 3:/* branch [and link] exchange thumb register */
9289 tmp = load_reg(s, rm);
9290 if (insn & (1 << 7)) {
9291 ARCH(5);
9292 val = (uint32_t)s->pc | 1;
9293 tmp2 = tcg_temp_new_i32();
9294 tcg_gen_movi_i32(tmp2, val);
9295 store_reg(s, 14, tmp2);
9296 }
9297 /* already thumb, no need to check */
9298 gen_bx(s, tmp);
9299 break;
9300 }
9301 break;
9302 }
9303
9304 /* data processing register */
9305 rd = insn & 7;
9306 rm = (insn >> 3) & 7;
9307 op = (insn >> 6) & 0xf;
9308 if (op == 2 || op == 3 || op == 4 || op == 7) {
9309 /* the shift/rotate ops want the operands backwards */
9310 val = rm;
9311 rm = rd;
9312 rd = val;
9313 val = 1;
9314 } else {
9315 val = 0;
9316 }
9317
9318 if (op == 9) { /* neg */
9319 tmp = tcg_temp_new_i32();
9320 tcg_gen_movi_i32(tmp, 0);
9321 } else if (op != 0xf) { /* mvn doesn't read its first operand */
9322 tmp = load_reg(s, rd);
9323 } else {
9324 TCGV_UNUSED(tmp);
9325 }
9326
9327 tmp2 = load_reg(s, rm);
9328 switch (op) {
9329 case 0x0: /* and */
9330 tcg_gen_and_i32(tmp, tmp, tmp2);
9331 if (!s->condexec_mask)
9332 gen_logic_CC(tmp);
9333 break;
9334 case 0x1: /* eor */
9335 tcg_gen_xor_i32(tmp, tmp, tmp2);
9336 if (!s->condexec_mask)
9337 gen_logic_CC(tmp);
9338 break;
9339 case 0x2: /* lsl */
9340 if (s->condexec_mask) {
9341 gen_helper_shl(tmp2, tmp2, tmp);
9342 } else {
9343 gen_helper_shl_cc(tmp2, tmp2, tmp);
9344 gen_logic_CC(tmp2);
9345 }
9346 break;
9347 case 0x3: /* lsr */
9348 if (s->condexec_mask) {
9349 gen_helper_shr(tmp2, tmp2, tmp);
9350 } else {
9351 gen_helper_shr_cc(tmp2, tmp2, tmp);
9352 gen_logic_CC(tmp2);
9353 }
9354 break;
9355 case 0x4: /* asr */
9356 if (s->condexec_mask) {
9357 gen_helper_sar(tmp2, tmp2, tmp);
9358 } else {
9359 gen_helper_sar_cc(tmp2, tmp2, tmp);
9360 gen_logic_CC(tmp2);
9361 }
9362 break;
9363 case 0x5: /* adc */
9364 if (s->condexec_mask)
9365 gen_adc(tmp, tmp2);
9366 else
9367 gen_helper_adc_cc(tmp, tmp, tmp2);
9368 break;
9369 case 0x6: /* sbc */
9370 if (s->condexec_mask)
9371 gen_sub_carry(tmp, tmp, tmp2);
9372 else
9373 gen_helper_sbc_cc(tmp, tmp, tmp2);
9374 break;
9375 case 0x7: /* ror */
9376 if (s->condexec_mask) {
9377 tcg_gen_andi_i32(tmp, tmp, 0x1f);
9378 tcg_gen_rotr_i32(tmp2, tmp2, tmp);
9379 } else {
9380 gen_helper_ror_cc(tmp2, tmp2, tmp);
9381 gen_logic_CC(tmp2);
9382 }
9383 break;
9384 case 0x8: /* tst */
9385 tcg_gen_and_i32(tmp, tmp, tmp2);
9386 gen_logic_CC(tmp);
9387 rd = 16;
9388 break;
9389 case 0x9: /* neg */
9390 if (s->condexec_mask)
9391 tcg_gen_neg_i32(tmp, tmp2);
9392 else
9393 gen_helper_sub_cc(tmp, tmp, tmp2);
9394 break;
9395 case 0xa: /* cmp */
9396 gen_helper_sub_cc(tmp, tmp, tmp2);
9397 rd = 16;
9398 break;
9399 case 0xb: /* cmn */
9400 gen_helper_add_cc(tmp, tmp, tmp2);
9401 rd = 16;
9402 break;
9403 case 0xc: /* orr */
9404 tcg_gen_or_i32(tmp, tmp, tmp2);
9405 if (!s->condexec_mask)
9406 gen_logic_CC(tmp);
9407 break;
9408 case 0xd: /* mul */
9409 tcg_gen_mul_i32(tmp, tmp, tmp2);
9410 if (!s->condexec_mask)
9411 gen_logic_CC(tmp);
9412 break;
9413 case 0xe: /* bic */
9414 tcg_gen_andc_i32(tmp, tmp, tmp2);
9415 if (!s->condexec_mask)
9416 gen_logic_CC(tmp);
9417 break;
9418 case 0xf: /* mvn */
9419 tcg_gen_not_i32(tmp2, tmp2);
9420 if (!s->condexec_mask)
9421 gen_logic_CC(tmp2);
9422 val = 1;
9423 rm = rd;
9424 break;
9425 }
9426 if (rd != 16) {
9427 if (val) {
9428 store_reg(s, rm, tmp2);
9429 if (op != 0xf)
9430 tcg_temp_free_i32(tmp);
9431 } else {
9432 store_reg(s, rd, tmp);
9433 tcg_temp_free_i32(tmp2);
9434 }
9435 } else {
9436 tcg_temp_free_i32(tmp);
9437 tcg_temp_free_i32(tmp2);
9438 }
9439 break;
9440
9441 case 5:
9442 /* load/store register offset. */
9443 rd = insn & 7;
9444 rn = (insn >> 3) & 7;
9445 rm = (insn >> 6) & 7;
9446 op = (insn >> 9) & 7;
9447 addr = load_reg(s, rn);
9448 tmp = load_reg(s, rm);
9449 tcg_gen_add_i32(addr, addr, tmp);
9450 tcg_temp_free_i32(tmp);
9451
9452 if (op < 3) /* store */
9453 tmp = load_reg(s, rd);
9454
9455 switch (op) {
9456 case 0: /* str */
9457 gen_st32(tmp, addr, IS_USER(s));
9458 break;
9459 case 1: /* strh */
9460 gen_st16(tmp, addr, IS_USER(s));
9461 break;
9462 case 2: /* strb */
9463 gen_st8(tmp, addr, IS_USER(s));
9464 break;
9465 case 3: /* ldrsb */
9466 tmp = gen_ld8s(addr, IS_USER(s));
9467 break;
9468 case 4: /* ldr */
9469 tmp = gen_ld32(addr, IS_USER(s));
9470 break;
9471 case 5: /* ldrh */
9472 tmp = gen_ld16u(addr, IS_USER(s));
9473 break;
9474 case 6: /* ldrb */
9475 tmp = gen_ld8u(addr, IS_USER(s));
9476 break;
9477 case 7: /* ldrsh */
9478 tmp = gen_ld16s(addr, IS_USER(s));
9479 break;
9480 }
9481 if (op >= 3) /* load */
9482 store_reg(s, rd, tmp);
9483 tcg_temp_free_i32(addr);
9484 break;
9485
9486 case 6:
9487 /* load/store word immediate offset */
9488 rd = insn & 7;
9489 rn = (insn >> 3) & 7;
9490 addr = load_reg(s, rn);
9491 val = (insn >> 4) & 0x7c;
9492 tcg_gen_addi_i32(addr, addr, val);
9493
9494 if (insn & (1 << 11)) {
9495 /* load */
9496 tmp = gen_ld32(addr, IS_USER(s));
9497 store_reg(s, rd, tmp);
9498 } else {
9499 /* store */
9500 tmp = load_reg(s, rd);
9501 gen_st32(tmp, addr, IS_USER(s));
9502 }
9503 tcg_temp_free_i32(addr);
9504 break;
9505
9506 case 7:
9507 /* load/store byte immediate offset */
9508 rd = insn & 7;
9509 rn = (insn >> 3) & 7;
9510 addr = load_reg(s, rn);
9511 val = (insn >> 6) & 0x1f;
9512 tcg_gen_addi_i32(addr, addr, val);
9513
9514 if (insn & (1 << 11)) {
9515 /* load */
9516 tmp = gen_ld8u(addr, IS_USER(s));
9517 store_reg(s, rd, tmp);
9518 } else {
9519 /* store */
9520 tmp = load_reg(s, rd);
9521 gen_st8(tmp, addr, IS_USER(s));
9522 }
9523 tcg_temp_free_i32(addr);
9524 break;
9525
9526 case 8:
9527 /* load/store halfword immediate offset */
9528 rd = insn & 7;
9529 rn = (insn >> 3) & 7;
9530 addr = load_reg(s, rn);
9531 val = (insn >> 5) & 0x3e;
9532 tcg_gen_addi_i32(addr, addr, val);
9533
9534 if (insn & (1 << 11)) {
9535 /* load */
9536 tmp = gen_ld16u(addr, IS_USER(s));
9537 store_reg(s, rd, tmp);
9538 } else {
9539 /* store */
9540 tmp = load_reg(s, rd);
9541 gen_st16(tmp, addr, IS_USER(s));
9542 }
9543 tcg_temp_free_i32(addr);
9544 break;
9545
9546 case 9:
9547 /* load/store from stack */
9548 rd = (insn >> 8) & 7;
9549 addr = load_reg(s, 13);
9550 val = (insn & 0xff) * 4;
9551 tcg_gen_addi_i32(addr, addr, val);
9552
9553 if (insn & (1 << 11)) {
9554 /* load */
9555 tmp = gen_ld32(addr, IS_USER(s));
9556 store_reg(s, rd, tmp);
9557 } else {
9558 /* store */
9559 tmp = load_reg(s, rd);
9560 gen_st32(tmp, addr, IS_USER(s));
9561 }
9562 tcg_temp_free_i32(addr);
9563 break;
9564
9565 case 10:
9566 /* add to high reg */
9567 rd = (insn >> 8) & 7;
9568 if (insn & (1 << 11)) {
9569 /* SP */
9570 tmp = load_reg(s, 13);
9571 } else {
9572 /* PC. bit 1 is ignored. */
9573 tmp = tcg_temp_new_i32();
9574 tcg_gen_movi_i32(tmp, (s->pc + 2) & ~(uint32_t)2);
9575 }
9576 val = (insn & 0xff) * 4;
9577 tcg_gen_addi_i32(tmp, tmp, val);
9578 store_reg(s, rd, tmp);
9579 break;
9580
9581 case 11:
9582 /* misc */
9583 op = (insn >> 8) & 0xf;
9584 switch (op) {
9585 case 0:
9586 /* adjust stack pointer */
9587 tmp = load_reg(s, 13);
9588 val = (insn & 0x7f) * 4;
9589 if (insn & (1 << 7))
9590 val = -(int32_t)val;
9591 tcg_gen_addi_i32(tmp, tmp, val);
9592 store_reg(s, 13, tmp);
9593 break;
9594
9595 case 2: /* sign/zero extend. */
9596 ARCH(6);
9597 rd = insn & 7;
9598 rm = (insn >> 3) & 7;
9599 tmp = load_reg(s, rm);
9600 switch ((insn >> 6) & 3) {
9601 case 0: gen_sxth(tmp); break;
9602 case 1: gen_sxtb(tmp); break;
9603 case 2: gen_uxth(tmp); break;
9604 case 3: gen_uxtb(tmp); break;
9605 }
9606 store_reg(s, rd, tmp);
9607 break;
9608 case 4: case 5: case 0xc: case 0xd:
9609 /* push/pop */
9610 addr = load_reg(s, 13);
9611 if (insn & (1 << 8))
9612 offset = 4;
9613 else
9614 offset = 0;
9615 for (i = 0; i < 8; i++) {
9616 if (insn & (1 << i))
9617 offset += 4;
9618 }
9619 if ((insn & (1 << 11)) == 0) {
9620 tcg_gen_addi_i32(addr, addr, -offset);
9621 }
9622 for (i = 0; i < 8; i++) {
9623 if (insn & (1 << i)) {
9624 if (insn & (1 << 11)) {
9625 /* pop */
9626 tmp = gen_ld32(addr, IS_USER(s));
9627 store_reg(s, i, tmp);
9628 } else {
9629 /* push */
9630 tmp = load_reg(s, i);
9631 gen_st32(tmp, addr, IS_USER(s));
9632 }
9633 /* advance to the next address. */
9634 tcg_gen_addi_i32(addr, addr, 4);
9635 }
9636 }
9637 TCGV_UNUSED(tmp);
9638 if (insn & (1 << 8)) {
9639 if (insn & (1 << 11)) {
9640 /* pop pc */
9641 tmp = gen_ld32(addr, IS_USER(s));
9642 /* don't set the pc until the rest of the instruction
9643 has completed */
9644 } else {
9645 /* push lr */
9646 tmp = load_reg(s, 14);
9647 gen_st32(tmp, addr, IS_USER(s));
9648 }
9649 tcg_gen_addi_i32(addr, addr, 4);
9650 }
9651 if ((insn & (1 << 11)) == 0) {
9652 tcg_gen_addi_i32(addr, addr, -offset);
9653 }
9654 /* write back the new stack pointer */
9655 store_reg(s, 13, addr);
9656 /* set the new PC value */
9657 if ((insn & 0x0900) == 0x0900) {
9658 store_reg_from_load(env, s, 15, tmp);
9659 }
9660 break;
9661
9662 case 1: case 3: case 9: case 11: /* czb */
9663 rm = insn & 7;
9664 tmp = load_reg(s, rm);
9665 s->condlabel = gen_new_label();
9666 s->condjmp = 1;
9667 if (insn & (1 << 11))
9668 tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, s->condlabel);
9669 else
9670 tcg_gen_brcondi_i32(TCG_COND_NE, tmp, 0, s->condlabel);
9671 tcg_temp_free_i32(tmp);
9672 offset = ((insn & 0xf8) >> 2) | (insn & 0x200) >> 3;
9673 val = (uint32_t)s->pc + 2;
9674 val += offset;
9675 gen_jmp(s, val);
9676 break;
9677
9678 case 15: /* IT, nop-hint. */
9679 if ((insn & 0xf) == 0) {
9680 gen_nop_hint(s, (insn >> 4) & 0xf);
9681 break;
9682 }
9683 /* If Then. */
9684 s->condexec_cond = (insn >> 4) & 0xe;
9685 s->condexec_mask = insn & 0x1f;
9686 /* No actual code generated for this insn, just setup state. */
9687 break;
9688
9689 case 0xe: /* bkpt */
9690 ARCH(5);
9691 gen_exception_insn(s, 2, EXCP_BKPT);
9692 break;
9693
9694 case 0xa: /* rev */
9695 ARCH(6);
9696 rn = (insn >> 3) & 0x7;
9697 rd = insn & 0x7;
9698 tmp = load_reg(s, rn);
9699 switch ((insn >> 6) & 3) {
9700 case 0: tcg_gen_bswap32_i32(tmp, tmp); break;
9701 case 1: gen_rev16(tmp); break;
9702 case 3: gen_revsh(tmp); break;
9703 default: goto illegal_op;
9704 }
9705 store_reg(s, rd, tmp);
9706 break;
9707
9708 case 6:
9709 switch ((insn >> 5) & 7) {
9710 case 2:
9711 /* setend */
9712 ARCH(6);
9713 if (insn & (1 << 3)) {
9714 /* BE8 mode not implemented. */
9715 goto illegal_op;
9716 }
9717 break;
9718 case 3:
9719 /* cps */
9720 ARCH(6);
9721 if (IS_USER(s)) {
9722 break;
9723 }
9724 if (IS_M(env)) {
9725 tmp = tcg_const_i32((insn & (1 << 4)) != 0);
9726 /* FAULTMASK */
9727 if (insn & 1) {
9728 addr = tcg_const_i32(19);
9729 gen_helper_v7m_msr(cpu_env, addr, tmp);
9730 tcg_temp_free_i32(addr);
9731 }
9732 /* PRIMASK */
9733 if (insn & 2) {
9734 addr = tcg_const_i32(16);
9735 gen_helper_v7m_msr(cpu_env, addr, tmp);
9736 tcg_temp_free_i32(addr);
9737 }
9738 tcg_temp_free_i32(tmp);
9739 gen_lookup_tb(s);
9740 } else {
9741 if (insn & (1 << 4)) {
9742 shift = CPSR_A | CPSR_I | CPSR_F;
9743 } else {
9744 shift = 0;
9745 }
9746 gen_set_psr_im(s, ((insn & 7) << 6), 0, shift);
9747 }
9748 break;
9749 default:
9750 goto undef;
9751 }
9752 break;
9753
9754 default:
9755 goto undef;
9756 }
9757 break;
9758
9759 case 12:
9760 {
9761 /* load/store multiple */
9762 TCGv loaded_var;
9763 TCGV_UNUSED(loaded_var);
9764 rn = (insn >> 8) & 0x7;
9765 addr = load_reg(s, rn);
9766 for (i = 0; i < 8; i++) {
9767 if (insn & (1 << i)) {
9768 if (insn & (1 << 11)) {
9769 /* load */
9770 tmp = gen_ld32(addr, IS_USER(s));
9771 if (i == rn) {
9772 loaded_var = tmp;
9773 } else {
9774 store_reg(s, i, tmp);
9775 }
9776 } else {
9777 /* store */
9778 tmp = load_reg(s, i);
9779 gen_st32(tmp, addr, IS_USER(s));
9780 }
9781 /* advance to the next address */
9782 tcg_gen_addi_i32(addr, addr, 4);
9783 }
9784 }
9785 if ((insn & (1 << rn)) == 0) {
9786 /* base reg not in list: base register writeback */
9787 store_reg(s, rn, addr);
9788 } else {
9789 /* base reg in list: if load, complete it now */
9790 if (insn & (1 << 11)) {
9791 store_reg(s, rn, loaded_var);
9792 }
9793 tcg_temp_free_i32(addr);
9794 }
9795 break;
9796 }
9797 case 13:
9798 /* conditional branch or swi */
9799 cond = (insn >> 8) & 0xf;
9800 if (cond == 0xe)
9801 goto undef;
9802
9803 if (cond == 0xf) {
9804 /* swi */
9805 gen_set_pc_im(s->pc);
9806 s->is_jmp = DISAS_SWI;
9807 break;
9808 }
9809 /* generate a conditional jump to next instruction */
9810 s->condlabel = gen_new_label();
9811 gen_test_cc(cond ^ 1, s->condlabel);
9812 s->condjmp = 1;
9813
9814 /* jump to the offset */
9815 val = (uint32_t)s->pc + 2;
9816 offset = ((int32_t)insn << 24) >> 24;
9817 val += offset << 1;
9818 gen_jmp(s, val);
9819 break;
9820
9821 case 14:
9822 if (insn & (1 << 11)) {
9823 if (disas_thumb2_insn(env, s, insn))
9824 goto undef32;
9825 break;
9826 }
9827 /* unconditional branch */
9828 val = (uint32_t)s->pc;
9829 offset = ((int32_t)insn << 21) >> 21;
9830 val += (offset << 1) + 2;
9831 gen_jmp(s, val);
9832 break;
9833
9834 case 15:
9835 if (disas_thumb2_insn(env, s, insn))
9836 goto undef32;
9837 break;
9838 }
9839 return;
9840 undef32:
9841 gen_exception_insn(s, 4, EXCP_UDEF);
9842 return;
9843 illegal_op:
9844 undef:
9845 gen_exception_insn(s, 2, EXCP_UDEF);
9846 }
9847
9848 /* generate intermediate code in gen_opc_buf and gen_opparam_buf for
9849 basic block 'tb'. If search_pc is TRUE, also generate PC
9850 information for each intermediate instruction. */
9851 static inline void gen_intermediate_code_internal(CPUARMState *env,
9852 TranslationBlock *tb,
9853 int search_pc)
9854 {
9855 DisasContext dc1, *dc = &dc1;
9856 CPUBreakpoint *bp;
9857 uint16_t *gen_opc_end;
9858 int j, lj;
9859 target_ulong pc_start;
9860 uint32_t next_page_start;
9861 int num_insns;
9862 int max_insns;
9863
9864 /* generate intermediate code */
9865 pc_start = tb->pc;
9866
9867 dc->tb = tb;
9868
9869 gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
9870
9871 dc->is_jmp = DISAS_NEXT;
9872 dc->pc = pc_start;
9873 dc->singlestep_enabled = env->singlestep_enabled;
9874 dc->condjmp = 0;
9875 dc->thumb = ARM_TBFLAG_THUMB(tb->flags);
9876 dc->bswap_code = ARM_TBFLAG_BSWAP_CODE(tb->flags);
9877 dc->condexec_mask = (ARM_TBFLAG_CONDEXEC(tb->flags) & 0xf) << 1;
9878 dc->condexec_cond = ARM_TBFLAG_CONDEXEC(tb->flags) >> 4;
9879 #if !defined(CONFIG_USER_ONLY)
9880 dc->user = (ARM_TBFLAG_PRIV(tb->flags) == 0);
9881 #endif
9882 dc->vfp_enabled = ARM_TBFLAG_VFPEN(tb->flags);
9883 dc->vec_len = ARM_TBFLAG_VECLEN(tb->flags);
9884 dc->vec_stride = ARM_TBFLAG_VECSTRIDE(tb->flags);
9885 cpu_F0s = tcg_temp_new_i32();
9886 cpu_F1s = tcg_temp_new_i32();
9887 cpu_F0d = tcg_temp_new_i64();
9888 cpu_F1d = tcg_temp_new_i64();
9889 cpu_V0 = cpu_F0d;
9890 cpu_V1 = cpu_F1d;
9891 /* FIXME: cpu_M0 can probably be the same as cpu_V0. */
9892 cpu_M0 = tcg_temp_new_i64();
9893 next_page_start = (pc_start & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE;
9894 lj = -1;
9895 num_insns = 0;
9896 max_insns = tb->cflags & CF_COUNT_MASK;
9897 if (max_insns == 0)
9898 max_insns = CF_COUNT_MASK;
9899
9900 gen_icount_start();
9901
9902 tcg_clear_temp_count();
9903
9904 /* A note on handling of the condexec (IT) bits:
9905 *
9906 * We want to avoid the overhead of having to write the updated condexec
9907 * bits back to the CPUARMState for every instruction in an IT block. So:
9908 * (1) if the condexec bits are not already zero then we write
9909 * zero back into the CPUARMState now. This avoids complications trying
9910 * to do it at the end of the block. (For example if we don't do this
9911 * it's hard to identify whether we can safely skip writing condexec
9912 * at the end of the TB, which we definitely want to do for the case
9913 * where a TB doesn't do anything with the IT state at all.)
9914 * (2) if we are going to leave the TB then we call gen_set_condexec()
9915 * which will write the correct value into CPUARMState if zero is wrong.
9916 * This is done both for leaving the TB at the end, and for leaving
9917 * it because of an exception we know will happen, which is done in
9918 * gen_exception_insn(). The latter is necessary because we need to
9919 * leave the TB with the PC/IT state just prior to execution of the
9920 * instruction which caused the exception.
9921 * (3) if we leave the TB unexpectedly (eg a data abort on a load)
9922 * then the CPUARMState will be wrong and we need to reset it.
9923 * This is handled in the same way as restoration of the
9924 * PC in these situations: we will be called again with search_pc=1
9925 * and generate a mapping of the condexec bits for each PC in
9926 * gen_opc_condexec_bits[]. restore_state_to_opc() then uses
9927 * this to restore the condexec bits.
9928 *
9929 * Note that there are no instructions which can read the condexec
9930 * bits, and none which can write non-static values to them, so
9931 * we don't need to care about whether CPUARMState is correct in the
9932 * middle of a TB.
9933 */
9934
9935 /* Reset the conditional execution bits immediately. This avoids
9936 complications trying to do it at the end of the block. */
9937 if (dc->condexec_mask || dc->condexec_cond)
9938 {
9939 TCGv tmp = tcg_temp_new_i32();
9940 tcg_gen_movi_i32(tmp, 0);
9941 store_cpu_field(tmp, condexec_bits);
9942 }
9943 do {
9944 #ifdef CONFIG_USER_ONLY
9945 /* Intercept jump to the magic kernel page. */
9946 if (dc->pc >= 0xffff0000) {
9947 /* We always get here via a jump, so know we are not in a
9948 conditional execution block. */
9949 gen_exception(EXCP_KERNEL_TRAP);
9950 dc->is_jmp = DISAS_UPDATE;
9951 break;
9952 }
9953 #else
9954 if (dc->pc >= 0xfffffff0 && IS_M(env)) {
9955 /* We always get here via a jump, so know we are not in a
9956 conditional execution block. */
9957 gen_exception(EXCP_EXCEPTION_EXIT);
9958 dc->is_jmp = DISAS_UPDATE;
9959 break;
9960 }
9961 #endif
9962
9963 if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
9964 QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
9965 if (bp->pc == dc->pc) {
9966 gen_exception_insn(dc, 0, EXCP_DEBUG);
9967 /* Advance PC so that clearing the breakpoint will
9968 invalidate this TB. */
9969 dc->pc += 2;
9970 goto done_generating;
9971 break;
9972 }
9973 }
9974 }
9975 if (search_pc) {
9976 j = gen_opc_ptr - gen_opc_buf;
9977 if (lj < j) {
9978 lj++;
9979 while (lj < j)
9980 gen_opc_instr_start[lj++] = 0;
9981 }
9982 gen_opc_pc[lj] = dc->pc;
9983 gen_opc_condexec_bits[lj] = (dc->condexec_cond << 4) | (dc->condexec_mask >> 1);
9984 gen_opc_instr_start[lj] = 1;
9985 gen_opc_icount[lj] = num_insns;
9986 }
9987
9988 if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))
9989 gen_io_start();
9990
9991 if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) {
9992 tcg_gen_debug_insn_start(dc->pc);
9993 }
9994
9995 if (dc->thumb) {
9996 disas_thumb_insn(env, dc);
9997 if (dc->condexec_mask) {
9998 dc->condexec_cond = (dc->condexec_cond & 0xe)
9999 | ((dc->condexec_mask >> 4) & 1);
10000 dc->condexec_mask = (dc->condexec_mask << 1) & 0x1f;
10001 if (dc->condexec_mask == 0) {
10002 dc->condexec_cond = 0;
10003 }
10004 }
10005 } else {
10006 disas_arm_insn(env, dc);
10007 }
10008
10009 if (dc->condjmp && !dc->is_jmp) {
10010 gen_set_label(dc->condlabel);
10011 dc->condjmp = 0;
10012 }
10013
10014 if (tcg_check_temp_count()) {
10015 fprintf(stderr, "TCG temporary leak before %08x\n", dc->pc);
10016 }
10017
10018 /* Translation stops when a conditional branch is encountered.
10019 * Otherwise the subsequent code could get translated several times.
10020 * Also stop translation when a page boundary is reached. This
10021 * ensures prefetch aborts occur at the right place. */
10022 num_insns ++;
10023 } while (!dc->is_jmp && gen_opc_ptr < gen_opc_end &&
10024 !env->singlestep_enabled &&
10025 !singlestep &&
10026 dc->pc < next_page_start &&
10027 num_insns < max_insns);
10028
10029 if (tb->cflags & CF_LAST_IO) {
10030 if (dc->condjmp) {
10031 /* FIXME: This can theoretically happen with self-modifying
10032 code. */
10033 cpu_abort(env, "IO on conditional branch instruction");
10034 }
10035 gen_io_end();
10036 }
10037
10038 /* At this stage dc->condjmp will only be set when the skipped
10039 instruction was a conditional branch or trap, and the PC has
10040 already been written. */
10041 if (unlikely(env->singlestep_enabled)) {
10042 /* Make sure the pc is updated, and raise a debug exception. */
10043 if (dc->condjmp) {
10044 gen_set_condexec(dc);
10045 if (dc->is_jmp == DISAS_SWI) {
10046 gen_exception(EXCP_SWI);
10047 } else {
10048 gen_exception(EXCP_DEBUG);
10049 }
10050 gen_set_label(dc->condlabel);
10051 }
10052 if (dc->condjmp || !dc->is_jmp) {
10053 gen_set_pc_im(dc->pc);
10054 dc->condjmp = 0;
10055 }
10056 gen_set_condexec(dc);
10057 if (dc->is_jmp == DISAS_SWI && !dc->condjmp) {
10058 gen_exception(EXCP_SWI);
10059 } else {
10060 /* FIXME: Single stepping a WFI insn will not halt
10061 the CPU. */
10062 gen_exception(EXCP_DEBUG);
10063 }
10064 } else {
10065 /* While branches must always occur at the end of an IT block,
10066 there are a few other things that can cause us to terminate
10067 the TB in the middel of an IT block:
10068 - Exception generating instructions (bkpt, swi, undefined).
10069 - Page boundaries.
10070 - Hardware watchpoints.
10071 Hardware breakpoints have already been handled and skip this code.
10072 */
10073 gen_set_condexec(dc);
10074 switch(dc->is_jmp) {
10075 case DISAS_NEXT:
10076 gen_goto_tb(dc, 1, dc->pc);
10077 break;
10078 default:
10079 case DISAS_JUMP:
10080 case DISAS_UPDATE:
10081 /* indicate that the hash table must be used to find the next TB */
10082 tcg_gen_exit_tb(0);
10083 break;
10084 case DISAS_TB_JUMP:
10085 /* nothing more to generate */
10086 break;
10087 case DISAS_WFI:
10088 gen_helper_wfi();
10089 break;
10090 case DISAS_SWI:
10091 gen_exception(EXCP_SWI);
10092 break;
10093 }
10094 if (dc->condjmp) {
10095 gen_set_label(dc->condlabel);
10096 gen_set_condexec(dc);
10097 gen_goto_tb(dc, 1, dc->pc);
10098 dc->condjmp = 0;
10099 }
10100 }
10101
10102 done_generating:
10103 gen_icount_end(tb, num_insns);
10104 *gen_opc_ptr = INDEX_op_end;
10105
10106 #ifdef DEBUG_DISAS
10107 if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
10108 qemu_log("----------------\n");
10109 qemu_log("IN: %s\n", lookup_symbol(pc_start));
10110 log_target_disas(pc_start, dc->pc - pc_start,
10111 dc->thumb | (dc->bswap_code << 1));
10112 qemu_log("\n");
10113 }
10114 #endif
10115 if (search_pc) {
10116 j = gen_opc_ptr - gen_opc_buf;
10117 lj++;
10118 while (lj <= j)
10119 gen_opc_instr_start[lj++] = 0;
10120 } else {
10121 tb->size = dc->pc - pc_start;
10122 tb->icount = num_insns;
10123 }
10124 }
10125
10126 void gen_intermediate_code(CPUARMState *env, TranslationBlock *tb)
10127 {
10128 gen_intermediate_code_internal(env, tb, 0);
10129 }
10130
10131 void gen_intermediate_code_pc(CPUARMState *env, TranslationBlock *tb)
10132 {
10133 gen_intermediate_code_internal(env, tb, 1);
10134 }
10135
10136 static const char *cpu_mode_names[16] = {
10137 "usr", "fiq", "irq", "svc", "???", "???", "???", "abt",
10138 "???", "???", "???", "und", "???", "???", "???", "sys"
10139 };
10140
10141 void cpu_dump_state(CPUARMState *env, FILE *f, fprintf_function cpu_fprintf,
10142 int flags)
10143 {
10144 int i;
10145 #if 0
10146 union {
10147 uint32_t i;
10148 float s;
10149 } s0, s1;
10150 CPU_DoubleU d;
10151 /* ??? This assumes float64 and double have the same layout.
10152 Oh well, it's only debug dumps. */
10153 union {
10154 float64 f64;
10155 double d;
10156 } d0;
10157 #endif
10158 uint32_t psr;
10159
10160 for(i=0;i<16;i++) {
10161 cpu_fprintf(f, "R%02d=%08x", i, env->regs[i]);
10162 if ((i % 4) == 3)
10163 cpu_fprintf(f, "\n");
10164 else
10165 cpu_fprintf(f, " ");
10166 }
10167 psr = cpsr_read(env);
10168 cpu_fprintf(f, "PSR=%08x %c%c%c%c %c %s%d\n",
10169 psr,
10170 psr & (1 << 31) ? 'N' : '-',
10171 psr & (1 << 30) ? 'Z' : '-',
10172 psr & (1 << 29) ? 'C' : '-',
10173 psr & (1 << 28) ? 'V' : '-',
10174 psr & CPSR_T ? 'T' : 'A',
10175 cpu_mode_names[psr & 0xf], (psr & 0x10) ? 32 : 26);
10176
10177 #if 0
10178 for (i = 0; i < 16; i++) {
10179 d.d = env->vfp.regs[i];
10180 s0.i = d.l.lower;
10181 s1.i = d.l.upper;
10182 d0.f64 = d.d;
10183 cpu_fprintf(f, "s%02d=%08x(%8g) s%02d=%08x(%8g) d%02d=%08x%08x(%8g)\n",
10184 i * 2, (int)s0.i, s0.s,
10185 i * 2 + 1, (int)s1.i, s1.s,
10186 i, (int)(uint32_t)d.l.upper, (int)(uint32_t)d.l.lower,
10187 d0.d);
10188 }
10189 cpu_fprintf(f, "FPSCR: %08x\n", (int)env->vfp.xregs[ARM_VFP_FPSCR]);
10190 #endif
10191 }
10192
10193 void restore_state_to_opc(CPUARMState *env, TranslationBlock *tb, int pc_pos)
10194 {
10195 env->regs[15] = gen_opc_pc[pc_pos];
10196 env->condexec_bits = gen_opc_condexec_bits[pc_pos];
10197 }
Patch queue for openSUSE QEMU