2 * CRIS emulation for qemu: main translation routines.
4 * Copyright (c) 2008 AXIS Communications AB
5 * Written by Edgar E. Iglesias.
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 * The condition code translation is in desperate need of attention. It's slow
25 * and for system simulation it seems buggy. It sucks.
40 #include "crisv32-decode.h"
41 #include "qemu-common.h"
58 #define BUG() (gen_BUG(dc, __FILE__, __LINE__))
59 #define BUG_ON(x) ({if (x) BUG();})
63 /* Used by the decoder. */
64 #define EXTRACT_FIELD(src, start, end) \
65 (((src) >> start) & ((1 << (end - start + 1)) - 1))
67 #define CC_MASK_NZ 0xc
68 #define CC_MASK_NZV 0xe
69 #define CC_MASK_NZVC 0xf
70 #define CC_MASK_RNZV 0x10e
86 /* This is the state at translation time. */
87 typedef struct DisasContext
{
96 unsigned int zsize
, zzsize
;
104 int flags_live
; /* Wether or not $ccs is uptodate. */
105 int flagx_live
; /* Wether or not flags_x has the x flag known at
108 int clear_x
; /* Clear x after this insn? */
110 int user
; /* user or kernel mode. */
119 struct TranslationBlock
*tb
;
120 int singlestep_enabled
;
123 void cris_prepare_jmp (DisasContext
*dc
, uint32_t dst
);
124 static void gen_BUG(DisasContext
*dc
, char *file
, int line
)
126 printf ("BUG: pc=%x %s %d\n", dc
->pc
, file
, line
);
127 fprintf (logfile
, "BUG: pc=%x %s %d\n", dc
->pc
, file
, line
);
128 cpu_dump_state (dc
->env
, stdout
, fprintf
, 0);
130 cris_prepare_jmp (dc
, 0x70000000 + line
);
133 const char *regnames
[] =
135 "$r0", "$r1", "$r2", "$r3",
136 "$r4", "$r5", "$r6", "$r7",
137 "$r8", "$r9", "$r10", "$r11",
138 "$r12", "$r13", "$sp", "$acr",
140 const char *pregnames
[] =
142 "$bz", "$vr", "$pid", "$srs",
143 "$wz", "$exs", "$eda", "$mof",
144 "$dz", "$ebp", "$erp", "$srp",
145 "$nrp", "$ccs", "$usp", "$spc",
148 /* We need this table to handle preg-moves with implicit width. */
160 #define t_gen_mov_TN_env(tn, member) \
161 _t_gen_mov_TN_env((tn), offsetof(CPUState, member))
162 #define t_gen_mov_env_TN(member, tn) \
163 _t_gen_mov_env_TN(offsetof(CPUState, member), (tn))
165 static inline void t_gen_mov_TN_reg(TCGv tn
, int r
)
168 fprintf(stderr
, "wrong register read $r%d\n", r
);
169 tcg_gen_mov_tl(tn
, cpu_R
[r
]);
171 static inline void t_gen_mov_reg_TN(int r
, TCGv tn
)
174 fprintf(stderr
, "wrong register write $r%d\n", r
);
175 tcg_gen_mov_tl(cpu_R
[r
], tn
);
178 static inline void _t_gen_mov_TN_env(TCGv tn
, int offset
)
180 if (offset
> sizeof (CPUState
))
181 fprintf(stderr
, "wrong load from env from off=%d\n", offset
);
182 tcg_gen_ld_tl(tn
, cpu_env
, offset
);
184 static inline void _t_gen_mov_env_TN(int offset
, TCGv tn
)
186 if (offset
> sizeof (CPUState
))
187 fprintf(stderr
, "wrong store to env at off=%d\n", offset
);
188 tcg_gen_st_tl(tn
, cpu_env
, offset
);
191 static inline void t_gen_mov_TN_preg(TCGv tn
, int r
)
194 fprintf(stderr
, "wrong register read $p%d\n", r
);
195 if (r
== PR_BZ
|| r
== PR_WZ
|| r
== PR_DZ
)
196 tcg_gen_mov_tl(tn
, tcg_const_tl(0));
198 tcg_gen_mov_tl(tn
, tcg_const_tl(32));
199 else if (r
== PR_EXS
) {
200 printf("read from EXS!\n");
201 tcg_gen_mov_tl(tn
, cpu_PR
[r
]);
203 else if (r
== PR_EDA
) {
204 printf("read from EDA!\n");
205 tcg_gen_mov_tl(tn
, cpu_PR
[r
]);
208 tcg_gen_mov_tl(tn
, cpu_PR
[r
]);
210 static inline void t_gen_mov_preg_TN(int r
, TCGv tn
)
213 fprintf(stderr
, "wrong register write $p%d\n", r
);
214 if (r
== PR_BZ
|| r
== PR_WZ
|| r
== PR_DZ
)
216 else if (r
== PR_SRS
)
217 tcg_gen_andi_tl(cpu_PR
[r
], tn
, 3);
220 tcg_gen_helper_0_0(helper_tlb_flush
);
222 tcg_gen_mov_tl(cpu_PR
[r
], tn
);
226 static inline void t_gen_mov_TN_im(TCGv tn
, int32_t val
)
228 tcg_gen_movi_tl(tn
, val
);
231 static void t_gen_lsl(TCGv d
, TCGv a
, TCGv b
)
235 l1
= gen_new_label();
236 /* Speculative shift. */
237 tcg_gen_shl_tl(d
, a
, b
);
238 tcg_gen_brcond_tl(TCG_COND_LE
, b
, tcg_const_tl(31), l1
);
239 /* Clear dst if shift operands were to large. */
240 tcg_gen_movi_tl(d
, 0);
244 static void t_gen_lsr(TCGv d
, TCGv a
, TCGv b
)
248 l1
= gen_new_label();
249 /* Speculative shift. */
250 tcg_gen_shr_tl(d
, a
, b
);
251 tcg_gen_brcond_tl(TCG_COND_LE
, b
, tcg_const_tl(31), l1
);
252 /* Clear dst if shift operands were to large. */
253 tcg_gen_movi_tl(d
, 0);
257 static void t_gen_asr(TCGv d
, TCGv a
, TCGv b
)
261 l1
= gen_new_label();
262 /* Speculative shift. */
263 tcg_gen_sar_tl(d
, a
, b
);
264 tcg_gen_brcond_tl(TCG_COND_LE
, b
, tcg_const_tl(31), l1
);
265 /* Clear dst if shift operands were to large. */
266 tcg_gen_sar_tl(d
, a
, tcg_const_tl(30));
270 /* 64-bit signed mul, lower result in d and upper in d2. */
271 static void t_gen_muls(TCGv d
, TCGv d2
, TCGv a
, TCGv b
)
275 t0
= tcg_temp_new(TCG_TYPE_I64
);
276 t1
= tcg_temp_new(TCG_TYPE_I64
);
278 tcg_gen_ext32s_i64(t0
, a
);
279 tcg_gen_ext32s_i64(t1
, b
);
280 tcg_gen_mul_i64(t0
, t0
, t1
);
282 tcg_gen_trunc_i64_i32(d
, t0
);
283 tcg_gen_shri_i64(t0
, t0
, 32);
284 tcg_gen_trunc_i64_i32(d2
, t0
);
286 tcg_gen_discard_i64(t0
);
287 tcg_gen_discard_i64(t1
);
290 /* 64-bit unsigned muls, lower result in d and upper in d2. */
291 static void t_gen_mulu(TCGv d
, TCGv d2
, TCGv a
, TCGv b
)
295 t0
= tcg_temp_new(TCG_TYPE_I64
);
296 t1
= tcg_temp_new(TCG_TYPE_I64
);
298 tcg_gen_extu_i32_i64(t0
, a
);
299 tcg_gen_extu_i32_i64(t1
, b
);
300 tcg_gen_mul_i64(t0
, t0
, t1
);
302 tcg_gen_trunc_i64_i32(d
, t0
);
303 tcg_gen_shri_i64(t0
, t0
, 32);
304 tcg_gen_trunc_i64_i32(d2
, t0
);
306 tcg_gen_discard_i64(t0
);
307 tcg_gen_discard_i64(t1
);
310 /* Extended arithmetics on CRIS. */
311 static inline void t_gen_add_flag(TCGv d
, int flag
)
315 c
= tcg_temp_new(TCG_TYPE_TL
);
316 t_gen_mov_TN_preg(c
, PR_CCS
);
317 /* Propagate carry into d. */
318 tcg_gen_andi_tl(c
, c
, 1 << flag
);
320 tcg_gen_shri_tl(c
, c
, flag
);
321 tcg_gen_add_tl(d
, d
, c
);
322 tcg_gen_discard_tl(c
);
325 static inline void t_gen_addx_carry(TCGv d
)
329 x
= tcg_temp_new(TCG_TYPE_TL
);
330 c
= tcg_temp_new(TCG_TYPE_TL
);
331 t_gen_mov_TN_preg(x
, PR_CCS
);
332 tcg_gen_mov_tl(c
, x
);
334 /* Propagate carry into d if X is set. Branch free. */
335 tcg_gen_andi_tl(c
, c
, C_FLAG
);
336 tcg_gen_andi_tl(x
, x
, X_FLAG
);
337 tcg_gen_shri_tl(x
, x
, 4);
339 tcg_gen_and_tl(x
, x
, c
);
340 tcg_gen_add_tl(d
, d
, x
);
341 tcg_gen_discard_tl(x
);
342 tcg_gen_discard_tl(c
);
345 static inline void t_gen_subx_carry(TCGv d
)
349 x
= tcg_temp_new(TCG_TYPE_TL
);
350 c
= tcg_temp_new(TCG_TYPE_TL
);
351 t_gen_mov_TN_preg(x
, PR_CCS
);
352 tcg_gen_mov_tl(c
, x
);
354 /* Propagate carry into d if X is set. Branch free. */
355 tcg_gen_andi_tl(c
, c
, C_FLAG
);
356 tcg_gen_andi_tl(x
, x
, X_FLAG
);
357 tcg_gen_shri_tl(x
, x
, 4);
359 tcg_gen_and_tl(x
, x
, c
);
360 tcg_gen_sub_tl(d
, d
, x
);
361 tcg_gen_discard_tl(x
);
362 tcg_gen_discard_tl(c
);
365 /* Swap the two bytes within each half word of the s operand.
366 T0 = ((T0 << 8) & 0xff00ff00) | ((T0 >> 8) & 0x00ff00ff) */
367 static inline void t_gen_swapb(TCGv d
, TCGv s
)
371 t
= tcg_temp_new(TCG_TYPE_TL
);
372 org_s
= tcg_temp_new(TCG_TYPE_TL
);
374 /* d and s may refer to the same object. */
375 tcg_gen_mov_tl(org_s
, s
);
376 tcg_gen_shli_tl(t
, org_s
, 8);
377 tcg_gen_andi_tl(d
, t
, 0xff00ff00);
378 tcg_gen_shri_tl(t
, org_s
, 8);
379 tcg_gen_andi_tl(t
, t
, 0x00ff00ff);
380 tcg_gen_or_tl(d
, d
, t
);
381 tcg_gen_discard_tl(t
);
382 tcg_gen_discard_tl(org_s
);
385 /* Swap the halfwords of the s operand. */
386 static inline void t_gen_swapw(TCGv d
, TCGv s
)
389 /* d and s refer the same object. */
390 t
= tcg_temp_new(TCG_TYPE_TL
);
391 tcg_gen_mov_tl(t
, s
);
392 tcg_gen_shli_tl(d
, t
, 16);
393 tcg_gen_shri_tl(t
, t
, 16);
394 tcg_gen_or_tl(d
, d
, t
);
395 tcg_gen_discard_tl(t
);
398 /* Reverse the within each byte.
399 T0 = (((T0 << 7) & 0x80808080) |
400 ((T0 << 5) & 0x40404040) |
401 ((T0 << 3) & 0x20202020) |
402 ((T0 << 1) & 0x10101010) |
403 ((T0 >> 1) & 0x08080808) |
404 ((T0 >> 3) & 0x04040404) |
405 ((T0 >> 5) & 0x02020202) |
406 ((T0 >> 7) & 0x01010101));
408 static inline void t_gen_swapr(TCGv d
, TCGv s
)
411 int shift
; /* LSL when positive, LSR when negative. */
426 /* d and s refer the same object. */
427 t
= tcg_temp_new(TCG_TYPE_TL
);
428 org_s
= tcg_temp_new(TCG_TYPE_TL
);
429 tcg_gen_mov_tl(org_s
, s
);
431 tcg_gen_shli_tl(t
, org_s
, bitrev
[0].shift
);
432 tcg_gen_andi_tl(d
, t
, bitrev
[0].mask
);
433 for (i
= 1; i
< sizeof bitrev
/ sizeof bitrev
[0]; i
++) {
434 if (bitrev
[i
].shift
>= 0) {
435 tcg_gen_shli_tl(t
, org_s
, bitrev
[i
].shift
);
437 tcg_gen_shri_tl(t
, org_s
, -bitrev
[i
].shift
);
439 tcg_gen_andi_tl(t
, t
, bitrev
[i
].mask
);
440 tcg_gen_or_tl(d
, d
, t
);
442 tcg_gen_discard_tl(t
);
443 tcg_gen_discard_tl(org_s
);
446 static void gen_goto_tb(DisasContext
*dc
, int n
, target_ulong dest
)
448 TranslationBlock
*tb
;
450 if ((tb
->pc
& TARGET_PAGE_MASK
) == (dest
& TARGET_PAGE_MASK
)) {
452 tcg_gen_movi_tl(cpu_T
[0], dest
);
453 t_gen_mov_env_TN(pc
, cpu_T
[0]);
454 tcg_gen_exit_tb((long)tb
+ n
);
456 t_gen_mov_env_TN(pc
, cpu_T
[0]);
461 /* Sign extend at translation time. */
462 static int sign_extend(unsigned int val
, unsigned int width
)
474 static inline void cris_clear_x_flag(DisasContext
*dc
)
477 || (dc
->flagx_live
&& dc
->flags_x
)
478 || dc
->cc_op
!= CC_OP_FLAGS
)
479 tcg_gen_andi_i32(cpu_PR
[PR_CCS
], cpu_PR
[PR_CCS
], ~X_FLAG
);
484 static void cris_evaluate_flags(DisasContext
*dc
)
486 if (!dc
->flags_live
) {
487 tcg_gen_movi_tl(cc_op
, dc
->cc_op
);
488 tcg_gen_movi_tl(cc_size
, dc
->cc_size
);
489 tcg_gen_movi_tl(cc_mask
, dc
->cc_mask
);
494 tcg_gen_helper_0_0(helper_evaluate_flags_mcp
);
497 tcg_gen_helper_0_0(helper_evaluate_flags_muls
);
500 tcg_gen_helper_0_0(helper_evaluate_flags_mulu
);
506 tcg_gen_helper_0_0(helper_evaluate_flags_move_4
);
509 tcg_gen_helper_0_0(helper_evaluate_flags_move_2
);
512 tcg_gen_helper_0_0(helper_evaluate_flags
);
524 tcg_gen_helper_0_0(helper_evaluate_flags_alu_4
);
527 tcg_gen_helper_0_0(helper_evaluate_flags
);
537 static void cris_cc_mask(DisasContext
*dc
, unsigned int mask
)
541 /* Check if we need to evaluate the condition codes due to
543 ovl
= (dc
->cc_mask
^ mask
) & ~mask
;
545 /* TODO: optimize this case. It trigs all the time. */
546 cris_evaluate_flags (dc
);
557 static void cris_update_cc_op(DisasContext
*dc
, int op
, int size
)
564 /* op is the operation.
565 T0, T1 are the operands.
566 dst is the destination reg.
568 static void crisv32_alu_op(DisasContext
*dc
, int op
, int rd
, int size
)
572 cris_update_cc_op(dc
, op
, size
);
573 tcg_gen_mov_tl(cc_dest
, cpu_T
[0]);
575 /* FIXME: This shouldn't be needed. But we don't pass the
576 tests without it. Investigate. */
577 t_gen_mov_env_TN(cc_x_live
, tcg_const_tl(dc
->flagx_live
));
578 t_gen_mov_env_TN(cc_x
, tcg_const_tl(dc
->flags_x
));
581 /* Emit the ALU insns. */
585 tcg_gen_add_tl(cpu_T
[0], cpu_T
[0], cpu_T
[1]);
586 /* Extended arithmetics. */
587 t_gen_addx_carry(cpu_T
[0]);
590 tcg_gen_add_tl(cpu_T
[0], cpu_T
[0], cpu_T
[1]);
591 t_gen_add_flag(cpu_T
[0], 0); /* C_FLAG. */
594 tcg_gen_add_tl(cpu_T
[0], cpu_T
[0], cpu_T
[1]);
595 t_gen_add_flag(cpu_T
[0], 8); /* R_FLAG. */
598 tcg_gen_sub_tl(cpu_T
[1], tcg_const_tl(0), cpu_T
[1]);
599 tcg_gen_add_tl(cpu_T
[0], cpu_T
[0], cpu_T
[1]);
600 tcg_gen_sub_tl(cpu_T
[1], tcg_const_tl(0), cpu_T
[1]);
601 /* CRIS flag evaluation needs ~src. */
602 tcg_gen_xori_tl(cpu_T
[1], cpu_T
[1], -1);
604 /* Extended arithmetics. */
605 t_gen_subx_carry(cpu_T
[0]);
608 tcg_gen_mov_tl(cpu_T
[0], cpu_T
[1]);
611 tcg_gen_or_tl(cpu_T
[0], cpu_T
[0], cpu_T
[1]);
614 tcg_gen_and_tl(cpu_T
[0], cpu_T
[0], cpu_T
[1]);
617 tcg_gen_xor_tl(cpu_T
[0], cpu_T
[0], cpu_T
[1]);
620 t_gen_lsl(cpu_T
[0], cpu_T
[0], cpu_T
[1]);
623 t_gen_lsr(cpu_T
[0], cpu_T
[0], cpu_T
[1]);
626 t_gen_asr(cpu_T
[0], cpu_T
[0], cpu_T
[1]);
629 /* Hopefully the TCG backend recognizes this pattern
630 and makes a real neg out of it. */
631 tcg_gen_sub_tl(cpu_T
[0], tcg_const_tl(0), cpu_T
[1]);
632 /* Extended arithmetics. */
633 t_gen_subx_carry(cpu_T
[0]);
645 mof
= tcg_temp_new(TCG_TYPE_TL
);
646 t_gen_muls(cpu_T
[0], mof
, cpu_T
[0], cpu_T
[1]);
647 t_gen_mov_preg_TN(PR_MOF
, mof
);
648 tcg_gen_discard_tl(mof
);
654 mof
= tcg_temp_new(TCG_TYPE_TL
);
655 t_gen_mulu(cpu_T
[0], mof
, cpu_T
[0], cpu_T
[1]);
656 t_gen_mov_preg_TN(PR_MOF
, mof
);
657 tcg_gen_discard_tl(mof
);
661 gen_op_dstep_T0_T1();
666 l1
= gen_new_label();
667 tcg_gen_brcond_tl(TCG_COND_LEU
,
668 cpu_T
[0], cpu_T
[1], l1
);
669 tcg_gen_mov_tl(cpu_T
[0], cpu_T
[1]);
674 tcg_gen_sub_tl(cpu_T
[1], tcg_const_tl(0), cpu_T
[1]);
675 tcg_gen_add_tl(cpu_T
[0], cpu_T
[0], cpu_T
[1]);
676 /* CRIS flag evaluation needs ~src. */
677 tcg_gen_sub_tl(cpu_T
[1], tcg_const_tl(0), cpu_T
[1]);
678 /* CRIS flag evaluation needs ~src. */
679 tcg_gen_xori_tl(cpu_T
[1], cpu_T
[1], -1);
681 /* Extended arithmetics. */
682 t_gen_subx_carry(cpu_T
[0]);
686 fprintf (logfile
, "illegal ALU op.\n");
692 tcg_gen_mov_tl(cc_src
, cpu_T
[1]);
695 tcg_gen_andi_tl(cpu_T
[0], cpu_T
[0], 0xff);
697 tcg_gen_andi_tl(cpu_T
[0], cpu_T
[0], 0xffff);
702 t_gen_mov_reg_TN(rd
, cpu_T
[0]);
704 tcg_gen_mov_tl(cpu_T
[1], cpu_T
[0]);
705 t_gen_mov_TN_reg(cpu_T
[0], rd
);
707 tcg_gen_andi_tl(cpu_T
[0], cpu_T
[0], ~0xff);
709 tcg_gen_andi_tl(cpu_T
[0], cpu_T
[0], ~0xffff);
710 tcg_gen_or_tl(cpu_T
[0], cpu_T
[0], cpu_T
[1]);
711 t_gen_mov_reg_TN(rd
, cpu_T
[0]);
712 tcg_gen_mov_tl(cpu_T
[0], cpu_T
[1]);
716 tcg_gen_mov_tl(cc_result
, cpu_T
[0]);
719 /* TODO: Optimize this. */
721 cris_evaluate_flags(dc
);
725 static int arith_cc(DisasContext
*dc
)
729 case CC_OP_ADD
: return 1;
730 case CC_OP_SUB
: return 1;
731 case CC_OP_LSL
: return 1;
732 case CC_OP_LSR
: return 1;
733 case CC_OP_ASR
: return 1;
734 case CC_OP_CMP
: return 1;
742 static void gen_tst_cc (DisasContext
*dc
, int cond
)
746 /* TODO: optimize more condition codes. */
747 arith_opt
= arith_cc(dc
) && !dc
->flags_live
;
751 gen_op_tst_cc_eq_fast ();
753 cris_evaluate_flags(dc
);
759 gen_op_tst_cc_ne_fast ();
761 cris_evaluate_flags(dc
);
766 cris_evaluate_flags(dc
);
770 cris_evaluate_flags(dc
);
774 cris_evaluate_flags(dc
);
778 cris_evaluate_flags(dc
);
783 gen_op_tst_cc_pl_fast ();
785 cris_evaluate_flags(dc
);
791 gen_op_tst_cc_mi_fast ();
793 cris_evaluate_flags(dc
);
798 cris_evaluate_flags(dc
);
802 cris_evaluate_flags(dc
);
806 cris_evaluate_flags(dc
);
810 cris_evaluate_flags(dc
);
814 cris_evaluate_flags(dc
);
818 cris_evaluate_flags(dc
);
822 cris_evaluate_flags(dc
);
826 cris_evaluate_flags(dc
);
827 gen_op_movl_T0_im (1);
835 static void cris_prepare_cc_branch (DisasContext
*dc
, int offset
, int cond
)
837 /* This helps us re-schedule the micro-code to insns in delay-slots
838 before the actual jump. */
839 dc
->delayed_branch
= 2;
840 dc
->delayed_pc
= dc
->pc
+ offset
;
844 gen_tst_cc (dc
, cond
);
845 gen_op_evaluate_bcc ();
847 tcg_gen_movi_tl(env_btarget
, dc
->delayed_pc
);
851 /* Dynamic jumps, when the dest is in a live reg for example. */
852 void cris_prepare_dyn_jmp (DisasContext
*dc
)
854 /* This helps us re-schedule the micro-code to insns in delay-slots
855 before the actual jump. */
856 dc
->delayed_branch
= 2;
861 void cris_prepare_jmp (DisasContext
*dc
, uint32_t dst
)
863 /* This helps us re-schedule the micro-code to insns in delay-slots
864 before the actual jump. */
865 dc
->delayed_branch
= 2;
866 dc
->delayed_pc
= dst
;
871 void gen_load(DisasContext
*dc
, TCGv dst
, TCGv addr
,
872 unsigned int size
, int sign
)
874 int mem_index
= cpu_mmu_index(dc
->env
);
876 /* FIXME: qemu_ld does not act as a barrier? */
877 tcg_gen_helper_0_0(helper_dummy
);
878 cris_evaluate_flags(dc
);
881 tcg_gen_qemu_ld8s(dst
, addr
, mem_index
);
883 tcg_gen_qemu_ld8u(dst
, addr
, mem_index
);
885 else if (size
== 2) {
887 tcg_gen_qemu_ld16s(dst
, addr
, mem_index
);
889 tcg_gen_qemu_ld16u(dst
, addr
, mem_index
);
892 tcg_gen_qemu_ld32s(dst
, addr
, mem_index
);
896 void gen_store_T0_T1 (DisasContext
*dc
, unsigned int size
)
898 int mem_index
= cpu_mmu_index(dc
->env
);
900 /* FIXME: qemu_st does not act as a barrier? */
901 tcg_gen_helper_0_0(helper_dummy
);
902 cris_evaluate_flags(dc
);
904 /* Remember, operands are flipped. CRIS has reversed order. */
906 tcg_gen_qemu_st8(cpu_T
[1], cpu_T
[0], mem_index
);
908 tcg_gen_qemu_st16(cpu_T
[1], cpu_T
[0], mem_index
);
910 tcg_gen_qemu_st32(cpu_T
[1], cpu_T
[0], mem_index
);
913 static inline void t_gen_sext(TCGv d
, TCGv s
, int size
)
916 tcg_gen_ext8s_i32(d
, s
);
918 tcg_gen_ext16s_i32(d
, s
);
921 static inline void t_gen_zext(TCGv d
, TCGv s
, int size
)
923 /* TCG-FIXME: this is not optimal. Many archs have fast zext insns. */
925 tcg_gen_andi_i32(d
, s
, 0xff);
927 tcg_gen_andi_i32(d
, s
, 0xffff);
931 static char memsize_char(int size
)
935 case 1: return 'b'; break;
936 case 2: return 'w'; break;
937 case 4: return 'd'; break;
945 static unsigned int memsize_z(DisasContext
*dc
)
947 return dc
->zsize
+ 1;
950 static unsigned int memsize_zz(DisasContext
*dc
)
961 static void do_postinc (DisasContext
*dc
, int size
)
965 t_gen_mov_TN_reg(cpu_T
[0], dc
->op1
);
966 tcg_gen_addi_tl(cpu_T
[0], cpu_T
[0], size
);
967 t_gen_mov_reg_TN(dc
->op1
, cpu_T
[0]);
971 static void dec_prep_move_r(DisasContext
*dc
, int rs
, int rd
,
974 t_gen_mov_TN_reg(cpu_T
[1], rs
);
976 t_gen_sext(cpu_T
[1], cpu_T
[1], size
);
978 t_gen_zext(cpu_T
[1], cpu_T
[1], size
);
981 /* Prepare T0 and T1 for a register alu operation.
982 s_ext decides if the operand1 should be sign-extended or zero-extended when
984 static void dec_prep_alu_r(DisasContext
*dc
, int rs
, int rd
,
987 dec_prep_move_r(dc
, rs
, rd
, size
, s_ext
);
989 t_gen_mov_TN_reg(cpu_T
[0], rd
);
991 t_gen_sext(cpu_T
[0], cpu_T
[0], size
);
993 t_gen_zext(cpu_T
[0], cpu_T
[0], size
);
996 /* Prepare T0 and T1 for a memory + alu operation.
997 s_ext decides if the operand1 should be sign-extended or zero-extended when
999 static int dec_prep_alu_m(DisasContext
*dc
, int s_ext
, int memsize
)
1001 unsigned int rs
, rd
;
1008 is_imm
= rs
== 15 && dc
->postinc
;
1010 /* Load [$rs] onto T1. */
1012 insn_len
= 2 + memsize
;
1016 imm
= ldl_code(dc
->pc
+ 2);
1019 imm
= sign_extend(imm
, (memsize
* 8) - 1);
1027 DIS(fprintf (logfile
, "imm=%x rd=%d sext=%d ms=%d\n",
1028 imm
, rd
, s_ext
, memsize
));
1029 tcg_gen_movi_tl(cpu_T
[1], imm
);
1032 gen_load(dc
, cpu_T
[1], cpu_R
[rs
], memsize
, 0);
1034 t_gen_sext(cpu_T
[1], cpu_T
[1], memsize
);
1036 t_gen_zext(cpu_T
[1], cpu_T
[1], memsize
);
1039 /* put dest in T0. */
1040 t_gen_mov_TN_reg(cpu_T
[0], rd
);
1045 static const char *cc_name(int cc
)
1047 static char *cc_names
[16] = {
1048 "cc", "cs", "ne", "eq", "vc", "vs", "pl", "mi",
1049 "ls", "hi", "ge", "lt", "gt", "le", "a", "p"
1052 return cc_names
[cc
];
1056 /* Start of insn decoders. */
1058 static unsigned int dec_bccq(DisasContext
*dc
)
1062 uint32_t cond
= dc
->op2
;
1065 offset
= EXTRACT_FIELD (dc
->ir
, 1, 7);
1066 sign
= EXTRACT_FIELD(dc
->ir
, 0, 0);
1069 offset
|= sign
<< 8;
1071 offset
= sign_extend(offset
, 8);
1073 /* op2 holds the condition-code. */
1074 cris_cc_mask(dc
, 0);
1075 cris_prepare_cc_branch (dc
, offset
, cond
);
1078 static unsigned int dec_addoq(DisasContext
*dc
)
1082 dc
->op1
= EXTRACT_FIELD(dc
->ir
, 0, 7);
1083 imm
= sign_extend(dc
->op1
, 7);
1085 DIS(fprintf (logfile
, "addoq %d, $r%u\n", imm
, dc
->op2
));
1086 cris_cc_mask(dc
, 0);
1087 /* Fetch register operand, */
1088 tcg_gen_addi_tl(cpu_R
[R_ACR
], cpu_R
[dc
->op2
], imm
);
1091 static unsigned int dec_addq(DisasContext
*dc
)
1093 DIS(fprintf (logfile
, "addq %u, $r%u\n", dc
->op1
, dc
->op2
));
1095 dc
->op1
= EXTRACT_FIELD(dc
->ir
, 0, 5);
1097 cris_cc_mask(dc
, CC_MASK_NZVC
);
1098 /* Fetch register operand, */
1099 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1100 tcg_gen_movi_tl(cpu_T
[1], dc
->op1
);
1101 crisv32_alu_op(dc
, CC_OP_ADD
, dc
->op2
, 4);
1104 static unsigned int dec_moveq(DisasContext
*dc
)
1108 dc
->op1
= EXTRACT_FIELD(dc
->ir
, 0, 5);
1109 imm
= sign_extend(dc
->op1
, 5);
1110 DIS(fprintf (logfile
, "moveq %d, $r%u\n", imm
, dc
->op2
));
1112 t_gen_mov_reg_TN(dc
->op2
, tcg_const_tl(imm
));
1115 static unsigned int dec_subq(DisasContext
*dc
)
1117 dc
->op1
= EXTRACT_FIELD(dc
->ir
, 0, 5);
1119 DIS(fprintf (logfile
, "subq %u, $r%u\n", dc
->op1
, dc
->op2
));
1121 cris_cc_mask(dc
, CC_MASK_NZVC
);
1122 /* Fetch register operand, */
1123 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1124 t_gen_mov_TN_im(cpu_T
[1], dc
->op1
);
1125 crisv32_alu_op(dc
, CC_OP_SUB
, dc
->op2
, 4);
1128 static unsigned int dec_cmpq(DisasContext
*dc
)
1131 dc
->op1
= EXTRACT_FIELD(dc
->ir
, 0, 5);
1132 imm
= sign_extend(dc
->op1
, 5);
1134 DIS(fprintf (logfile
, "cmpq %d, $r%d\n", imm
, dc
->op2
));
1135 cris_cc_mask(dc
, CC_MASK_NZVC
);
1136 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1137 t_gen_mov_TN_im(cpu_T
[1], imm
);
1138 crisv32_alu_op(dc
, CC_OP_CMP
, dc
->op2
, 4);
1141 static unsigned int dec_andq(DisasContext
*dc
)
1144 dc
->op1
= EXTRACT_FIELD(dc
->ir
, 0, 5);
1145 imm
= sign_extend(dc
->op1
, 5);
1147 DIS(fprintf (logfile
, "andq %d, $r%d\n", imm
, dc
->op2
));
1148 cris_cc_mask(dc
, CC_MASK_NZ
);
1149 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1150 t_gen_mov_TN_im(cpu_T
[1], imm
);
1151 crisv32_alu_op(dc
, CC_OP_AND
, dc
->op2
, 4);
1154 static unsigned int dec_orq(DisasContext
*dc
)
1157 dc
->op1
= EXTRACT_FIELD(dc
->ir
, 0, 5);
1158 imm
= sign_extend(dc
->op1
, 5);
1159 DIS(fprintf (logfile
, "orq %d, $r%d\n", imm
, dc
->op2
));
1160 cris_cc_mask(dc
, CC_MASK_NZ
);
1161 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1162 t_gen_mov_TN_im(cpu_T
[1], imm
);
1163 crisv32_alu_op(dc
, CC_OP_OR
, dc
->op2
, 4);
1166 static unsigned int dec_btstq(DisasContext
*dc
)
1168 dc
->op1
= EXTRACT_FIELD(dc
->ir
, 0, 4);
1169 DIS(fprintf (logfile
, "btstq %u, $r%d\n", dc
->op1
, dc
->op2
));
1170 cris_cc_mask(dc
, CC_MASK_NZ
);
1171 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1172 t_gen_mov_TN_im(cpu_T
[1], dc
->op1
);
1173 crisv32_alu_op(dc
, CC_OP_BTST
, dc
->op2
, 4);
1175 cris_update_cc_op(dc
, CC_OP_FLAGS
, 4);
1176 t_gen_mov_preg_TN(PR_CCS
, cpu_T
[0]);
1180 static unsigned int dec_asrq(DisasContext
*dc
)
1182 dc
->op1
= EXTRACT_FIELD(dc
->ir
, 0, 4);
1183 DIS(fprintf (logfile
, "asrq %u, $r%d\n", dc
->op1
, dc
->op2
));
1184 cris_cc_mask(dc
, CC_MASK_NZ
);
1185 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1186 t_gen_mov_TN_im(cpu_T
[1], dc
->op1
);
1187 crisv32_alu_op(dc
, CC_OP_ASR
, dc
->op2
, 4);
1190 static unsigned int dec_lslq(DisasContext
*dc
)
1192 dc
->op1
= EXTRACT_FIELD(dc
->ir
, 0, 4);
1193 DIS(fprintf (logfile
, "lslq %u, $r%d\n", dc
->op1
, dc
->op2
));
1195 cris_cc_mask(dc
, CC_MASK_NZ
);
1196 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1197 t_gen_mov_TN_im(cpu_T
[1], dc
->op1
);
1198 crisv32_alu_op(dc
, CC_OP_LSL
, dc
->op2
, 4);
1201 static unsigned int dec_lsrq(DisasContext
*dc
)
1203 dc
->op1
= EXTRACT_FIELD(dc
->ir
, 0, 4);
1204 DIS(fprintf (logfile
, "lsrq %u, $r%d\n", dc
->op1
, dc
->op2
));
1206 cris_cc_mask(dc
, CC_MASK_NZ
);
1207 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1208 t_gen_mov_TN_im(cpu_T
[1], dc
->op1
);
1209 crisv32_alu_op(dc
, CC_OP_LSR
, dc
->op2
, 4);
1213 static unsigned int dec_move_r(DisasContext
*dc
)
1215 int size
= memsize_zz(dc
);
1217 DIS(fprintf (logfile
, "move.%c $r%u, $r%u\n",
1218 memsize_char(size
), dc
->op1
, dc
->op2
));
1220 cris_cc_mask(dc
, CC_MASK_NZ
);
1221 dec_prep_move_r(dc
, dc
->op1
, dc
->op2
, size
, 0);
1222 crisv32_alu_op(dc
, CC_OP_MOVE
, dc
->op2
, size
);
1226 static unsigned int dec_scc_r(DisasContext
*dc
)
1230 DIS(fprintf (logfile
, "s%s $r%u\n",
1231 cc_name(cond
), dc
->op1
));
1235 gen_tst_cc (dc
, cond
);
1236 tcg_gen_mov_tl(cpu_T
[1], cpu_T
[0]);
1239 tcg_gen_movi_tl(cpu_T
[1], 1);
1241 cris_cc_mask(dc
, 0);
1242 crisv32_alu_op(dc
, CC_OP_MOVE
, dc
->op1
, 4);
1246 static unsigned int dec_and_r(DisasContext
*dc
)
1248 int size
= memsize_zz(dc
);
1250 DIS(fprintf (logfile
, "and.%c $r%u, $r%u\n",
1251 memsize_char(size
), dc
->op1
, dc
->op2
));
1252 cris_cc_mask(dc
, CC_MASK_NZ
);
1253 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, size
, 0);
1254 crisv32_alu_op(dc
, CC_OP_AND
, dc
->op2
, size
);
1258 static unsigned int dec_lz_r(DisasContext
*dc
)
1260 DIS(fprintf (logfile
, "lz $r%u, $r%u\n",
1262 cris_cc_mask(dc
, CC_MASK_NZ
);
1263 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, 4, 0);
1264 crisv32_alu_op(dc
, CC_OP_LZ
, dc
->op2
, 4);
1268 static unsigned int dec_lsl_r(DisasContext
*dc
)
1270 int size
= memsize_zz(dc
);
1272 DIS(fprintf (logfile
, "lsl.%c $r%u, $r%u\n",
1273 memsize_char(size
), dc
->op1
, dc
->op2
));
1274 cris_cc_mask(dc
, CC_MASK_NZ
);
1275 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, size
, 0);
1276 tcg_gen_andi_tl(cpu_T
[1], cpu_T
[1], 63);
1277 crisv32_alu_op(dc
, CC_OP_LSL
, dc
->op2
, size
);
1281 static unsigned int dec_lsr_r(DisasContext
*dc
)
1283 int size
= memsize_zz(dc
);
1285 DIS(fprintf (logfile
, "lsr.%c $r%u, $r%u\n",
1286 memsize_char(size
), dc
->op1
, dc
->op2
));
1287 cris_cc_mask(dc
, CC_MASK_NZ
);
1288 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, size
, 0);
1289 tcg_gen_andi_tl(cpu_T
[1], cpu_T
[1], 63);
1290 crisv32_alu_op(dc
, CC_OP_LSR
, dc
->op2
, size
);
1294 static unsigned int dec_asr_r(DisasContext
*dc
)
1296 int size
= memsize_zz(dc
);
1298 DIS(fprintf (logfile
, "asr.%c $r%u, $r%u\n",
1299 memsize_char(size
), dc
->op1
, dc
->op2
));
1300 cris_cc_mask(dc
, CC_MASK_NZ
);
1301 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, size
, 1);
1302 tcg_gen_andi_tl(cpu_T
[1], cpu_T
[1], 63);
1303 crisv32_alu_op(dc
, CC_OP_ASR
, dc
->op2
, size
);
1307 static unsigned int dec_muls_r(DisasContext
*dc
)
1309 int size
= memsize_zz(dc
);
1311 DIS(fprintf (logfile
, "muls.%c $r%u, $r%u\n",
1312 memsize_char(size
), dc
->op1
, dc
->op2
));
1313 cris_cc_mask(dc
, CC_MASK_NZV
);
1314 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, size
, 1);
1315 t_gen_sext(cpu_T
[0], cpu_T
[0], size
);
1316 crisv32_alu_op(dc
, CC_OP_MULS
, dc
->op2
, 4);
1320 static unsigned int dec_mulu_r(DisasContext
*dc
)
1322 int size
= memsize_zz(dc
);
1324 DIS(fprintf (logfile
, "mulu.%c $r%u, $r%u\n",
1325 memsize_char(size
), dc
->op1
, dc
->op2
));
1326 cris_cc_mask(dc
, CC_MASK_NZV
);
1327 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, size
, 0);
1328 t_gen_zext(cpu_T
[0], cpu_T
[0], size
);
1329 crisv32_alu_op(dc
, CC_OP_MULU
, dc
->op2
, 4);
1334 static unsigned int dec_dstep_r(DisasContext
*dc
)
1336 DIS(fprintf (logfile
, "dstep $r%u, $r%u\n", dc
->op1
, dc
->op2
));
1337 cris_cc_mask(dc
, CC_MASK_NZ
);
1338 t_gen_mov_TN_reg(cpu_T
[1], dc
->op1
);
1339 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1340 crisv32_alu_op(dc
, CC_OP_DSTEP
, dc
->op2
, 4);
1344 static unsigned int dec_xor_r(DisasContext
*dc
)
1346 int size
= memsize_zz(dc
);
1347 DIS(fprintf (logfile
, "xor.%c $r%u, $r%u\n",
1348 memsize_char(size
), dc
->op1
, dc
->op2
));
1349 BUG_ON(size
!= 4); /* xor is dword. */
1350 cris_cc_mask(dc
, CC_MASK_NZ
);
1351 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, size
, 0);
1352 crisv32_alu_op(dc
, CC_OP_XOR
, dc
->op2
, 4);
1356 static unsigned int dec_bound_r(DisasContext
*dc
)
1358 int size
= memsize_zz(dc
);
1359 DIS(fprintf (logfile
, "bound.%c $r%u, $r%u\n",
1360 memsize_char(size
), dc
->op1
, dc
->op2
));
1361 cris_cc_mask(dc
, CC_MASK_NZ
);
1362 /* TODO: needs optmimization. */
1363 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, size
, 0);
1364 /* rd should be 4. */
1365 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1366 crisv32_alu_op(dc
, CC_OP_BOUND
, dc
->op2
, 4);
1370 static unsigned int dec_cmp_r(DisasContext
*dc
)
1372 int size
= memsize_zz(dc
);
1373 DIS(fprintf (logfile
, "cmp.%c $r%u, $r%u\n",
1374 memsize_char(size
), dc
->op1
, dc
->op2
));
1375 cris_cc_mask(dc
, CC_MASK_NZVC
);
1376 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, size
, 0);
1377 crisv32_alu_op(dc
, CC_OP_CMP
, dc
->op2
, size
);
1381 static unsigned int dec_abs_r(DisasContext
*dc
)
1385 DIS(fprintf (logfile
, "abs $r%u, $r%u\n",
1387 cris_cc_mask(dc
, CC_MASK_NZ
);
1388 dec_prep_move_r(dc
, dc
->op1
, dc
->op2
, 4, 0);
1390 /* TODO: consider a branch free approach. */
1391 l1
= gen_new_label();
1392 tcg_gen_brcond_tl(TCG_COND_GE
, cpu_T
[1], tcg_const_tl(0), l1
);
1393 tcg_gen_sub_tl(cpu_T
[1], tcg_const_tl(0), cpu_T
[1]);
1395 crisv32_alu_op(dc
, CC_OP_MOVE
, dc
->op2
, 4);
1399 static unsigned int dec_add_r(DisasContext
*dc
)
1401 int size
= memsize_zz(dc
);
1402 DIS(fprintf (logfile
, "add.%c $r%u, $r%u\n",
1403 memsize_char(size
), dc
->op1
, dc
->op2
));
1404 cris_cc_mask(dc
, CC_MASK_NZVC
);
1405 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, size
, 0);
1406 crisv32_alu_op(dc
, CC_OP_ADD
, dc
->op2
, size
);
1410 static unsigned int dec_addc_r(DisasContext
*dc
)
1412 DIS(fprintf (logfile
, "addc $r%u, $r%u\n",
1414 cris_evaluate_flags(dc
);
1415 cris_cc_mask(dc
, CC_MASK_NZVC
);
1416 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, 4, 0);
1417 crisv32_alu_op(dc
, CC_OP_ADDC
, dc
->op2
, 4);
1421 static unsigned int dec_mcp_r(DisasContext
*dc
)
1423 DIS(fprintf (logfile
, "mcp $p%u, $r%u\n",
1425 cris_evaluate_flags(dc
);
1426 cris_cc_mask(dc
, CC_MASK_RNZV
);
1427 t_gen_mov_TN_reg(cpu_T
[0], dc
->op1
);
1428 t_gen_mov_TN_preg(cpu_T
[1], dc
->op2
);
1429 crisv32_alu_op(dc
, CC_OP_MCP
, dc
->op1
, 4);
1434 static char * swapmode_name(int mode
, char *modename
) {
1437 modename
[i
++] = 'n';
1439 modename
[i
++] = 'w';
1441 modename
[i
++] = 'b';
1443 modename
[i
++] = 'r';
1449 static unsigned int dec_swap_r(DisasContext
*dc
)
1451 DIS(char modename
[4]);
1452 DIS(fprintf (logfile
, "swap%s $r%u\n",
1453 swapmode_name(dc
->op2
, modename
), dc
->op1
));
1455 cris_cc_mask(dc
, CC_MASK_NZ
);
1456 t_gen_mov_TN_reg(cpu_T
[0], dc
->op1
);
1458 tcg_gen_xori_tl(cpu_T
[0], cpu_T
[0], -1);
1460 t_gen_swapw(cpu_T
[0], cpu_T
[0]);
1462 t_gen_swapb(cpu_T
[0], cpu_T
[0]);
1464 t_gen_swapr(cpu_T
[0], cpu_T
[0]);
1465 tcg_gen_mov_tl(cpu_T
[1], cpu_T
[0]);
1466 crisv32_alu_op(dc
, CC_OP_MOVE
, dc
->op1
, 4);
1470 static unsigned int dec_or_r(DisasContext
*dc
)
1472 int size
= memsize_zz(dc
);
1473 DIS(fprintf (logfile
, "or.%c $r%u, $r%u\n",
1474 memsize_char(size
), dc
->op1
, dc
->op2
));
1475 cris_cc_mask(dc
, CC_MASK_NZ
);
1476 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, size
, 0);
1477 crisv32_alu_op(dc
, CC_OP_OR
, dc
->op2
, size
);
1481 static unsigned int dec_addi_r(DisasContext
*dc
)
1483 DIS(fprintf (logfile
, "addi.%c $r%u, $r%u\n",
1484 memsize_char(memsize_zz(dc
)), dc
->op2
, dc
->op1
));
1485 cris_cc_mask(dc
, 0);
1486 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, 4, 0);
1487 t_gen_lsl(cpu_T
[0], cpu_T
[0], tcg_const_tl(dc
->zzsize
));
1488 tcg_gen_add_tl(cpu_T
[0], cpu_T
[0], cpu_T
[1]);
1489 t_gen_mov_reg_TN(dc
->op1
, cpu_T
[0]);
1493 static unsigned int dec_addi_acr(DisasContext
*dc
)
1495 DIS(fprintf (logfile
, "addi.%c $r%u, $r%u, $acr\n",
1496 memsize_char(memsize_zz(dc
)), dc
->op2
, dc
->op1
));
1497 cris_cc_mask(dc
, 0);
1498 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, 4, 0);
1499 t_gen_lsl(cpu_T
[0], cpu_T
[0], tcg_const_tl(dc
->zzsize
));
1501 tcg_gen_add_tl(cpu_T
[0], cpu_T
[0], cpu_T
[1]);
1502 t_gen_mov_reg_TN(R_ACR
, cpu_T
[0]);
1506 static unsigned int dec_neg_r(DisasContext
*dc
)
1508 int size
= memsize_zz(dc
);
1509 DIS(fprintf (logfile
, "neg.%c $r%u, $r%u\n",
1510 memsize_char(size
), dc
->op1
, dc
->op2
));
1511 cris_cc_mask(dc
, CC_MASK_NZVC
);
1512 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, size
, 0);
1513 crisv32_alu_op(dc
, CC_OP_NEG
, dc
->op2
, size
);
1517 static unsigned int dec_btst_r(DisasContext
*dc
)
1519 DIS(fprintf (logfile
, "btst $r%u, $r%u\n",
1521 cris_cc_mask(dc
, CC_MASK_NZ
);
1522 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, 4, 0);
1523 crisv32_alu_op(dc
, CC_OP_BTST
, dc
->op2
, 4);
1525 cris_update_cc_op(dc
, CC_OP_FLAGS
, 4);
1526 t_gen_mov_preg_TN(PR_CCS
, cpu_T
[0]);
1531 static unsigned int dec_sub_r(DisasContext
*dc
)
1533 int size
= memsize_zz(dc
);
1534 DIS(fprintf (logfile
, "sub.%c $r%u, $r%u\n",
1535 memsize_char(size
), dc
->op1
, dc
->op2
));
1536 cris_cc_mask(dc
, CC_MASK_NZVC
);
1537 dec_prep_alu_r(dc
, dc
->op1
, dc
->op2
, size
, 0);
1538 crisv32_alu_op(dc
, CC_OP_SUB
, dc
->op2
, size
);
1542 /* Zero extension. From size to dword. */
1543 static unsigned int dec_movu_r(DisasContext
*dc
)
1545 int size
= memsize_z(dc
);
1546 DIS(fprintf (logfile
, "movu.%c $r%u, $r%u\n",
1550 cris_cc_mask(dc
, CC_MASK_NZ
);
1551 dec_prep_move_r(dc
, dc
->op1
, dc
->op2
, size
, 0);
1552 crisv32_alu_op(dc
, CC_OP_MOVE
, dc
->op2
, 4);
1556 /* Sign extension. From size to dword. */
1557 static unsigned int dec_movs_r(DisasContext
*dc
)
1559 int size
= memsize_z(dc
);
1560 DIS(fprintf (logfile
, "movs.%c $r%u, $r%u\n",
1564 cris_cc_mask(dc
, CC_MASK_NZ
);
1565 t_gen_mov_TN_reg(cpu_T
[0], dc
->op1
);
1566 /* Size can only be qi or hi. */
1567 t_gen_sext(cpu_T
[1], cpu_T
[0], size
);
1568 crisv32_alu_op(dc
, CC_OP_MOVE
, dc
->op2
, 4);
1572 /* zero extension. From size to dword. */
1573 static unsigned int dec_addu_r(DisasContext
*dc
)
1575 int size
= memsize_z(dc
);
1576 DIS(fprintf (logfile
, "addu.%c $r%u, $r%u\n",
1580 cris_cc_mask(dc
, CC_MASK_NZVC
);
1581 t_gen_mov_TN_reg(cpu_T
[1], dc
->op1
);
1582 /* Size can only be qi or hi. */
1583 t_gen_zext(cpu_T
[1], cpu_T
[1], size
);
1584 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1585 crisv32_alu_op(dc
, CC_OP_ADD
, dc
->op2
, 4);
1589 /* Sign extension. From size to dword. */
1590 static unsigned int dec_adds_r(DisasContext
*dc
)
1592 int size
= memsize_z(dc
);
1593 DIS(fprintf (logfile
, "adds.%c $r%u, $r%u\n",
1597 cris_cc_mask(dc
, CC_MASK_NZVC
);
1598 t_gen_mov_TN_reg(cpu_T
[1], dc
->op1
);
1599 /* Size can only be qi or hi. */
1600 t_gen_sext(cpu_T
[1], cpu_T
[1], size
);
1601 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1603 crisv32_alu_op(dc
, CC_OP_ADD
, dc
->op2
, 4);
1607 /* Zero extension. From size to dword. */
1608 static unsigned int dec_subu_r(DisasContext
*dc
)
1610 int size
= memsize_z(dc
);
1611 DIS(fprintf (logfile
, "subu.%c $r%u, $r%u\n",
1615 cris_cc_mask(dc
, CC_MASK_NZVC
);
1616 t_gen_mov_TN_reg(cpu_T
[1], dc
->op1
);
1617 /* Size can only be qi or hi. */
1618 t_gen_zext(cpu_T
[1], cpu_T
[1], size
);
1619 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1620 crisv32_alu_op(dc
, CC_OP_SUB
, dc
->op2
, 4);
1624 /* Sign extension. From size to dword. */
1625 static unsigned int dec_subs_r(DisasContext
*dc
)
1627 int size
= memsize_z(dc
);
1628 DIS(fprintf (logfile
, "subs.%c $r%u, $r%u\n",
1632 cris_cc_mask(dc
, CC_MASK_NZVC
);
1633 t_gen_mov_TN_reg(cpu_T
[1], dc
->op1
);
1634 /* Size can only be qi or hi. */
1635 t_gen_sext(cpu_T
[1], cpu_T
[1], size
);
1636 t_gen_mov_TN_reg(cpu_T
[0], dc
->op2
);
1637 crisv32_alu_op(dc
, CC_OP_SUB
, dc
->op2
, 4);
1641 static unsigned int dec_setclrf(DisasContext
*dc
)
1644 int set
= (~dc
->opcode
>> 2) & 1;
1646 flags
= (EXTRACT_FIELD(dc
->ir
, 12, 15) << 4)
1647 | EXTRACT_FIELD(dc
->ir
, 0, 3);
1648 DIS(fprintf (logfile
, "set=%d flags=%x\n", set
, flags
));
1649 if (set
&& flags
== 0)
1650 DIS(fprintf (logfile
, "nop\n"));
1651 else if (!set
&& (flags
& 0x20))
1652 DIS(fprintf (logfile
, "di\n"));
1654 DIS(fprintf (logfile
, "%sf %x\n",
1655 set
? "set" : "clr",
1658 if (set
&& (flags
& X_FLAG
)) {
1663 /* Simply decode the flags. */
1664 cris_evaluate_flags (dc
);
1665 cris_update_cc_op(dc
, CC_OP_FLAGS
, 4);
1666 tcg_gen_movi_tl(cc_op
, dc
->cc_op
);
1677 static unsigned int dec_move_rs(DisasContext
*dc
)
1679 DIS(fprintf (logfile
, "move $r%u, $s%u\n", dc
->op1
, dc
->op2
));
1680 cris_cc_mask(dc
, 0);
1681 t_gen_mov_TN_reg(cpu_T
[0], dc
->op1
);
1682 gen_op_movl_sreg_T0(dc
->op2
);
1684 #if !defined(CONFIG_USER_ONLY)
1686 gen_op_movl_tlb_hi_T0();
1687 else if (dc
->op2
== 5) { /* srs is checked at runtime. */
1688 tcg_gen_helper_0_1(helper_tlb_update
, cpu_T
[0]);
1689 gen_op_movl_tlb_lo_T0();
1694 static unsigned int dec_move_sr(DisasContext
*dc
)
1696 DIS(fprintf (logfile
, "move $s%u, $r%u\n", dc
->op2
, dc
->op1
));
1697 cris_cc_mask(dc
, 0);
1698 gen_op_movl_T0_sreg(dc
->op2
);
1699 tcg_gen_mov_tl(cpu_T
[1], cpu_T
[0]);
1700 crisv32_alu_op(dc
, CC_OP_MOVE
, dc
->op1
, 4);
1703 static unsigned int dec_move_rp(DisasContext
*dc
)
1705 DIS(fprintf (logfile
, "move $r%u, $p%u\n", dc
->op1
, dc
->op2
));
1706 cris_cc_mask(dc
, 0);
1708 if (dc
->op2
== PR_CCS
) {
1709 cris_evaluate_flags(dc
);
1710 t_gen_mov_TN_reg(cpu_T
[0], dc
->op1
);
1712 /* User space is not allowed to touch all flags. */
1713 tcg_gen_andi_tl(cpu_T
[0], cpu_T
[0], 0x39f);
1714 tcg_gen_andi_tl(cpu_T
[1], cpu_PR
[PR_CCS
], ~0x39f);
1715 tcg_gen_or_tl(cpu_T
[0], cpu_T
[1], cpu_T
[0]);
1719 t_gen_mov_TN_reg(cpu_T
[0], dc
->op1
);
1721 t_gen_mov_preg_TN(dc
->op2
, cpu_T
[0]);
1722 if (dc
->op2
== PR_CCS
) {
1723 cris_update_cc_op(dc
, CC_OP_FLAGS
, 4);
1728 static unsigned int dec_move_pr(DisasContext
*dc
)
1730 DIS(fprintf (logfile
, "move $p%u, $r%u\n", dc
->op1
, dc
->op2
));
1731 cris_cc_mask(dc
, 0);
1732 /* Support register 0 is hardwired to zero.
1733 Treat it specially. */
1735 tcg_gen_movi_tl(cpu_T
[1], 0);
1736 else if (dc
->op2
== PR_CCS
) {
1737 cris_evaluate_flags(dc
);
1738 t_gen_mov_TN_preg(cpu_T
[1], dc
->op2
);
1740 t_gen_mov_TN_preg(cpu_T
[1], dc
->op2
);
1741 crisv32_alu_op(dc
, CC_OP_MOVE
, dc
->op1
, preg_sizes
[dc
->op2
]);
1745 static unsigned int dec_move_mr(DisasContext
*dc
)
1747 int memsize
= memsize_zz(dc
);
1749 DIS(fprintf (logfile
, "move.%c [$r%u%s, $r%u\n",
1750 memsize_char(memsize
),
1751 dc
->op1
, dc
->postinc
? "+]" : "]",
1754 insn_len
= dec_prep_alu_m(dc
, 0, memsize
);
1755 cris_cc_mask(dc
, CC_MASK_NZ
);
1756 crisv32_alu_op(dc
, CC_OP_MOVE
, dc
->op2
, memsize
);
1757 do_postinc(dc
, memsize
);
1761 static unsigned int dec_movs_m(DisasContext
*dc
)
1763 int memsize
= memsize_z(dc
);
1765 DIS(fprintf (logfile
, "movs.%c [$r%u%s, $r%u\n",
1766 memsize_char(memsize
),
1767 dc
->op1
, dc
->postinc
? "+]" : "]",
1771 insn_len
= dec_prep_alu_m(dc
, 1, memsize
);
1772 cris_cc_mask(dc
, CC_MASK_NZ
);
1773 crisv32_alu_op(dc
, CC_OP_MOVE
, dc
->op2
, 4);
1774 do_postinc(dc
, memsize
);
1778 static unsigned int dec_addu_m(DisasContext
*dc
)
1780 int memsize
= memsize_z(dc
);
1782 DIS(fprintf (logfile
, "addu.%c [$r%u%s, $r%u\n",
1783 memsize_char(memsize
),
1784 dc
->op1
, dc
->postinc
? "+]" : "]",
1788 insn_len
= dec_prep_alu_m(dc
, 0, memsize
);
1789 cris_cc_mask(dc
, CC_MASK_NZVC
);
1790 crisv32_alu_op(dc
, CC_OP_ADD
, dc
->op2
, 4);
1791 do_postinc(dc
, memsize
);
1795 static unsigned int dec_adds_m(DisasContext
*dc
)
1797 int memsize
= memsize_z(dc
);
1799 DIS(fprintf (logfile
, "adds.%c [$r%u%s, $r%u\n",
1800 memsize_char(memsize
),
1801 dc
->op1
, dc
->postinc
? "+]" : "]",
1805 insn_len
= dec_prep_alu_m(dc
, 1, memsize
);
1806 cris_cc_mask(dc
, CC_MASK_NZVC
);
1807 crisv32_alu_op(dc
, CC_OP_ADD
, dc
->op2
, 4);
1808 do_postinc(dc
, memsize
);
1812 static unsigned int dec_subu_m(DisasContext
*dc
)
1814 int memsize
= memsize_z(dc
);
1816 DIS(fprintf (logfile
, "subu.%c [$r%u%s, $r%u\n",
1817 memsize_char(memsize
),
1818 dc
->op1
, dc
->postinc
? "+]" : "]",
1822 insn_len
= dec_prep_alu_m(dc
, 0, memsize
);
1823 cris_cc_mask(dc
, CC_MASK_NZVC
);
1824 crisv32_alu_op(dc
, CC_OP_SUB
, dc
->op2
, 4);
1825 do_postinc(dc
, memsize
);
1829 static unsigned int dec_subs_m(DisasContext
*dc
)
1831 int memsize
= memsize_z(dc
);
1833 DIS(fprintf (logfile
, "subs.%c [$r%u%s, $r%u\n",
1834 memsize_char(memsize
),
1835 dc
->op1
, dc
->postinc
? "+]" : "]",
1839 insn_len
= dec_prep_alu_m(dc
, 1, memsize
);
1840 cris_cc_mask(dc
, CC_MASK_NZVC
);
1841 crisv32_alu_op(dc
, CC_OP_SUB
, dc
->op2
, 4);
1842 do_postinc(dc
, memsize
);
1846 static unsigned int dec_movu_m(DisasContext
*dc
)
1848 int memsize
= memsize_z(dc
);
1851 DIS(fprintf (logfile
, "movu.%c [$r%u%s, $r%u\n",
1852 memsize_char(memsize
),
1853 dc
->op1
, dc
->postinc
? "+]" : "]",
1856 insn_len
= dec_prep_alu_m(dc
, 0, memsize
);
1857 cris_cc_mask(dc
, CC_MASK_NZ
);
1858 crisv32_alu_op(dc
, CC_OP_MOVE
, dc
->op2
, 4);
1859 do_postinc(dc
, memsize
);
1863 static unsigned int dec_cmpu_m(DisasContext
*dc
)
1865 int memsize
= memsize_z(dc
);
1867 DIS(fprintf (logfile
, "cmpu.%c [$r%u%s, $r%u\n",
1868 memsize_char(memsize
),
1869 dc
->op1
, dc
->postinc
? "+]" : "]",
1872 insn_len
= dec_prep_alu_m(dc
, 0, memsize
);
1873 cris_cc_mask(dc
, CC_MASK_NZVC
);
1874 crisv32_alu_op(dc
, CC_OP_CMP
, dc
->op2
, 4);
1875 do_postinc(dc
, memsize
);
1879 static unsigned int dec_cmps_m(DisasContext
*dc
)
1881 int memsize
= memsize_z(dc
);
1883 DIS(fprintf (logfile
, "cmps.%c [$r%u%s, $r%u\n",
1884 memsize_char(memsize
),
1885 dc
->op1
, dc
->postinc
? "+]" : "]",
1888 insn_len
= dec_prep_alu_m(dc
, 1, memsize
);
1889 cris_cc_mask(dc
, CC_MASK_NZVC
);
1890 crisv32_alu_op(dc
, CC_OP_CMP
, dc
->op2
, memsize_zz(dc
));
1891 do_postinc(dc
, memsize
);
1895 static unsigned int dec_cmp_m(DisasContext
*dc
)
1897 int memsize
= memsize_zz(dc
);
1899 DIS(fprintf (logfile
, "cmp.%c [$r%u%s, $r%u\n",
1900 memsize_char(memsize
),
1901 dc
->op1
, dc
->postinc
? "+]" : "]",
1904 insn_len
= dec_prep_alu_m(dc
, 0, memsize
);
1905 cris_cc_mask(dc
, CC_MASK_NZVC
);
1906 crisv32_alu_op(dc
, CC_OP_CMP
, dc
->op2
, memsize_zz(dc
));
1907 do_postinc(dc
, memsize
);
1911 static unsigned int dec_test_m(DisasContext
*dc
)
1913 int memsize
= memsize_zz(dc
);
1915 DIS(fprintf (logfile
, "test.%d [$r%u%s] op2=%x\n",
1916 memsize_char(memsize
),
1917 dc
->op1
, dc
->postinc
? "+]" : "]",
1920 insn_len
= dec_prep_alu_m(dc
, 0, memsize
);
1921 cris_cc_mask(dc
, CC_MASK_NZ
);
1924 tcg_gen_mov_tl(cpu_T
[0], cpu_T
[1]);
1925 tcg_gen_movi_tl(cpu_T
[1], 0);
1926 crisv32_alu_op(dc
, CC_OP_CMP
, dc
->op2
, memsize_zz(dc
));
1927 do_postinc(dc
, memsize
);
1931 static unsigned int dec_and_m(DisasContext
*dc
)
1933 int memsize
= memsize_zz(dc
);
1935 DIS(fprintf (logfile
, "and.%d [$r%u%s, $r%u\n",
1936 memsize_char(memsize
),
1937 dc
->op1
, dc
->postinc
? "+]" : "]",
1940 insn_len
= dec_prep_alu_m(dc
, 0, memsize
);
1941 cris_cc_mask(dc
, CC_MASK_NZ
);
1942 crisv32_alu_op(dc
, CC_OP_AND
, dc
->op2
, memsize_zz(dc
));
1943 do_postinc(dc
, memsize
);
1947 static unsigned int dec_add_m(DisasContext
*dc
)
1949 int memsize
= memsize_zz(dc
);
1951 DIS(fprintf (logfile
, "add.%d [$r%u%s, $r%u\n",
1952 memsize_char(memsize
),
1953 dc
->op1
, dc
->postinc
? "+]" : "]",
1956 insn_len
= dec_prep_alu_m(dc
, 0, memsize
);
1957 cris_cc_mask(dc
, CC_MASK_NZVC
);
1958 crisv32_alu_op(dc
, CC_OP_ADD
, dc
->op2
, memsize_zz(dc
));
1959 do_postinc(dc
, memsize
);
1963 static unsigned int dec_addo_m(DisasContext
*dc
)
1965 int memsize
= memsize_zz(dc
);
1967 DIS(fprintf (logfile
, "add.%d [$r%u%s, $r%u\n",
1968 memsize_char(memsize
),
1969 dc
->op1
, dc
->postinc
? "+]" : "]",
1972 insn_len
= dec_prep_alu_m(dc
, 1, memsize
);
1973 cris_cc_mask(dc
, 0);
1974 crisv32_alu_op(dc
, CC_OP_ADD
, R_ACR
, 4);
1975 do_postinc(dc
, memsize
);
1979 static unsigned int dec_bound_m(DisasContext
*dc
)
1981 int memsize
= memsize_zz(dc
);
1983 DIS(fprintf (logfile
, "bound.%d [$r%u%s, $r%u\n",
1984 memsize_char(memsize
),
1985 dc
->op1
, dc
->postinc
? "+]" : "]",
1988 insn_len
= dec_prep_alu_m(dc
, 0, memsize
);
1989 cris_cc_mask(dc
, CC_MASK_NZ
);
1990 crisv32_alu_op(dc
, CC_OP_BOUND
, dc
->op2
, 4);
1991 do_postinc(dc
, memsize
);
1995 static unsigned int dec_addc_mr(DisasContext
*dc
)
1998 DIS(fprintf (logfile
, "addc [$r%u%s, $r%u\n",
1999 dc
->op1
, dc
->postinc
? "+]" : "]",
2002 cris_evaluate_flags(dc
);
2003 insn_len
= dec_prep_alu_m(dc
, 0, 4);
2004 cris_cc_mask(dc
, CC_MASK_NZVC
);
2005 crisv32_alu_op(dc
, CC_OP_ADDC
, dc
->op2
, 4);
2010 static unsigned int dec_sub_m(DisasContext
*dc
)
2012 int memsize
= memsize_zz(dc
);
2014 DIS(fprintf (logfile
, "sub.%c [$r%u%s, $r%u ir=%x zz=%x\n",
2015 memsize_char(memsize
),
2016 dc
->op1
, dc
->postinc
? "+]" : "]",
2017 dc
->op2
, dc
->ir
, dc
->zzsize
));
2019 insn_len
= dec_prep_alu_m(dc
, 0, memsize
);
2020 cris_cc_mask(dc
, CC_MASK_NZVC
);
2021 crisv32_alu_op(dc
, CC_OP_SUB
, dc
->op2
, memsize
);
2022 do_postinc(dc
, memsize
);
2026 static unsigned int dec_or_m(DisasContext
*dc
)
2028 int memsize
= memsize_zz(dc
);
2030 DIS(fprintf (logfile
, "or.%d [$r%u%s, $r%u pc=%x\n",
2031 memsize_char(memsize
),
2032 dc
->op1
, dc
->postinc
? "+]" : "]",
2035 insn_len
= dec_prep_alu_m(dc
, 0, memsize
);
2036 cris_cc_mask(dc
, CC_MASK_NZ
);
2037 crisv32_alu_op(dc
, CC_OP_OR
, dc
->op2
, memsize_zz(dc
));
2038 do_postinc(dc
, memsize
);
2042 static unsigned int dec_move_mp(DisasContext
*dc
)
2044 int memsize
= memsize_zz(dc
);
2047 DIS(fprintf (logfile
, "move.%c [$r%u%s, $p%u\n",
2048 memsize_char(memsize
),
2050 dc
->postinc
? "+]" : "]",
2053 insn_len
= dec_prep_alu_m(dc
, 0, memsize
);
2054 cris_cc_mask(dc
, 0);
2055 if (dc
->op2
== PR_CCS
) {
2056 cris_evaluate_flags(dc
);
2058 /* User space is not allowed to touch all flags. */
2059 tcg_gen_andi_tl(cpu_T
[1], cpu_T
[1], 0x39f);
2060 tcg_gen_andi_tl(cpu_T
[0], cpu_PR
[PR_CCS
], ~0x39f);
2061 tcg_gen_or_tl(cpu_T
[1], cpu_T
[0], cpu_T
[1]);
2065 t_gen_mov_preg_TN(dc
->op2
, cpu_T
[1]);
2067 do_postinc(dc
, memsize
);
2071 static unsigned int dec_move_pm(DisasContext
*dc
)
2075 memsize
= preg_sizes
[dc
->op2
];
2077 DIS(fprintf (logfile
, "move.%c $p%u, [$r%u%s\n",
2078 memsize_char(memsize
),
2079 dc
->op2
, dc
->op1
, dc
->postinc
? "+]" : "]"));
2081 /* prepare store. Address in T0, value in T1. */
2082 t_gen_mov_TN_preg(cpu_T
[1], dc
->op2
);
2083 t_gen_mov_TN_reg(cpu_T
[0], dc
->op1
);
2084 gen_store_T0_T1(dc
, memsize
);
2085 cris_cc_mask(dc
, 0);
2088 tcg_gen_addi_tl(cpu_T
[0], cpu_T
[0], memsize
);
2089 t_gen_mov_reg_TN(dc
->op1
, cpu_T
[0]);
2094 static unsigned int dec_movem_mr(DisasContext
*dc
)
2098 DIS(fprintf (logfile
, "movem [$r%u%s, $r%u\n", dc
->op1
,
2099 dc
->postinc
? "+]" : "]", dc
->op2
));
2101 /* fetch the address into T0 and T1. */
2102 t_gen_mov_TN_reg(cpu_T
[1], dc
->op1
);
2103 for (i
= 0; i
<= dc
->op2
; i
++) {
2104 /* Perform the load onto regnum i. Always dword wide. */
2105 tcg_gen_mov_tl(cpu_T
[0], cpu_T
[1]);
2106 gen_load(dc
, cpu_R
[i
], cpu_T
[1], 4, 0);
2107 tcg_gen_addi_tl(cpu_T
[1], cpu_T
[1], 4);
2109 /* writeback the updated pointer value. */
2111 t_gen_mov_reg_TN(dc
->op1
, cpu_T
[1]);
2113 /* gen_load might want to evaluate the previous insns flags. */
2114 cris_cc_mask(dc
, 0);
2118 static unsigned int dec_movem_rm(DisasContext
*dc
)
2122 DIS(fprintf (logfile
, "movem $r%u, [$r%u%s\n", dc
->op2
, dc
->op1
,
2123 dc
->postinc
? "+]" : "]"));
2125 for (i
= 0; i
<= dc
->op2
; i
++) {
2126 /* Fetch register i into T1. */
2127 t_gen_mov_TN_reg(cpu_T
[1], i
);
2128 /* Fetch the address into T0. */
2129 t_gen_mov_TN_reg(cpu_T
[0], dc
->op1
);
2131 tcg_gen_addi_tl(cpu_T
[0], cpu_T
[0], i
* 4);
2132 /* Perform the store. */
2133 gen_store_T0_T1(dc
, 4);
2136 /* T0 should point to the last written addr, advance one more
2138 tcg_gen_addi_tl(cpu_T
[0], cpu_T
[0], 4);
2139 /* writeback the updated pointer value. */
2140 t_gen_mov_reg_TN(dc
->op1
, cpu_T
[0]);
2142 cris_cc_mask(dc
, 0);
2146 static unsigned int dec_move_rm(DisasContext
*dc
)
2150 memsize
= memsize_zz(dc
);
2152 DIS(fprintf (logfile
, "move.%d $r%u, [$r%u]\n",
2153 memsize
, dc
->op2
, dc
->op1
));
2155 /* prepare store. */
2156 t_gen_mov_TN_reg(cpu_T
[0], dc
->op1
);
2157 t_gen_mov_TN_reg(cpu_T
[1], dc
->op2
);
2158 gen_store_T0_T1(dc
, memsize
);
2161 tcg_gen_addi_tl(cpu_T
[0], cpu_T
[0], memsize
);
2162 t_gen_mov_reg_TN(dc
->op1
, cpu_T
[0]);
2164 cris_cc_mask(dc
, 0);
2168 static unsigned int dec_lapcq(DisasContext
*dc
)
2170 DIS(fprintf (logfile
, "lapcq %x, $r%u\n",
2171 dc
->pc
+ dc
->op1
*2, dc
->op2
));
2172 cris_cc_mask(dc
, 0);
2173 tcg_gen_movi_tl(cpu_T
[1], dc
->pc
+ dc
->op1
* 2);
2174 crisv32_alu_op(dc
, CC_OP_MOVE
, dc
->op2
, 4);
2178 static unsigned int dec_lapc_im(DisasContext
*dc
)
2186 cris_cc_mask(dc
, 0);
2187 imm
= ldl_code(dc
->pc
+ 2);
2188 DIS(fprintf (logfile
, "lapc 0x%x, $r%u\n", imm
+ dc
->pc
, dc
->op2
));
2192 t_gen_mov_reg_TN(rd
, tcg_const_tl(pc
));
2196 /* Jump to special reg. */
2197 static unsigned int dec_jump_p(DisasContext
*dc
)
2199 DIS(fprintf (logfile
, "jump $p%u\n", dc
->op2
));
2200 cris_cc_mask(dc
, 0);
2202 t_gen_mov_TN_preg(cpu_T
[0], dc
->op2
);
2203 /* rete will often have low bit set to indicate delayslot. */
2204 tcg_gen_andi_tl(env_btarget
, cpu_T
[0], ~1);
2205 cris_prepare_dyn_jmp(dc
);
2209 /* Jump and save. */
2210 static unsigned int dec_jas_r(DisasContext
*dc
)
2212 DIS(fprintf (logfile
, "jas $r%u, $p%u\n", dc
->op1
, dc
->op2
));
2213 cris_cc_mask(dc
, 0);
2214 /* Store the return address in Pd. */
2215 tcg_gen_mov_tl(env_btarget
, cpu_R
[dc
->op1
]);
2218 tcg_gen_movi_tl(cpu_PR
[dc
->op2
], dc
->pc
+ 4);
2220 cris_prepare_dyn_jmp(dc
);
2224 static unsigned int dec_jas_im(DisasContext
*dc
)
2228 imm
= ldl_code(dc
->pc
+ 2);
2230 DIS(fprintf (logfile
, "jas 0x%x\n", imm
));
2231 cris_cc_mask(dc
, 0);
2232 /* Stor the return address in Pd. */
2233 tcg_gen_movi_tl(env_btarget
, imm
);
2234 t_gen_mov_preg_TN(dc
->op2
, tcg_const_tl(dc
->pc
+ 8));
2235 cris_prepare_dyn_jmp(dc
);
2239 static unsigned int dec_jasc_im(DisasContext
*dc
)
2243 imm
= ldl_code(dc
->pc
+ 2);
2245 DIS(fprintf (logfile
, "jasc 0x%x\n", imm
));
2246 cris_cc_mask(dc
, 0);
2247 /* Stor the return address in Pd. */
2248 tcg_gen_movi_tl(cpu_T
[0], imm
);
2249 t_gen_mov_env_TN(btarget
, cpu_T
[0]);
2250 tcg_gen_movi_tl(cpu_T
[0], dc
->pc
+ 8 + 4);
2251 t_gen_mov_preg_TN(dc
->op2
, cpu_T
[0]);
2252 cris_prepare_dyn_jmp(dc
);
2256 static unsigned int dec_jasc_r(DisasContext
*dc
)
2258 DIS(fprintf (logfile
, "jasc_r $r%u, $p%u\n", dc
->op1
, dc
->op2
));
2259 cris_cc_mask(dc
, 0);
2260 /* Stor the return address in Pd. */
2261 t_gen_mov_TN_reg(cpu_T
[0], dc
->op1
);
2262 t_gen_mov_env_TN(btarget
, cpu_T
[0]);
2263 tcg_gen_movi_tl(cpu_T
[0], dc
->pc
+ 4 + 4);
2264 t_gen_mov_preg_TN(dc
->op2
, cpu_T
[0]);
2265 cris_prepare_dyn_jmp(dc
);
2269 static unsigned int dec_bcc_im(DisasContext
*dc
)
2272 uint32_t cond
= dc
->op2
;
2274 offset
= ldl_code(dc
->pc
+ 2);
2275 offset
= sign_extend(offset
, 15);
2277 DIS(fprintf (logfile
, "b%s %d pc=%x dst=%x\n",
2278 cc_name(cond
), offset
,
2279 dc
->pc
, dc
->pc
+ offset
));
2281 cris_cc_mask(dc
, 0);
2282 /* op2 holds the condition-code. */
2283 cris_prepare_cc_branch (dc
, offset
, cond
);
2287 static unsigned int dec_bas_im(DisasContext
*dc
)
2292 simm
= ldl_code(dc
->pc
+ 2);
2294 DIS(fprintf (logfile
, "bas 0x%x, $p%u\n", dc
->pc
+ simm
, dc
->op2
));
2295 cris_cc_mask(dc
, 0);
2296 /* Stor the return address in Pd. */
2297 tcg_gen_movi_tl(cpu_T
[0], dc
->pc
+ simm
);
2298 t_gen_mov_env_TN(btarget
, cpu_T
[0]);
2299 tcg_gen_movi_tl(cpu_T
[0], dc
->pc
+ 8);
2300 t_gen_mov_preg_TN(dc
->op2
, cpu_T
[0]);
2301 cris_prepare_dyn_jmp(dc
);
2305 static unsigned int dec_basc_im(DisasContext
*dc
)
2308 simm
= ldl_code(dc
->pc
+ 2);
2310 DIS(fprintf (logfile
, "basc 0x%x, $p%u\n", dc
->pc
+ simm
, dc
->op2
));
2311 cris_cc_mask(dc
, 0);
2312 /* Stor the return address in Pd. */
2313 tcg_gen_movi_tl(cpu_T
[0], dc
->pc
+ simm
);
2314 t_gen_mov_env_TN(btarget
, cpu_T
[0]);
2315 tcg_gen_movi_tl(cpu_T
[0], dc
->pc
+ 12);
2316 t_gen_mov_preg_TN(dc
->op2
, cpu_T
[0]);
2317 cris_prepare_dyn_jmp(dc
);
2321 static unsigned int dec_rfe_etc(DisasContext
*dc
)
2323 DIS(fprintf (logfile
, "rfe_etc opc=%x pc=0x%x op1=%d op2=%d\n",
2324 dc
->opcode
, dc
->pc
, dc
->op1
, dc
->op2
));
2326 cris_cc_mask(dc
, 0);
2328 if (dc
->op2
== 15) /* ignore halt. */
2331 switch (dc
->op2
& 7) {
2334 cris_evaluate_flags(dc
);
2335 gen_op_ccs_rshift();
2336 /* FIXME: don't set the P-FLAG if R is set. */
2337 tcg_gen_ori_tl(cpu_PR
[PR_CCS
], cpu_PR
[PR_CCS
], P_FLAG
);
2339 tcg_gen_helper_0_0(helper_rfe
);
2340 dc
->is_jmp
= DISAS_UPDATE
;
2348 tcg_gen_movi_tl(cpu_T
[0], dc
->pc
);
2349 t_gen_mov_env_TN(pc
, cpu_T
[0]);
2350 /* Breaks start at 16 in the exception vector. */
2351 gen_op_break_im(dc
->op1
+ 16);
2352 dc
->is_jmp
= DISAS_UPDATE
;
2355 printf ("op2=%x\n", dc
->op2
);
2363 static unsigned int dec_ftag_fidx_d_m(DisasContext
*dc
)
2365 /* Ignore D-cache flushes. */
2369 static unsigned int dec_ftag_fidx_i_m(DisasContext
*dc
)
2371 /* Ignore I-cache flushes. */
2375 static unsigned int dec_null(DisasContext
*dc
)
2377 printf ("unknown insn pc=%x opc=%x op1=%x op2=%x\n",
2378 dc
->pc
, dc
->opcode
, dc
->op1
, dc
->op2
);
2384 struct decoder_info
{
2389 unsigned int (*dec
)(DisasContext
*dc
);
2391 /* Order matters here. */
2392 {DEC_MOVEQ
, dec_moveq
},
2393 {DEC_BTSTQ
, dec_btstq
},
2394 {DEC_CMPQ
, dec_cmpq
},
2395 {DEC_ADDOQ
, dec_addoq
},
2396 {DEC_ADDQ
, dec_addq
},
2397 {DEC_SUBQ
, dec_subq
},
2398 {DEC_ANDQ
, dec_andq
},
2400 {DEC_ASRQ
, dec_asrq
},
2401 {DEC_LSLQ
, dec_lslq
},
2402 {DEC_LSRQ
, dec_lsrq
},
2403 {DEC_BCCQ
, dec_bccq
},
2405 {DEC_BCC_IM
, dec_bcc_im
},
2406 {DEC_JAS_IM
, dec_jas_im
},
2407 {DEC_JAS_R
, dec_jas_r
},
2408 {DEC_JASC_IM
, dec_jasc_im
},
2409 {DEC_JASC_R
, dec_jasc_r
},
2410 {DEC_BAS_IM
, dec_bas_im
},
2411 {DEC_BASC_IM
, dec_basc_im
},
2412 {DEC_JUMP_P
, dec_jump_p
},
2413 {DEC_LAPC_IM
, dec_lapc_im
},
2414 {DEC_LAPCQ
, dec_lapcq
},
2416 {DEC_RFE_ETC
, dec_rfe_etc
},
2417 {DEC_ADDC_MR
, dec_addc_mr
},
2419 {DEC_MOVE_MP
, dec_move_mp
},
2420 {DEC_MOVE_PM
, dec_move_pm
},
2421 {DEC_MOVEM_MR
, dec_movem_mr
},
2422 {DEC_MOVEM_RM
, dec_movem_rm
},
2423 {DEC_MOVE_PR
, dec_move_pr
},
2424 {DEC_SCC_R
, dec_scc_r
},
2425 {DEC_SETF
, dec_setclrf
},
2426 {DEC_CLEARF
, dec_setclrf
},
2428 {DEC_MOVE_SR
, dec_move_sr
},
2429 {DEC_MOVE_RP
, dec_move_rp
},
2430 {DEC_SWAP_R
, dec_swap_r
},
2431 {DEC_ABS_R
, dec_abs_r
},
2432 {DEC_LZ_R
, dec_lz_r
},
2433 {DEC_MOVE_RS
, dec_move_rs
},
2434 {DEC_BTST_R
, dec_btst_r
},
2435 {DEC_ADDC_R
, dec_addc_r
},
2437 {DEC_DSTEP_R
, dec_dstep_r
},
2438 {DEC_XOR_R
, dec_xor_r
},
2439 {DEC_MCP_R
, dec_mcp_r
},
2440 {DEC_CMP_R
, dec_cmp_r
},
2442 {DEC_ADDI_R
, dec_addi_r
},
2443 {DEC_ADDI_ACR
, dec_addi_acr
},
2445 {DEC_ADD_R
, dec_add_r
},
2446 {DEC_SUB_R
, dec_sub_r
},
2448 {DEC_ADDU_R
, dec_addu_r
},
2449 {DEC_ADDS_R
, dec_adds_r
},
2450 {DEC_SUBU_R
, dec_subu_r
},
2451 {DEC_SUBS_R
, dec_subs_r
},
2452 {DEC_LSL_R
, dec_lsl_r
},
2454 {DEC_AND_R
, dec_and_r
},
2455 {DEC_OR_R
, dec_or_r
},
2456 {DEC_BOUND_R
, dec_bound_r
},
2457 {DEC_ASR_R
, dec_asr_r
},
2458 {DEC_LSR_R
, dec_lsr_r
},
2460 {DEC_MOVU_R
, dec_movu_r
},
2461 {DEC_MOVS_R
, dec_movs_r
},
2462 {DEC_NEG_R
, dec_neg_r
},
2463 {DEC_MOVE_R
, dec_move_r
},
2465 {DEC_FTAG_FIDX_I_M
, dec_ftag_fidx_i_m
},
2466 {DEC_FTAG_FIDX_D_M
, dec_ftag_fidx_d_m
},
2468 {DEC_MULS_R
, dec_muls_r
},
2469 {DEC_MULU_R
, dec_mulu_r
},
2471 {DEC_ADDU_M
, dec_addu_m
},
2472 {DEC_ADDS_M
, dec_adds_m
},
2473 {DEC_SUBU_M
, dec_subu_m
},
2474 {DEC_SUBS_M
, dec_subs_m
},
2476 {DEC_CMPU_M
, dec_cmpu_m
},
2477 {DEC_CMPS_M
, dec_cmps_m
},
2478 {DEC_MOVU_M
, dec_movu_m
},
2479 {DEC_MOVS_M
, dec_movs_m
},
2481 {DEC_CMP_M
, dec_cmp_m
},
2482 {DEC_ADDO_M
, dec_addo_m
},
2483 {DEC_BOUND_M
, dec_bound_m
},
2484 {DEC_ADD_M
, dec_add_m
},
2485 {DEC_SUB_M
, dec_sub_m
},
2486 {DEC_AND_M
, dec_and_m
},
2487 {DEC_OR_M
, dec_or_m
},
2488 {DEC_MOVE_RM
, dec_move_rm
},
2489 {DEC_TEST_M
, dec_test_m
},
2490 {DEC_MOVE_MR
, dec_move_mr
},
2495 static inline unsigned int
2496 cris_decoder(DisasContext
*dc
)
2498 unsigned int insn_len
= 2;
2502 /* Load a halfword onto the instruction register. */
2503 tmp
= ldl_code(dc
->pc
);
2504 dc
->ir
= tmp
& 0xffff;
2506 /* Now decode it. */
2507 dc
->opcode
= EXTRACT_FIELD(dc
->ir
, 4, 11);
2508 dc
->op1
= EXTRACT_FIELD(dc
->ir
, 0, 3);
2509 dc
->op2
= EXTRACT_FIELD(dc
->ir
, 12, 15);
2510 dc
->zsize
= EXTRACT_FIELD(dc
->ir
, 4, 4);
2511 dc
->zzsize
= EXTRACT_FIELD(dc
->ir
, 4, 5);
2512 dc
->postinc
= EXTRACT_FIELD(dc
->ir
, 10, 10);
2514 /* Large switch for all insns. */
2515 for (i
= 0; i
< sizeof decinfo
/ sizeof decinfo
[0]; i
++) {
2516 if ((dc
->opcode
& decinfo
[i
].mask
) == decinfo
[i
].bits
)
2518 insn_len
= decinfo
[i
].dec(dc
);
2526 static void check_breakpoint(CPUState
*env
, DisasContext
*dc
)
2529 if (env
->nb_breakpoints
> 0) {
2530 for(j
= 0; j
< env
->nb_breakpoints
; j
++) {
2531 if (env
->breakpoints
[j
] == dc
->pc
) {
2532 cris_evaluate_flags (dc
);
2533 tcg_gen_movi_tl(cpu_T
[0], dc
->pc
);
2534 t_gen_mov_env_TN(pc
, cpu_T
[0]);
2536 dc
->is_jmp
= DISAS_UPDATE
;
2542 /* generate intermediate code for basic block 'tb'. */
2543 struct DisasContext ctx
;
2545 gen_intermediate_code_internal(CPUState
*env
, TranslationBlock
*tb
,
2548 uint16_t *gen_opc_end
;
2550 unsigned int insn_len
;
2552 struct DisasContext
*dc
= &ctx
;
2553 uint32_t next_page_start
;
2559 cpu_abort(env
, "unaligned pc=%x erp=%x\n",
2560 env
->pc
, env
->pregs
[PR_ERP
]);
2565 gen_opc_end
= gen_opc_buf
+ OPC_MAX_SIZE
;
2567 dc
->is_jmp
= DISAS_NEXT
;
2570 dc
->singlestep_enabled
= env
->singlestep_enabled
;
2575 cris_update_cc_op(dc
, CC_OP_FLAGS
, 4);
2577 dc
->user
= env
->pregs
[PR_CCS
] & U_FLAG
;
2578 dc
->delayed_branch
= 0;
2580 if (loglevel
& CPU_LOG_TB_IN_ASM
) {
2582 "search=%d pc=%x ccs=%x pid=%x usp=%x\n"
2587 search_pc
, env
->pc
, env
->pregs
[PR_CCS
],
2588 env
->pregs
[PR_PID
], env
->pregs
[PR_USP
],
2589 env
->regs
[0], env
->regs
[1], env
->regs
[2], env
->regs
[3],
2590 env
->regs
[4], env
->regs
[5], env
->regs
[6], env
->regs
[7],
2591 env
->regs
[8], env
->regs
[9],
2592 env
->regs
[10], env
->regs
[11],
2593 env
->regs
[12], env
->regs
[13],
2594 env
->regs
[14], env
->regs
[15]);
2598 next_page_start
= (pc_start
& TARGET_PAGE_MASK
) + TARGET_PAGE_SIZE
;
2602 check_breakpoint(env
, dc
);
2603 if (dc
->is_jmp
== DISAS_JUMP
2604 || dc
->is_jmp
== DISAS_SWI
)
2608 j
= gen_opc_ptr
- gen_opc_buf
;
2612 gen_opc_instr_start
[lj
++] = 0;
2614 if (dc
->delayed_branch
== 1) {
2615 gen_opc_pc
[lj
] = dc
->ppc
| 1;
2616 gen_opc_instr_start
[lj
] = 0;
2619 gen_opc_pc
[lj
] = dc
->pc
;
2620 gen_opc_instr_start
[lj
] = 1;
2625 insn_len
= cris_decoder(dc
);
2626 STATS(gen_op_exec_insn());
2630 cris_clear_x_flag(dc
);
2632 /* Check for delayed branches here. If we do it before
2633 actually genereating any host code, the simulator will just
2634 loop doing nothing for on this program location. */
2635 if (dc
->delayed_branch
) {
2636 dc
->delayed_branch
--;
2637 if (dc
->delayed_branch
== 0)
2639 if (dc
->bcc
== CC_A
) {
2641 dc
->is_jmp
= DISAS_JUMP
;
2644 /* Conditional jmp. */
2645 gen_op_cc_jmp (dc
->delayed_pc
, dc
->pc
);
2646 dc
->is_jmp
= DISAS_JUMP
;
2651 if (env
->singlestep_enabled
)
2653 } while (!dc
->is_jmp
&& gen_opc_ptr
< gen_opc_end
2654 && ((dc
->pc
< next_page_start
) || dc
->delayed_branch
));
2656 if (dc
->delayed_branch
== 1) {
2657 /* Reexecute the last insn. */
2662 D(printf("!jmp pc=%x jmp=%d db=%d\n", dc
->pc
,
2663 dc
->is_jmp
, dc
->delayed_branch
));
2664 /* T0 and env_pc should hold the new pc. */
2665 tcg_gen_movi_tl(cpu_T
[0], dc
->pc
);
2666 tcg_gen_mov_tl(env_pc
, cpu_T
[0]);
2669 cris_evaluate_flags (dc
);
2671 if (__builtin_expect(env
->singlestep_enabled
, 0)) {
2674 switch(dc
->is_jmp
) {
2676 gen_goto_tb(dc
, 1, dc
->pc
);
2681 /* indicate that the hash table must be used
2682 to find the next TB */
2687 /* nothing more to generate */
2691 *gen_opc_ptr
= INDEX_op_end
;
2693 j
= gen_opc_ptr
- gen_opc_buf
;
2696 gen_opc_instr_start
[lj
++] = 0;
2698 tb
->size
= dc
->pc
- pc_start
;
2702 if (loglevel
& CPU_LOG_TB_IN_ASM
) {
2703 fprintf(logfile
, "--------------\n");
2704 fprintf(logfile
, "IN: %s\n", lookup_symbol(pc_start
));
2705 target_disas(logfile
, pc_start
, dc
->pc
+ 4 - pc_start
, 0);
2706 fprintf(logfile
, "\nisize=%d osize=%d\n",
2707 dc
->pc
- pc_start
, gen_opc_ptr
- gen_opc_buf
);
2713 int gen_intermediate_code (CPUState
*env
, struct TranslationBlock
*tb
)
2715 return gen_intermediate_code_internal(env
, tb
, 0);
2718 int gen_intermediate_code_pc (CPUState
*env
, struct TranslationBlock
*tb
)
2720 return gen_intermediate_code_internal(env
, tb
, 1);
2723 void cpu_dump_state (CPUState
*env
, FILE *f
,
2724 int (*cpu_fprintf
)(FILE *f
, const char *fmt
, ...),
2733 cpu_fprintf(f
, "PC=%x CCS=%x btaken=%d btarget=%x\n"
2734 "cc_op=%d cc_src=%d cc_dest=%d cc_result=%x cc_mask=%x\n"
2736 env
->pc
, env
->pregs
[PR_CCS
], env
->btaken
, env
->btarget
,
2738 env
->cc_src
, env
->cc_dest
, env
->cc_result
, env
->cc_mask
,
2739 env
->debug1
, env
->debug2
, env
->debug3
);
2741 for (i
= 0; i
< 16; i
++) {
2742 cpu_fprintf(f
, "r%2.2d=%8.8x ", i
, env
->regs
[i
]);
2743 if ((i
+ 1) % 4 == 0)
2744 cpu_fprintf(f
, "\n");
2746 cpu_fprintf(f
, "\nspecial regs:\n");
2747 for (i
= 0; i
< 16; i
++) {
2748 cpu_fprintf(f
, "p%2.2d=%8.8x ", i
, env
->pregs
[i
]);
2749 if ((i
+ 1) % 4 == 0)
2750 cpu_fprintf(f
, "\n");
2752 srs
= env
->pregs
[PR_SRS
];
2753 cpu_fprintf(f
, "\nsupport function regs bank %x:\n", srs
);
2755 for (i
= 0; i
< 16; i
++) {
2756 cpu_fprintf(f
, "s%2.2d=%8.8x ",
2757 i
, env
->sregs
[srs
][i
]);
2758 if ((i
+ 1) % 4 == 0)
2759 cpu_fprintf(f
, "\n");
2762 cpu_fprintf(f
, "\n\n");
2766 static void tcg_macro_func(TCGContext
*s
, int macro_id
, const int *dead_args
)
2770 CPUCRISState
*cpu_cris_init (const char *cpu_model
)
2775 env
= qemu_mallocz(sizeof(CPUCRISState
));
2780 tcg_set_macro_func(&tcg_ctx
, tcg_macro_func
);
2781 cpu_env
= tcg_global_reg_new(TCG_TYPE_PTR
, TCG_AREG0
, "env");
2782 #if TARGET_LONG_BITS > HOST_LONG_BITS
2783 cpu_T
[0] = tcg_global_mem_new(TCG_TYPE_TL
,
2784 TCG_AREG0
, offsetof(CPUState
, t0
), "T0");
2785 cpu_T
[1] = tcg_global_mem_new(TCG_TYPE_TL
,
2786 TCG_AREG0
, offsetof(CPUState
, t1
), "T1");
2788 cpu_T
[0] = tcg_global_reg_new(TCG_TYPE_TL
, TCG_AREG1
, "T0");
2789 cpu_T
[1] = tcg_global_reg_new(TCG_TYPE_TL
, TCG_AREG2
, "T1");
2792 cc_src
= tcg_global_mem_new(TCG_TYPE_PTR
, TCG_AREG0
,
2793 offsetof(CPUState
, cc_src
), "cc_src");
2794 cc_dest
= tcg_global_mem_new(TCG_TYPE_PTR
, TCG_AREG0
,
2795 offsetof(CPUState
, cc_dest
),
2797 cc_result
= tcg_global_mem_new(TCG_TYPE_PTR
, TCG_AREG0
,
2798 offsetof(CPUState
, cc_result
),
2800 cc_op
= tcg_global_mem_new(TCG_TYPE_PTR
, TCG_AREG0
,
2801 offsetof(CPUState
, cc_op
), "cc_op");
2802 cc_size
= tcg_global_mem_new(TCG_TYPE_PTR
, TCG_AREG0
,
2803 offsetof(CPUState
, cc_size
),
2805 cc_mask
= tcg_global_mem_new(TCG_TYPE_PTR
, TCG_AREG0
,
2806 offsetof(CPUState
, cc_mask
),
2809 env_pc
= tcg_global_mem_new(TCG_TYPE_PTR
, TCG_AREG0
,
2810 offsetof(CPUState
, pc
),
2812 env_btarget
= tcg_global_mem_new(TCG_TYPE_PTR
, TCG_AREG0
,
2813 offsetof(CPUState
, btarget
),
2816 for (i
= 0; i
< 16; i
++) {
2817 cpu_R
[i
] = tcg_global_mem_new(TCG_TYPE_PTR
, TCG_AREG0
,
2818 offsetof(CPUState
, regs
[i
]),
2821 for (i
= 0; i
< 16; i
++) {
2822 cpu_PR
[i
] = tcg_global_mem_new(TCG_TYPE_PTR
, TCG_AREG0
,
2823 offsetof(CPUState
, pregs
[i
]),
2827 TCG_HELPER(helper_tlb_update
);
2828 TCG_HELPER(helper_tlb_flush
);
2829 TCG_HELPER(helper_rfe
);
2830 TCG_HELPER(helper_store
);
2831 TCG_HELPER(helper_dump
);
2832 TCG_HELPER(helper_dummy
);
2834 TCG_HELPER(helper_evaluate_flags_muls
);
2835 TCG_HELPER(helper_evaluate_flags_mulu
);
2836 TCG_HELPER(helper_evaluate_flags_mcp
);
2837 TCG_HELPER(helper_evaluate_flags_alu_4
);
2838 TCG_HELPER(helper_evaluate_flags_move_4
);
2839 TCG_HELPER(helper_evaluate_flags_move_2
);
2840 TCG_HELPER(helper_evaluate_flags
);
2846 void cpu_reset (CPUCRISState
*env
)
2848 memset(env
, 0, offsetof(CPUCRISState
, breakpoints
));
2851 #if defined(CONFIG_USER_ONLY)
2852 /* start in user mode with interrupts enabled. */
2853 env
->pregs
[PR_CCS
] |= U_FLAG
| I_FLAG
;
2855 env
->pregs
[PR_CCS
] = 0;
2859 void gen_pc_load(CPUState
*env
, struct TranslationBlock
*tb
,
2860 unsigned long searched_pc
, int pc_pos
, void *puc
)
2862 env
->pc
= gen_opc_pc
[pc_pos
];