2 * Xilinx MicroBlaze emulation for qemu: main translation routines.
4 * Copyright (c) 2009 Edgar E. Iglesias.
5 * Copyright (c) 2009-2012 PetaLogix Qld Pty Ltd.
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, see <http://www.gnu.org/licenses/>.
22 #include "disas/disas.h"
25 #include "microblaze-decode.h"
33 #if DISAS_MB && !SIM_COMPAT
34 # define LOG_DIS(...) qemu_log_mask(CPU_LOG_TB_IN_ASM, ## __VA_ARGS__)
36 # define LOG_DIS(...) do { } while (0)
41 #define EXTRACT_FIELD(src, start, end) \
42 (((src) >> start) & ((1 << (end - start + 1)) - 1))
44 static TCGv env_debug
;
45 static TCGv_ptr cpu_env
;
46 static TCGv cpu_R
[32];
47 static TCGv cpu_SR
[18];
49 static TCGv env_btaken
;
50 static TCGv env_btarget
;
51 static TCGv env_iflags
;
53 #include "exec/gen-icount.h"
55 /* This is the state at translation time. */
56 typedef struct DisasContext
{
67 unsigned int cpustate_changed
;
68 unsigned int delayed_branch
;
69 unsigned int tb_flags
, synced_flags
; /* tb dependent flags. */
70 unsigned int clear_imm
;
75 #define JMP_DIRECT_CC 2
76 #define JMP_INDIRECT 3
80 int abort_at_next_insn
;
82 struct TranslationBlock
*tb
;
83 int singlestep_enabled
;
86 static const char *regnames
[] =
88 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
89 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
90 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
91 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
94 static const char *special_regnames
[] =
96 "rpc", "rmsr", "sr2", "sr3", "sr4", "sr5", "sr6", "sr7",
97 "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
98 "sr16", "sr17", "sr18"
101 /* Sign extend at translation time. */
102 static inline int sign_extend(unsigned int val
, unsigned int width
)
114 static inline void t_sync_flags(DisasContext
*dc
)
116 /* Synch the tb dependent flags between translator and runtime. */
117 if (dc
->tb_flags
!= dc
->synced_flags
) {
118 tcg_gen_movi_tl(env_iflags
, dc
->tb_flags
);
119 dc
->synced_flags
= dc
->tb_flags
;
123 static inline void t_gen_raise_exception(DisasContext
*dc
, uint32_t index
)
125 TCGv_i32 tmp
= tcg_const_i32(index
);
128 tcg_gen_movi_tl(cpu_SR
[SR_PC
], dc
->pc
);
129 gen_helper_raise_exception(cpu_env
, tmp
);
130 tcg_temp_free_i32(tmp
);
131 dc
->is_jmp
= DISAS_UPDATE
;
134 static void gen_goto_tb(DisasContext
*dc
, int n
, target_ulong dest
)
136 TranslationBlock
*tb
;
138 if ((tb
->pc
& TARGET_PAGE_MASK
) == (dest
& TARGET_PAGE_MASK
)) {
140 tcg_gen_movi_tl(cpu_SR
[SR_PC
], dest
);
141 tcg_gen_exit_tb((uintptr_t)tb
+ n
);
143 tcg_gen_movi_tl(cpu_SR
[SR_PC
], dest
);
148 static void read_carry(DisasContext
*dc
, TCGv d
)
150 tcg_gen_shri_tl(d
, cpu_SR
[SR_MSR
], 31);
154 * write_carry sets the carry bits in MSR based on bit 0 of v.
155 * v[31:1] are ignored.
157 static void write_carry(DisasContext
*dc
, TCGv v
)
159 TCGv t0
= tcg_temp_new();
160 tcg_gen_shli_tl(t0
, v
, 31);
161 tcg_gen_sari_tl(t0
, t0
, 31);
162 tcg_gen_andi_tl(t0
, t0
, (MSR_C
| MSR_CC
));
163 tcg_gen_andi_tl(cpu_SR
[SR_MSR
], cpu_SR
[SR_MSR
],
165 tcg_gen_or_tl(cpu_SR
[SR_MSR
], cpu_SR
[SR_MSR
], t0
);
169 static void write_carryi(DisasContext
*dc
, bool carry
)
171 TCGv t0
= tcg_temp_new();
172 tcg_gen_movi_tl(t0
, carry
);
177 /* True if ALU operand b is a small immediate that may deserve
179 static inline int dec_alu_op_b_is_small_imm(DisasContext
*dc
)
181 /* Immediate insn without the imm prefix ? */
182 return dc
->type_b
&& !(dc
->tb_flags
& IMM_FLAG
);
185 static inline TCGv
*dec_alu_op_b(DisasContext
*dc
)
188 if (dc
->tb_flags
& IMM_FLAG
)
189 tcg_gen_ori_tl(env_imm
, env_imm
, dc
->imm
);
191 tcg_gen_movi_tl(env_imm
, (int32_t)((int16_t)dc
->imm
));
194 return &cpu_R
[dc
->rb
];
197 static void dec_add(DisasContext
*dc
)
205 LOG_DIS("add%s%s%s r%d r%d r%d\n",
206 dc
->type_b
? "i" : "", k
? "k" : "", c
? "c" : "",
207 dc
->rd
, dc
->ra
, dc
->rb
);
209 /* Take care of the easy cases first. */
211 /* k - keep carry, no need to update MSR. */
212 /* If rd == r0, it's a nop. */
214 tcg_gen_add_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], *(dec_alu_op_b(dc
)));
217 /* c - Add carry into the result. */
221 tcg_gen_add_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->rd
], cf
);
228 /* From now on, we can assume k is zero. So we need to update MSR. */
234 tcg_gen_movi_tl(cf
, 0);
238 TCGv ncf
= tcg_temp_new();
239 gen_helper_carry(ncf
, cpu_R
[dc
->ra
], *(dec_alu_op_b(dc
)), cf
);
240 tcg_gen_add_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], *(dec_alu_op_b(dc
)));
241 tcg_gen_add_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->rd
], cf
);
242 write_carry(dc
, ncf
);
245 gen_helper_carry(cf
, cpu_R
[dc
->ra
], *(dec_alu_op_b(dc
)), cf
);
251 static void dec_sub(DisasContext
*dc
)
253 unsigned int u
, cmp
, k
, c
;
259 cmp
= (dc
->imm
& 1) && (!dc
->type_b
) && k
;
262 LOG_DIS("cmp%s r%d, r%d ir=%x\n", u
? "u" : "", dc
->rd
, dc
->ra
, dc
->ir
);
265 gen_helper_cmpu(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
267 gen_helper_cmp(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
272 LOG_DIS("sub%s%s r%d, r%d r%d\n",
273 k
? "k" : "", c
? "c" : "", dc
->rd
, dc
->ra
, dc
->rb
);
275 /* Take care of the easy cases first. */
277 /* k - keep carry, no need to update MSR. */
278 /* If rd == r0, it's a nop. */
280 tcg_gen_sub_tl(cpu_R
[dc
->rd
], *(dec_alu_op_b(dc
)), cpu_R
[dc
->ra
]);
283 /* c - Add carry into the result. */
287 tcg_gen_add_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->rd
], cf
);
294 /* From now on, we can assume k is zero. So we need to update MSR. */
295 /* Extract carry. And complement a into na. */
301 tcg_gen_movi_tl(cf
, 1);
304 /* d = b + ~a + c. carry defaults to 1. */
305 tcg_gen_not_tl(na
, cpu_R
[dc
->ra
]);
308 TCGv ncf
= tcg_temp_new();
309 gen_helper_carry(ncf
, na
, *(dec_alu_op_b(dc
)), cf
);
310 tcg_gen_add_tl(cpu_R
[dc
->rd
], na
, *(dec_alu_op_b(dc
)));
311 tcg_gen_add_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->rd
], cf
);
312 write_carry(dc
, ncf
);
315 gen_helper_carry(cf
, na
, *(dec_alu_op_b(dc
)), cf
);
322 static void dec_pattern(DisasContext
*dc
)
327 if ((dc
->tb_flags
& MSR_EE_FLAG
)
328 && (dc
->env
->pvr
.regs
[2] & PVR2_ILL_OPCODE_EXC_MASK
)
329 && !((dc
->env
->pvr
.regs
[2] & PVR2_USE_PCMP_INSTR
))) {
330 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_ILLEGAL_OP
);
331 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
334 mode
= dc
->opcode
& 3;
338 LOG_DIS("pcmpbf r%d r%d r%d\n", dc
->rd
, dc
->ra
, dc
->rb
);
340 gen_helper_pcmpbf(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
343 LOG_DIS("pcmpeq r%d r%d r%d\n", dc
->rd
, dc
->ra
, dc
->rb
);
345 TCGv t0
= tcg_temp_local_new();
346 l1
= gen_new_label();
347 tcg_gen_movi_tl(t0
, 1);
348 tcg_gen_brcond_tl(TCG_COND_EQ
,
349 cpu_R
[dc
->ra
], cpu_R
[dc
->rb
], l1
);
350 tcg_gen_movi_tl(t0
, 0);
352 tcg_gen_mov_tl(cpu_R
[dc
->rd
], t0
);
357 LOG_DIS("pcmpne r%d r%d r%d\n", dc
->rd
, dc
->ra
, dc
->rb
);
358 l1
= gen_new_label();
360 TCGv t0
= tcg_temp_local_new();
361 tcg_gen_movi_tl(t0
, 1);
362 tcg_gen_brcond_tl(TCG_COND_NE
,
363 cpu_R
[dc
->ra
], cpu_R
[dc
->rb
], l1
);
364 tcg_gen_movi_tl(t0
, 0);
366 tcg_gen_mov_tl(cpu_R
[dc
->rd
], t0
);
372 "unsupported pattern insn opcode=%x\n", dc
->opcode
);
377 static void dec_and(DisasContext
*dc
)
381 if (!dc
->type_b
&& (dc
->imm
& (1 << 10))) {
386 not = dc
->opcode
& (1 << 1);
387 LOG_DIS("and%s\n", not ? "n" : "");
393 tcg_gen_andc_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], *(dec_alu_op_b(dc
)));
395 tcg_gen_and_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], *(dec_alu_op_b(dc
)));
398 static void dec_or(DisasContext
*dc
)
400 if (!dc
->type_b
&& (dc
->imm
& (1 << 10))) {
405 LOG_DIS("or r%d r%d r%d imm=%x\n", dc
->rd
, dc
->ra
, dc
->rb
, dc
->imm
);
407 tcg_gen_or_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], *(dec_alu_op_b(dc
)));
410 static void dec_xor(DisasContext
*dc
)
412 if (!dc
->type_b
&& (dc
->imm
& (1 << 10))) {
417 LOG_DIS("xor r%d\n", dc
->rd
);
419 tcg_gen_xor_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], *(dec_alu_op_b(dc
)));
422 static inline void msr_read(DisasContext
*dc
, TCGv d
)
424 tcg_gen_mov_tl(d
, cpu_SR
[SR_MSR
]);
427 static inline void msr_write(DisasContext
*dc
, TCGv v
)
432 dc
->cpustate_changed
= 1;
433 /* PVR bit is not writable. */
434 tcg_gen_andi_tl(t
, v
, ~MSR_PVR
);
435 tcg_gen_andi_tl(cpu_SR
[SR_MSR
], cpu_SR
[SR_MSR
], MSR_PVR
);
436 tcg_gen_or_tl(cpu_SR
[SR_MSR
], cpu_SR
[SR_MSR
], v
);
440 static void dec_msr(DisasContext
*dc
)
443 unsigned int sr
, to
, rn
;
444 int mem_index
= cpu_mmu_index(dc
->env
);
446 sr
= dc
->imm
& ((1 << 14) - 1);
447 to
= dc
->imm
& (1 << 14);
450 dc
->cpustate_changed
= 1;
452 /* msrclr and msrset. */
453 if (!(dc
->imm
& (1 << 15))) {
454 unsigned int clr
= dc
->ir
& (1 << 16);
456 LOG_DIS("msr%s r%d imm=%x\n", clr
? "clr" : "set",
459 if (!(dc
->env
->pvr
.regs
[2] & PVR2_USE_MSR_INSTR
)) {
464 if ((dc
->tb_flags
& MSR_EE_FLAG
)
465 && mem_index
== MMU_USER_IDX
&& (dc
->imm
!= 4 && dc
->imm
!= 0)) {
466 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_PRIVINSN
);
467 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
472 msr_read(dc
, cpu_R
[dc
->rd
]);
477 tcg_gen_mov_tl(t1
, *(dec_alu_op_b(dc
)));
480 tcg_gen_not_tl(t1
, t1
);
481 tcg_gen_and_tl(t0
, t0
, t1
);
483 tcg_gen_or_tl(t0
, t0
, t1
);
487 tcg_gen_movi_tl(cpu_SR
[SR_PC
], dc
->pc
+ 4);
488 dc
->is_jmp
= DISAS_UPDATE
;
493 if ((dc
->tb_flags
& MSR_EE_FLAG
)
494 && mem_index
== MMU_USER_IDX
) {
495 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_PRIVINSN
);
496 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
501 #if !defined(CONFIG_USER_ONLY)
502 /* Catch read/writes to the mmu block. */
503 if ((sr
& ~0xff) == 0x1000) {
505 LOG_DIS("m%ss sr%d r%d imm=%x\n", to
? "t" : "f", sr
, dc
->ra
, dc
->imm
);
507 gen_helper_mmu_write(cpu_env
, tcg_const_tl(sr
), cpu_R
[dc
->ra
]);
509 gen_helper_mmu_read(cpu_R
[dc
->rd
], cpu_env
, tcg_const_tl(sr
));
515 LOG_DIS("m%ss sr%x r%d imm=%x\n", to
? "t" : "f", sr
, dc
->ra
, dc
->imm
);
520 msr_write(dc
, cpu_R
[dc
->ra
]);
523 tcg_gen_mov_tl(cpu_SR
[SR_EAR
], cpu_R
[dc
->ra
]);
526 tcg_gen_mov_tl(cpu_SR
[SR_ESR
], cpu_R
[dc
->ra
]);
529 tcg_gen_andi_tl(cpu_SR
[SR_FSR
], cpu_R
[dc
->ra
], 31);
532 tcg_gen_st_tl(cpu_R
[dc
->ra
], cpu_env
, offsetof(CPUMBState
, slr
));
535 tcg_gen_st_tl(cpu_R
[dc
->ra
], cpu_env
, offsetof(CPUMBState
, shr
));
538 cpu_abort(dc
->env
, "unknown mts reg %x\n", sr
);
542 LOG_DIS("m%ss r%d sr%x imm=%x\n", to
? "t" : "f", dc
->rd
, sr
, dc
->imm
);
546 tcg_gen_movi_tl(cpu_R
[dc
->rd
], dc
->pc
);
549 msr_read(dc
, cpu_R
[dc
->rd
]);
552 tcg_gen_mov_tl(cpu_R
[dc
->rd
], cpu_SR
[SR_EAR
]);
555 tcg_gen_mov_tl(cpu_R
[dc
->rd
], cpu_SR
[SR_ESR
]);
558 tcg_gen_mov_tl(cpu_R
[dc
->rd
], cpu_SR
[SR_FSR
]);
561 tcg_gen_mov_tl(cpu_R
[dc
->rd
], cpu_SR
[SR_BTR
]);
564 tcg_gen_ld_tl(cpu_R
[dc
->rd
], cpu_env
, offsetof(CPUMBState
, slr
));
567 tcg_gen_ld_tl(cpu_R
[dc
->rd
], cpu_env
, offsetof(CPUMBState
, shr
));
583 tcg_gen_ld_tl(cpu_R
[dc
->rd
],
584 cpu_env
, offsetof(CPUMBState
, pvr
.regs
[rn
]));
587 cpu_abort(dc
->env
, "unknown mfs reg %x\n", sr
);
593 tcg_gen_movi_tl(cpu_R
[0], 0);
597 /* 64-bit signed mul, lower result in d and upper in d2. */
598 static void t_gen_muls(TCGv d
, TCGv d2
, TCGv a
, TCGv b
)
602 t0
= tcg_temp_new_i64();
603 t1
= tcg_temp_new_i64();
605 tcg_gen_ext_i32_i64(t0
, a
);
606 tcg_gen_ext_i32_i64(t1
, b
);
607 tcg_gen_mul_i64(t0
, t0
, t1
);
609 tcg_gen_trunc_i64_i32(d
, t0
);
610 tcg_gen_shri_i64(t0
, t0
, 32);
611 tcg_gen_trunc_i64_i32(d2
, t0
);
613 tcg_temp_free_i64(t0
);
614 tcg_temp_free_i64(t1
);
617 /* 64-bit unsigned muls, lower result in d and upper in d2. */
618 static void t_gen_mulu(TCGv d
, TCGv d2
, TCGv a
, TCGv b
)
622 t0
= tcg_temp_new_i64();
623 t1
= tcg_temp_new_i64();
625 tcg_gen_extu_i32_i64(t0
, a
);
626 tcg_gen_extu_i32_i64(t1
, b
);
627 tcg_gen_mul_i64(t0
, t0
, t1
);
629 tcg_gen_trunc_i64_i32(d
, t0
);
630 tcg_gen_shri_i64(t0
, t0
, 32);
631 tcg_gen_trunc_i64_i32(d2
, t0
);
633 tcg_temp_free_i64(t0
);
634 tcg_temp_free_i64(t1
);
637 /* Multiplier unit. */
638 static void dec_mul(DisasContext
*dc
)
641 unsigned int subcode
;
643 if ((dc
->tb_flags
& MSR_EE_FLAG
)
644 && (dc
->env
->pvr
.regs
[2] & PVR2_ILL_OPCODE_EXC_MASK
)
645 && !(dc
->env
->pvr
.regs
[0] & PVR0_USE_HW_MUL_MASK
)) {
646 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_ILLEGAL_OP
);
647 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
651 subcode
= dc
->imm
& 3;
652 d
[0] = tcg_temp_new();
653 d
[1] = tcg_temp_new();
656 LOG_DIS("muli r%d r%d %x\n", dc
->rd
, dc
->ra
, dc
->imm
);
657 t_gen_mulu(cpu_R
[dc
->rd
], d
[1], cpu_R
[dc
->ra
], *(dec_alu_op_b(dc
)));
661 /* mulh, mulhsu and mulhu are not available if C_USE_HW_MUL is < 2. */
662 if (subcode
>= 1 && subcode
<= 3
663 && !((dc
->env
->pvr
.regs
[2] & PVR2_USE_MUL64_MASK
))) {
669 LOG_DIS("mul r%d r%d r%d\n", dc
->rd
, dc
->ra
, dc
->rb
);
670 t_gen_mulu(cpu_R
[dc
->rd
], d
[1], cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
673 LOG_DIS("mulh r%d r%d r%d\n", dc
->rd
, dc
->ra
, dc
->rb
);
674 t_gen_muls(d
[0], cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
677 LOG_DIS("mulhsu r%d r%d r%d\n", dc
->rd
, dc
->ra
, dc
->rb
);
678 t_gen_muls(d
[0], cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
681 LOG_DIS("mulhu r%d r%d r%d\n", dc
->rd
, dc
->ra
, dc
->rb
);
682 t_gen_mulu(d
[0], cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
685 cpu_abort(dc
->env
, "unknown MUL insn %x\n", subcode
);
694 static void dec_div(DisasContext
*dc
)
701 if ((dc
->env
->pvr
.regs
[2] & PVR2_ILL_OPCODE_EXC_MASK
)
702 && !((dc
->env
->pvr
.regs
[0] & PVR0_USE_DIV_MASK
))) {
703 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_ILLEGAL_OP
);
704 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
708 gen_helper_divu(cpu_R
[dc
->rd
], cpu_env
, *(dec_alu_op_b(dc
)),
711 gen_helper_divs(cpu_R
[dc
->rd
], cpu_env
, *(dec_alu_op_b(dc
)),
714 tcg_gen_movi_tl(cpu_R
[dc
->rd
], 0);
717 static void dec_barrel(DisasContext
*dc
)
722 if ((dc
->tb_flags
& MSR_EE_FLAG
)
723 && (dc
->env
->pvr
.regs
[2] & PVR2_ILL_OPCODE_EXC_MASK
)
724 && !(dc
->env
->pvr
.regs
[0] & PVR0_USE_BARREL_MASK
)) {
725 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_ILLEGAL_OP
);
726 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
730 s
= dc
->imm
& (1 << 10);
731 t
= dc
->imm
& (1 << 9);
733 LOG_DIS("bs%s%s r%d r%d r%d\n",
734 s
? "l" : "r", t
? "a" : "l", dc
->rd
, dc
->ra
, dc
->rb
);
738 tcg_gen_mov_tl(t0
, *(dec_alu_op_b(dc
)));
739 tcg_gen_andi_tl(t0
, t0
, 31);
742 tcg_gen_shl_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], t0
);
745 tcg_gen_sar_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], t0
);
747 tcg_gen_shr_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], t0
);
751 static void dec_bit(DisasContext
*dc
)
755 int mem_index
= cpu_mmu_index(dc
->env
);
757 op
= dc
->ir
& ((1 << 9) - 1);
763 LOG_DIS("src r%d r%d\n", dc
->rd
, dc
->ra
);
764 tcg_gen_andi_tl(t0
, cpu_SR
[SR_MSR
], MSR_CC
);
765 write_carry(dc
, cpu_R
[dc
->ra
]);
767 tcg_gen_shri_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], 1);
768 tcg_gen_or_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->rd
], t0
);
776 LOG_DIS("srl r%d r%d\n", dc
->rd
, dc
->ra
);
778 /* Update carry. Note that write carry only looks at the LSB. */
779 write_carry(dc
, cpu_R
[dc
->ra
]);
782 tcg_gen_shri_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], 1);
784 tcg_gen_sari_tl(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], 1);
788 LOG_DIS("ext8s r%d r%d\n", dc
->rd
, dc
->ra
);
789 tcg_gen_ext8s_i32(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
]);
792 LOG_DIS("ext16s r%d r%d\n", dc
->rd
, dc
->ra
);
793 tcg_gen_ext16s_i32(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
]);
800 LOG_DIS("wdc r%d\n", dc
->ra
);
801 if ((dc
->tb_flags
& MSR_EE_FLAG
)
802 && mem_index
== MMU_USER_IDX
) {
803 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_PRIVINSN
);
804 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
810 LOG_DIS("wic r%d\n", dc
->ra
);
811 if ((dc
->tb_flags
& MSR_EE_FLAG
)
812 && mem_index
== MMU_USER_IDX
) {
813 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_PRIVINSN
);
814 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
819 if ((dc
->tb_flags
& MSR_EE_FLAG
)
820 && (dc
->env
->pvr
.regs
[2] & PVR2_ILL_OPCODE_EXC_MASK
)
821 && !((dc
->env
->pvr
.regs
[2] & PVR2_USE_PCMP_INSTR
))) {
822 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_ILLEGAL_OP
);
823 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
825 if (dc
->env
->pvr
.regs
[2] & PVR2_USE_PCMP_INSTR
) {
826 gen_helper_clz(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
]);
831 LOG_DIS("swapb r%d r%d\n", dc
->rd
, dc
->ra
);
832 tcg_gen_bswap32_i32(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
]);
836 LOG_DIS("swaph r%d r%d\n", dc
->rd
, dc
->ra
);
837 tcg_gen_rotri_i32(cpu_R
[dc
->rd
], cpu_R
[dc
->ra
], 16);
840 cpu_abort(dc
->env
, "unknown bit oc=%x op=%x rd=%d ra=%d rb=%d\n",
841 dc
->pc
, op
, dc
->rd
, dc
->ra
, dc
->rb
);
846 static inline void sync_jmpstate(DisasContext
*dc
)
848 if (dc
->jmp
== JMP_DIRECT
|| dc
->jmp
== JMP_DIRECT_CC
) {
849 if (dc
->jmp
== JMP_DIRECT
) {
850 tcg_gen_movi_tl(env_btaken
, 1);
852 dc
->jmp
= JMP_INDIRECT
;
853 tcg_gen_movi_tl(env_btarget
, dc
->jmp_pc
);
857 static void dec_imm(DisasContext
*dc
)
859 LOG_DIS("imm %x\n", dc
->imm
<< 16);
860 tcg_gen_movi_tl(env_imm
, (dc
->imm
<< 16));
861 dc
->tb_flags
|= IMM_FLAG
;
865 static inline void gen_load(DisasContext
*dc
, TCGv dst
, TCGv addr
,
866 unsigned int size
, bool exclusive
)
868 int mem_index
= cpu_mmu_index(dc
->env
);
871 tcg_gen_qemu_ld8u(dst
, addr
, mem_index
);
872 } else if (size
== 2) {
873 tcg_gen_qemu_ld16u(dst
, addr
, mem_index
);
874 } else if (size
== 4) {
875 tcg_gen_qemu_ld32u(dst
, addr
, mem_index
);
877 cpu_abort(dc
->env
, "Incorrect load size %d\n", size
);
880 tcg_gen_st_tl(addr
, cpu_env
, offsetof(CPUMBState
, res_addr
));
884 static inline TCGv
*compute_ldst_addr(DisasContext
*dc
, TCGv
*t
)
886 unsigned int extimm
= dc
->tb_flags
& IMM_FLAG
;
887 /* Should be set to one if r1 is used by loadstores. */
890 /* All load/stores use ra. */
895 /* Treat the common cases first. */
897 /* If any of the regs is r0, return a ptr to the other. */
899 return &cpu_R
[dc
->rb
];
900 } else if (dc
->rb
== 0) {
901 return &cpu_R
[dc
->ra
];
909 tcg_gen_add_tl(*t
, cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
912 gen_helper_stackprot(cpu_env
, *t
);
919 return &cpu_R
[dc
->ra
];
922 tcg_gen_movi_tl(*t
, (int32_t)((int16_t)dc
->imm
));
923 tcg_gen_add_tl(*t
, cpu_R
[dc
->ra
], *t
);
926 tcg_gen_add_tl(*t
, cpu_R
[dc
->ra
], *(dec_alu_op_b(dc
)));
930 gen_helper_stackprot(cpu_env
, *t
);
935 static inline void dec_byteswap(DisasContext
*dc
, TCGv dst
, TCGv src
, int size
)
938 tcg_gen_bswap32_tl(dst
, src
);
939 } else if (size
== 2) {
940 TCGv t
= tcg_temp_new();
942 /* bswap16 assumes the high bits are zero. */
943 tcg_gen_andi_tl(t
, src
, 0xffff);
944 tcg_gen_bswap16_tl(dst
, t
);
948 cpu_abort(dc->env, "Invalid ldst byteswap size %d\n", size);
953 static void dec_load(DisasContext
*dc
)
956 unsigned int size
, rev
= 0, ex
= 0;
958 size
= 1 << (dc
->opcode
& 3);
961 rev
= (dc
->ir
>> 9) & 1;
962 ex
= (dc
->ir
>> 10) & 1;
965 if (size
> 4 && (dc
->tb_flags
& MSR_EE_FLAG
)
966 && (dc
->env
->pvr
.regs
[2] & PVR2_ILL_OPCODE_EXC_MASK
)) {
967 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_ILLEGAL_OP
);
968 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
972 LOG_DIS("l%d%s%s%s\n", size
, dc
->type_b
? "i" : "", rev
? "r" : "",
976 addr
= compute_ldst_addr(dc
, &t
);
979 * When doing reverse accesses we need to do two things.
981 * 1. Reverse the address wrt endianness.
982 * 2. Byteswap the data lanes on the way back into the CPU core.
984 if (rev
&& size
!= 4) {
985 /* Endian reverse the address. t is addr. */
993 TCGv low
= tcg_temp_new();
995 /* Force addr into the temp. */
998 tcg_gen_mov_tl(t
, *addr
);
1002 tcg_gen_andi_tl(low
, t
, 3);
1003 tcg_gen_sub_tl(low
, tcg_const_tl(3), low
);
1004 tcg_gen_andi_tl(t
, t
, ~3);
1005 tcg_gen_or_tl(t
, t
, low
);
1006 tcg_gen_mov_tl(env_imm
, t
);
1014 /* Force addr into the temp. */
1017 tcg_gen_xori_tl(t
, *addr
, 2);
1020 tcg_gen_xori_tl(t
, t
, 2);
1024 cpu_abort(dc
->env
, "Invalid reverse size\n");
1029 /* lwx does not throw unaligned access errors, so force alignment */
1031 /* Force addr into the temp. */
1034 tcg_gen_mov_tl(t
, *addr
);
1037 tcg_gen_andi_tl(t
, t
, ~3);
1040 /* If we get a fault on a dslot, the jmpstate better be in sync. */
1043 /* Verify alignment if needed. */
1044 if ((dc
->env
->pvr
.regs
[2] & PVR2_UNALIGNED_EXC_MASK
) && size
> 1) {
1045 TCGv v
= tcg_temp_new();
1048 * Microblaze gives MMU faults priority over faults due to
1049 * unaligned addresses. That's why we speculatively do the load
1050 * into v. If the load succeeds, we verify alignment of the
1051 * address and if that succeeds we write into the destination reg.
1053 gen_load(dc
, v
, *addr
, size
, ex
);
1055 tcg_gen_movi_tl(cpu_SR
[SR_PC
], dc
->pc
);
1056 gen_helper_memalign(cpu_env
, *addr
, tcg_const_tl(dc
->rd
),
1057 tcg_const_tl(0), tcg_const_tl(size
- 1));
1060 dec_byteswap(dc
, cpu_R
[dc
->rd
], v
, size
);
1062 tcg_gen_mov_tl(cpu_R
[dc
->rd
], v
);
1068 gen_load(dc
, cpu_R
[dc
->rd
], *addr
, size
, ex
);
1070 dec_byteswap(dc
, cpu_R
[dc
->rd
], cpu_R
[dc
->rd
], size
);
1073 /* We are loading into r0, no need to reverse. */
1074 gen_load(dc
, env_imm
, *addr
, size
, ex
);
1079 /* no support for for AXI exclusive so always clear C */
1080 write_carryi(dc
, 0);
1087 static void gen_store(DisasContext
*dc
, TCGv addr
, TCGv val
,
1090 int mem_index
= cpu_mmu_index(dc
->env
);
1093 tcg_gen_qemu_st8(val
, addr
, mem_index
);
1094 else if (size
== 2) {
1095 tcg_gen_qemu_st16(val
, addr
, mem_index
);
1096 } else if (size
== 4) {
1097 tcg_gen_qemu_st32(val
, addr
, mem_index
);
1099 cpu_abort(dc
->env
, "Incorrect store size %d\n", size
);
1102 static void dec_store(DisasContext
*dc
)
1104 TCGv t
, *addr
, swx_addr
, r_check
;
1106 unsigned int size
, rev
= 0, ex
= 0;
1108 size
= 1 << (dc
->opcode
& 3);
1110 rev
= (dc
->ir
>> 9) & 1;
1111 ex
= (dc
->ir
>> 10) & 1;
1114 if (size
> 4 && (dc
->tb_flags
& MSR_EE_FLAG
)
1115 && (dc
->env
->pvr
.regs
[2] & PVR2_ILL_OPCODE_EXC_MASK
)) {
1116 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_ILLEGAL_OP
);
1117 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
1121 LOG_DIS("s%d%s%s%s\n", size
, dc
->type_b
? "i" : "", rev
? "r" : "",
1124 /* If we get a fault on a dslot, the jmpstate better be in sync. */
1126 addr
= compute_ldst_addr(dc
, &t
);
1128 r_check
= tcg_temp_new();
1129 swx_addr
= tcg_temp_local_new();
1132 /* Force addr into the swx_addr. */
1133 tcg_gen_mov_tl(swx_addr
, *addr
);
1135 /* swx does not throw unaligned access errors, so force alignment */
1136 tcg_gen_andi_tl(swx_addr
, swx_addr
, ~3);
1138 tcg_gen_ld_tl(r_check
, cpu_env
, offsetof(CPUMBState
, res_addr
));
1139 write_carryi(dc
, 1);
1140 swx_skip
= gen_new_label();
1141 tcg_gen_brcond_tl(TCG_COND_NE
, r_check
, swx_addr
, swx_skip
);
1142 write_carryi(dc
, 0);
1145 if (rev
&& size
!= 4) {
1146 /* Endian reverse the address. t is addr. */
1154 TCGv low
= tcg_temp_new();
1156 /* Force addr into the temp. */
1159 tcg_gen_mov_tl(t
, *addr
);
1163 tcg_gen_andi_tl(low
, t
, 3);
1164 tcg_gen_sub_tl(low
, tcg_const_tl(3), low
);
1165 tcg_gen_andi_tl(t
, t
, ~3);
1166 tcg_gen_or_tl(t
, t
, low
);
1167 tcg_gen_mov_tl(env_imm
, t
);
1175 /* Force addr into the temp. */
1178 tcg_gen_xori_tl(t
, *addr
, 2);
1181 tcg_gen_xori_tl(t
, t
, 2);
1185 cpu_abort(dc
->env
, "Invalid reverse size\n");
1190 TCGv bs_data
= tcg_temp_new();
1191 dec_byteswap(dc
, bs_data
, cpu_R
[dc
->rd
], size
);
1192 gen_store(dc
, *addr
, bs_data
, size
);
1193 tcg_temp_free(bs_data
);
1195 gen_store(dc
, *addr
, cpu_R
[dc
->rd
], size
);
1199 TCGv bs_data
= tcg_temp_new();
1200 dec_byteswap(dc
, bs_data
, cpu_R
[dc
->rd
], size
);
1201 gen_store(dc
, *addr
, bs_data
, size
);
1202 tcg_temp_free(bs_data
);
1204 gen_store(dc
, *addr
, cpu_R
[dc
->rd
], size
);
1208 /* Verify alignment if needed. */
1209 if ((dc
->env
->pvr
.regs
[2] & PVR2_UNALIGNED_EXC_MASK
) && size
> 1) {
1210 tcg_gen_movi_tl(cpu_SR
[SR_PC
], dc
->pc
);
1211 /* FIXME: if the alignment is wrong, we should restore the value
1212 * in memory. One possible way to achieve this is to probe
1213 * the MMU prior to the memaccess, thay way we could put
1214 * the alignment checks in between the probe and the mem
1217 gen_helper_memalign(cpu_env
, *addr
, tcg_const_tl(dc
->rd
),
1218 tcg_const_tl(1), tcg_const_tl(size
- 1));
1222 gen_set_label(swx_skip
);
1224 tcg_temp_free(r_check
);
1225 tcg_temp_free(swx_addr
);
1231 static inline void eval_cc(DisasContext
*dc
, unsigned int cc
,
1232 TCGv d
, TCGv a
, TCGv b
)
1236 tcg_gen_setcond_tl(TCG_COND_EQ
, d
, a
, b
);
1239 tcg_gen_setcond_tl(TCG_COND_NE
, d
, a
, b
);
1242 tcg_gen_setcond_tl(TCG_COND_LT
, d
, a
, b
);
1245 tcg_gen_setcond_tl(TCG_COND_LE
, d
, a
, b
);
1248 tcg_gen_setcond_tl(TCG_COND_GE
, d
, a
, b
);
1251 tcg_gen_setcond_tl(TCG_COND_GT
, d
, a
, b
);
1254 cpu_abort(dc
->env
, "Unknown condition code %x.\n", cc
);
1259 static void eval_cond_jmp(DisasContext
*dc
, TCGv pc_true
, TCGv pc_false
)
1263 l1
= gen_new_label();
1264 /* Conditional jmp. */
1265 tcg_gen_mov_tl(cpu_SR
[SR_PC
], pc_false
);
1266 tcg_gen_brcondi_tl(TCG_COND_EQ
, env_btaken
, 0, l1
);
1267 tcg_gen_mov_tl(cpu_SR
[SR_PC
], pc_true
);
1271 static void dec_bcc(DisasContext
*dc
)
1276 cc
= EXTRACT_FIELD(dc
->ir
, 21, 23);
1277 dslot
= dc
->ir
& (1 << 25);
1278 LOG_DIS("bcc%s r%d %x\n", dslot
? "d" : "", dc
->ra
, dc
->imm
);
1280 dc
->delayed_branch
= 1;
1282 dc
->delayed_branch
= 2;
1283 dc
->tb_flags
|= D_FLAG
;
1284 tcg_gen_st_tl(tcg_const_tl(dc
->type_b
&& (dc
->tb_flags
& IMM_FLAG
)),
1285 cpu_env
, offsetof(CPUMBState
, bimm
));
1288 if (dec_alu_op_b_is_small_imm(dc
)) {
1289 int32_t offset
= (int32_t)((int16_t)dc
->imm
); /* sign-extend. */
1291 tcg_gen_movi_tl(env_btarget
, dc
->pc
+ offset
);
1292 dc
->jmp
= JMP_DIRECT_CC
;
1293 dc
->jmp_pc
= dc
->pc
+ offset
;
1295 dc
->jmp
= JMP_INDIRECT
;
1296 tcg_gen_movi_tl(env_btarget
, dc
->pc
);
1297 tcg_gen_add_tl(env_btarget
, env_btarget
, *(dec_alu_op_b(dc
)));
1299 eval_cc(dc
, cc
, env_btaken
, cpu_R
[dc
->ra
], tcg_const_tl(0));
1302 static void dec_br(DisasContext
*dc
)
1304 unsigned int dslot
, link
, abs
, mbar
;
1305 int mem_index
= cpu_mmu_index(dc
->env
);
1307 dslot
= dc
->ir
& (1 << 20);
1308 abs
= dc
->ir
& (1 << 19);
1309 link
= dc
->ir
& (1 << 18);
1311 /* Memory barrier. */
1312 mbar
= (dc
->ir
>> 16) & 31;
1313 if (mbar
== 2 && dc
->imm
== 4) {
1314 /* mbar IMM & 16 decodes to sleep. */
1316 TCGv_i32 tmp_hlt
= tcg_const_i32(EXCP_HLT
);
1317 TCGv_i32 tmp_1
= tcg_const_i32(1);
1322 tcg_gen_st_i32(tmp_1
, cpu_env
,
1323 -offsetof(MicroBlazeCPU
, env
)
1324 +offsetof(CPUState
, halted
));
1325 tcg_gen_movi_tl(cpu_SR
[SR_PC
], dc
->pc
+ 4);
1326 gen_helper_raise_exception(cpu_env
, tmp_hlt
);
1327 tcg_temp_free_i32(tmp_hlt
);
1328 tcg_temp_free_i32(tmp_1
);
1331 LOG_DIS("mbar %d\n", dc
->rd
);
1333 dc
->cpustate_changed
= 1;
1337 LOG_DIS("br%s%s%s%s imm=%x\n",
1338 abs
? "a" : "", link
? "l" : "",
1339 dc
->type_b
? "i" : "", dslot
? "d" : "",
1342 dc
->delayed_branch
= 1;
1344 dc
->delayed_branch
= 2;
1345 dc
->tb_flags
|= D_FLAG
;
1346 tcg_gen_st_tl(tcg_const_tl(dc
->type_b
&& (dc
->tb_flags
& IMM_FLAG
)),
1347 cpu_env
, offsetof(CPUMBState
, bimm
));
1350 tcg_gen_movi_tl(cpu_R
[dc
->rd
], dc
->pc
);
1352 dc
->jmp
= JMP_INDIRECT
;
1354 tcg_gen_movi_tl(env_btaken
, 1);
1355 tcg_gen_mov_tl(env_btarget
, *(dec_alu_op_b(dc
)));
1356 if (link
&& !dslot
) {
1357 if (!(dc
->tb_flags
& IMM_FLAG
) && (dc
->imm
== 8 || dc
->imm
== 0x18))
1358 t_gen_raise_exception(dc
, EXCP_BREAK
);
1360 if ((dc
->tb_flags
& MSR_EE_FLAG
) && mem_index
== MMU_USER_IDX
) {
1361 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_PRIVINSN
);
1362 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
1366 t_gen_raise_exception(dc
, EXCP_DEBUG
);
1370 if (dec_alu_op_b_is_small_imm(dc
)) {
1371 dc
->jmp
= JMP_DIRECT
;
1372 dc
->jmp_pc
= dc
->pc
+ (int32_t)((int16_t)dc
->imm
);
1374 tcg_gen_movi_tl(env_btaken
, 1);
1375 tcg_gen_movi_tl(env_btarget
, dc
->pc
);
1376 tcg_gen_add_tl(env_btarget
, env_btarget
, *(dec_alu_op_b(dc
)));
1381 static inline void do_rti(DisasContext
*dc
)
1384 t0
= tcg_temp_new();
1385 t1
= tcg_temp_new();
1386 tcg_gen_shri_tl(t0
, cpu_SR
[SR_MSR
], 1);
1387 tcg_gen_ori_tl(t1
, cpu_SR
[SR_MSR
], MSR_IE
);
1388 tcg_gen_andi_tl(t0
, t0
, (MSR_VM
| MSR_UM
));
1390 tcg_gen_andi_tl(t1
, t1
, ~(MSR_VM
| MSR_UM
));
1391 tcg_gen_or_tl(t1
, t1
, t0
);
1395 dc
->tb_flags
&= ~DRTI_FLAG
;
1398 static inline void do_rtb(DisasContext
*dc
)
1401 t0
= tcg_temp_new();
1402 t1
= tcg_temp_new();
1403 tcg_gen_andi_tl(t1
, cpu_SR
[SR_MSR
], ~MSR_BIP
);
1404 tcg_gen_shri_tl(t0
, t1
, 1);
1405 tcg_gen_andi_tl(t0
, t0
, (MSR_VM
| MSR_UM
));
1407 tcg_gen_andi_tl(t1
, t1
, ~(MSR_VM
| MSR_UM
));
1408 tcg_gen_or_tl(t1
, t1
, t0
);
1412 dc
->tb_flags
&= ~DRTB_FLAG
;
1415 static inline void do_rte(DisasContext
*dc
)
1418 t0
= tcg_temp_new();
1419 t1
= tcg_temp_new();
1421 tcg_gen_ori_tl(t1
, cpu_SR
[SR_MSR
], MSR_EE
);
1422 tcg_gen_andi_tl(t1
, t1
, ~MSR_EIP
);
1423 tcg_gen_shri_tl(t0
, t1
, 1);
1424 tcg_gen_andi_tl(t0
, t0
, (MSR_VM
| MSR_UM
));
1426 tcg_gen_andi_tl(t1
, t1
, ~(MSR_VM
| MSR_UM
));
1427 tcg_gen_or_tl(t1
, t1
, t0
);
1431 dc
->tb_flags
&= ~DRTE_FLAG
;
1434 static void dec_rts(DisasContext
*dc
)
1436 unsigned int b_bit
, i_bit
, e_bit
;
1437 int mem_index
= cpu_mmu_index(dc
->env
);
1439 i_bit
= dc
->ir
& (1 << 21);
1440 b_bit
= dc
->ir
& (1 << 22);
1441 e_bit
= dc
->ir
& (1 << 23);
1443 dc
->delayed_branch
= 2;
1444 dc
->tb_flags
|= D_FLAG
;
1445 tcg_gen_st_tl(tcg_const_tl(dc
->type_b
&& (dc
->tb_flags
& IMM_FLAG
)),
1446 cpu_env
, offsetof(CPUMBState
, bimm
));
1449 LOG_DIS("rtid ir=%x\n", dc
->ir
);
1450 if ((dc
->tb_flags
& MSR_EE_FLAG
)
1451 && mem_index
== MMU_USER_IDX
) {
1452 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_PRIVINSN
);
1453 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
1455 dc
->tb_flags
|= DRTI_FLAG
;
1457 LOG_DIS("rtbd ir=%x\n", dc
->ir
);
1458 if ((dc
->tb_flags
& MSR_EE_FLAG
)
1459 && mem_index
== MMU_USER_IDX
) {
1460 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_PRIVINSN
);
1461 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
1463 dc
->tb_flags
|= DRTB_FLAG
;
1465 LOG_DIS("rted ir=%x\n", dc
->ir
);
1466 if ((dc
->tb_flags
& MSR_EE_FLAG
)
1467 && mem_index
== MMU_USER_IDX
) {
1468 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_PRIVINSN
);
1469 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
1471 dc
->tb_flags
|= DRTE_FLAG
;
1473 LOG_DIS("rts ir=%x\n", dc
->ir
);
1475 dc
->jmp
= JMP_INDIRECT
;
1476 tcg_gen_movi_tl(env_btaken
, 1);
1477 tcg_gen_add_tl(env_btarget
, cpu_R
[dc
->ra
], *(dec_alu_op_b(dc
)));
1480 static int dec_check_fpuv2(DisasContext
*dc
)
1484 r
= dc
->env
->pvr
.regs
[2] & PVR2_USE_FPU2_MASK
;
1486 if (!r
&& (dc
->tb_flags
& MSR_EE_FLAG
)) {
1487 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_FPU
);
1488 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
1493 static void dec_fpu(DisasContext
*dc
)
1495 unsigned int fpu_insn
;
1497 if ((dc
->tb_flags
& MSR_EE_FLAG
)
1498 && (dc
->env
->pvr
.regs
[2] & PVR2_ILL_OPCODE_EXC_MASK
)
1499 && !((dc
->env
->pvr
.regs
[2] & PVR2_USE_FPU_MASK
))) {
1500 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_ILLEGAL_OP
);
1501 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
1505 fpu_insn
= (dc
->ir
>> 7) & 7;
1509 gen_helper_fadd(cpu_R
[dc
->rd
], cpu_env
, cpu_R
[dc
->ra
],
1514 gen_helper_frsub(cpu_R
[dc
->rd
], cpu_env
, cpu_R
[dc
->ra
],
1519 gen_helper_fmul(cpu_R
[dc
->rd
], cpu_env
, cpu_R
[dc
->ra
],
1524 gen_helper_fdiv(cpu_R
[dc
->rd
], cpu_env
, cpu_R
[dc
->ra
],
1529 switch ((dc
->ir
>> 4) & 7) {
1531 gen_helper_fcmp_un(cpu_R
[dc
->rd
], cpu_env
,
1532 cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
1535 gen_helper_fcmp_lt(cpu_R
[dc
->rd
], cpu_env
,
1536 cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
1539 gen_helper_fcmp_eq(cpu_R
[dc
->rd
], cpu_env
,
1540 cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
1543 gen_helper_fcmp_le(cpu_R
[dc
->rd
], cpu_env
,
1544 cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
1547 gen_helper_fcmp_gt(cpu_R
[dc
->rd
], cpu_env
,
1548 cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
1551 gen_helper_fcmp_ne(cpu_R
[dc
->rd
], cpu_env
,
1552 cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
1555 gen_helper_fcmp_ge(cpu_R
[dc
->rd
], cpu_env
,
1556 cpu_R
[dc
->ra
], cpu_R
[dc
->rb
]);
1559 qemu_log_mask(LOG_UNIMP
,
1560 "unimplemented fcmp fpu_insn=%x pc=%x"
1562 fpu_insn
, dc
->pc
, dc
->opcode
);
1563 dc
->abort_at_next_insn
= 1;
1569 if (!dec_check_fpuv2(dc
)) {
1572 gen_helper_flt(cpu_R
[dc
->rd
], cpu_env
, cpu_R
[dc
->ra
]);
1576 if (!dec_check_fpuv2(dc
)) {
1579 gen_helper_fint(cpu_R
[dc
->rd
], cpu_env
, cpu_R
[dc
->ra
]);
1583 if (!dec_check_fpuv2(dc
)) {
1586 gen_helper_fsqrt(cpu_R
[dc
->rd
], cpu_env
, cpu_R
[dc
->ra
]);
1590 qemu_log_mask(LOG_UNIMP
, "unimplemented FPU insn fpu_insn=%x pc=%x"
1592 fpu_insn
, dc
->pc
, dc
->opcode
);
1593 dc
->abort_at_next_insn
= 1;
1598 static void dec_null(DisasContext
*dc
)
1600 if ((dc
->tb_flags
& MSR_EE_FLAG
)
1601 && (dc
->env
->pvr
.regs
[2] & PVR2_ILL_OPCODE_EXC_MASK
)) {
1602 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_ILLEGAL_OP
);
1603 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
1606 qemu_log ("unknown insn pc=%x opc=%x\n", dc
->pc
, dc
->opcode
);
1607 dc
->abort_at_next_insn
= 1;
1610 /* Insns connected to FSL or AXI stream attached devices. */
1611 static void dec_stream(DisasContext
*dc
)
1613 int mem_index
= cpu_mmu_index(dc
->env
);
1614 TCGv_i32 t_id
, t_ctrl
;
1617 LOG_DIS("%s%s imm=%x\n", dc
->rd
? "get" : "put",
1618 dc
->type_b
? "" : "d", dc
->imm
);
1620 if ((dc
->tb_flags
& MSR_EE_FLAG
) && (mem_index
== MMU_USER_IDX
)) {
1621 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_PRIVINSN
);
1622 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
1626 t_id
= tcg_temp_new();
1628 tcg_gen_movi_tl(t_id
, dc
->imm
& 0xf);
1629 ctrl
= dc
->imm
>> 10;
1631 tcg_gen_andi_tl(t_id
, cpu_R
[dc
->rb
], 0xf);
1632 ctrl
= dc
->imm
>> 5;
1635 t_ctrl
= tcg_const_tl(ctrl
);
1638 gen_helper_put(t_id
, t_ctrl
, cpu_R
[dc
->ra
]);
1640 gen_helper_get(cpu_R
[dc
->rd
], t_id
, t_ctrl
);
1642 tcg_temp_free(t_id
);
1643 tcg_temp_free(t_ctrl
);
1646 static struct decoder_info
{
1651 void (*dec
)(DisasContext
*dc
);
1659 {DEC_BARREL
, dec_barrel
},
1661 {DEC_ST
, dec_store
},
1670 {DEC_STREAM
, dec_stream
},
1674 static inline void decode(DisasContext
*dc
, uint32_t ir
)
1678 if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP
| CPU_LOG_TB_OP_OPT
))) {
1679 tcg_gen_debug_insn_start(dc
->pc
);
1683 LOG_DIS("%8.8x\t", dc
->ir
);
1688 if ((dc
->tb_flags
& MSR_EE_FLAG
)
1689 && (dc
->env
->pvr
.regs
[2] & PVR2_ILL_OPCODE_EXC_MASK
)
1690 && (dc
->env
->pvr
.regs
[2] & PVR2_OPCODE_0x0_ILL_MASK
)) {
1691 tcg_gen_movi_tl(cpu_SR
[SR_ESR
], ESR_EC_ILLEGAL_OP
);
1692 t_gen_raise_exception(dc
, EXCP_HW_EXCP
);
1696 LOG_DIS("nr_nops=%d\t", dc
->nr_nops
);
1698 if (dc
->nr_nops
> 4)
1699 cpu_abort(dc
->env
, "fetching nop sequence\n");
1701 /* bit 2 seems to indicate insn type. */
1702 dc
->type_b
= ir
& (1 << 29);
1704 dc
->opcode
= EXTRACT_FIELD(ir
, 26, 31);
1705 dc
->rd
= EXTRACT_FIELD(ir
, 21, 25);
1706 dc
->ra
= EXTRACT_FIELD(ir
, 16, 20);
1707 dc
->rb
= EXTRACT_FIELD(ir
, 11, 15);
1708 dc
->imm
= EXTRACT_FIELD(ir
, 0, 15);
1710 /* Large switch for all insns. */
1711 for (i
= 0; i
< ARRAY_SIZE(decinfo
); i
++) {
1712 if ((dc
->opcode
& decinfo
[i
].mask
) == decinfo
[i
].bits
) {
1719 static void check_breakpoint(CPUMBState
*env
, DisasContext
*dc
)
1723 if (unlikely(!QTAILQ_EMPTY(&env
->breakpoints
))) {
1724 QTAILQ_FOREACH(bp
, &env
->breakpoints
, entry
) {
1725 if (bp
->pc
== dc
->pc
) {
1726 t_gen_raise_exception(dc
, EXCP_DEBUG
);
1727 dc
->is_jmp
= DISAS_UPDATE
;
1733 /* generate intermediate code for basic block 'tb'. */
1735 gen_intermediate_code_internal(MicroBlazeCPU
*cpu
, TranslationBlock
*tb
,
1738 CPUState
*cs
= CPU(cpu
);
1739 CPUMBState
*env
= &cpu
->env
;
1740 uint16_t *gen_opc_end
;
1743 struct DisasContext ctx
;
1744 struct DisasContext
*dc
= &ctx
;
1745 uint32_t next_page_start
, org_flags
;
1753 org_flags
= dc
->synced_flags
= dc
->tb_flags
= tb
->flags
;
1755 gen_opc_end
= tcg_ctx
.gen_opc_buf
+ OPC_MAX_SIZE
;
1757 dc
->is_jmp
= DISAS_NEXT
;
1759 dc
->delayed_branch
= !!(dc
->tb_flags
& D_FLAG
);
1760 if (dc
->delayed_branch
) {
1761 dc
->jmp
= JMP_INDIRECT
;
1764 dc
->singlestep_enabled
= cs
->singlestep_enabled
;
1765 dc
->cpustate_changed
= 0;
1766 dc
->abort_at_next_insn
= 0;
1770 cpu_abort(env
, "Microblaze: unaligned PC=%x\n", pc_start
);
1772 if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM
)) {
1774 qemu_log("--------------\n");
1775 log_cpu_state(CPU(cpu
), 0);
1779 next_page_start
= (pc_start
& TARGET_PAGE_MASK
) + TARGET_PAGE_SIZE
;
1782 max_insns
= tb
->cflags
& CF_COUNT_MASK
;
1784 max_insns
= CF_COUNT_MASK
;
1790 if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM
)) {
1791 tcg_gen_movi_tl(cpu_SR
[SR_PC
], dc
->pc
);
1795 check_breakpoint(env
, dc
);
1798 j
= tcg_ctx
.gen_opc_ptr
- tcg_ctx
.gen_opc_buf
;
1802 tcg_ctx
.gen_opc_instr_start
[lj
++] = 0;
1804 tcg_ctx
.gen_opc_pc
[lj
] = dc
->pc
;
1805 tcg_ctx
.gen_opc_instr_start
[lj
] = 1;
1806 tcg_ctx
.gen_opc_icount
[lj
] = num_insns
;
1810 LOG_DIS("%8.8x:\t", dc
->pc
);
1812 if (num_insns
+ 1 == max_insns
&& (tb
->cflags
& CF_LAST_IO
))
1816 decode(dc
, cpu_ldl_code(env
, dc
->pc
));
1818 dc
->tb_flags
&= ~IMM_FLAG
;
1822 if (dc
->delayed_branch
) {
1823 dc
->delayed_branch
--;
1824 if (!dc
->delayed_branch
) {
1825 if (dc
->tb_flags
& DRTI_FLAG
)
1827 if (dc
->tb_flags
& DRTB_FLAG
)
1829 if (dc
->tb_flags
& DRTE_FLAG
)
1831 /* Clear the delay slot flag. */
1832 dc
->tb_flags
&= ~D_FLAG
;
1833 /* If it is a direct jump, try direct chaining. */
1834 if (dc
->jmp
== JMP_INDIRECT
) {
1835 eval_cond_jmp(dc
, env_btarget
, tcg_const_tl(dc
->pc
));
1836 dc
->is_jmp
= DISAS_JUMP
;
1837 } else if (dc
->jmp
== JMP_DIRECT
) {
1839 gen_goto_tb(dc
, 0, dc
->jmp_pc
);
1840 dc
->is_jmp
= DISAS_TB_JUMP
;
1841 } else if (dc
->jmp
== JMP_DIRECT_CC
) {
1845 l1
= gen_new_label();
1846 /* Conditional jmp. */
1847 tcg_gen_brcondi_tl(TCG_COND_NE
, env_btaken
, 0, l1
);
1848 gen_goto_tb(dc
, 1, dc
->pc
);
1850 gen_goto_tb(dc
, 0, dc
->jmp_pc
);
1852 dc
->is_jmp
= DISAS_TB_JUMP
;
1857 if (cs
->singlestep_enabled
) {
1860 } while (!dc
->is_jmp
&& !dc
->cpustate_changed
1861 && tcg_ctx
.gen_opc_ptr
< gen_opc_end
1863 && (dc
->pc
< next_page_start
)
1864 && num_insns
< max_insns
);
1867 if (dc
->jmp
== JMP_DIRECT
|| dc
->jmp
== JMP_DIRECT_CC
) {
1868 if (dc
->tb_flags
& D_FLAG
) {
1869 dc
->is_jmp
= DISAS_UPDATE
;
1870 tcg_gen_movi_tl(cpu_SR
[SR_PC
], npc
);
1876 if (tb
->cflags
& CF_LAST_IO
)
1878 /* Force an update if the per-tb cpu state has changed. */
1879 if (dc
->is_jmp
== DISAS_NEXT
1880 && (dc
->cpustate_changed
|| org_flags
!= dc
->tb_flags
)) {
1881 dc
->is_jmp
= DISAS_UPDATE
;
1882 tcg_gen_movi_tl(cpu_SR
[SR_PC
], npc
);
1886 if (unlikely(cs
->singlestep_enabled
)) {
1887 TCGv_i32 tmp
= tcg_const_i32(EXCP_DEBUG
);
1889 if (dc
->is_jmp
!= DISAS_JUMP
) {
1890 tcg_gen_movi_tl(cpu_SR
[SR_PC
], npc
);
1892 gen_helper_raise_exception(cpu_env
, tmp
);
1893 tcg_temp_free_i32(tmp
);
1895 switch(dc
->is_jmp
) {
1897 gen_goto_tb(dc
, 1, npc
);
1902 /* indicate that the hash table must be used
1903 to find the next TB */
1907 /* nothing more to generate */
1911 gen_tb_end(tb
, num_insns
);
1912 *tcg_ctx
.gen_opc_ptr
= INDEX_op_end
;
1914 j
= tcg_ctx
.gen_opc_ptr
- tcg_ctx
.gen_opc_buf
;
1917 tcg_ctx
.gen_opc_instr_start
[lj
++] = 0;
1919 tb
->size
= dc
->pc
- pc_start
;
1920 tb
->icount
= num_insns
;
1925 if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM
)) {
1928 log_target_disas(env
, pc_start
, dc
->pc
- pc_start
, 0);
1930 qemu_log("\nisize=%d osize=%td\n",
1931 dc
->pc
- pc_start
, tcg_ctx
.gen_opc_ptr
-
1932 tcg_ctx
.gen_opc_buf
);
1936 assert(!dc
->abort_at_next_insn
);
1939 void gen_intermediate_code (CPUMBState
*env
, struct TranslationBlock
*tb
)
1941 gen_intermediate_code_internal(mb_env_get_cpu(env
), tb
, false);
1944 void gen_intermediate_code_pc (CPUMBState
*env
, struct TranslationBlock
*tb
)
1946 gen_intermediate_code_internal(mb_env_get_cpu(env
), tb
, true);
1949 void mb_cpu_dump_state(CPUState
*cs
, FILE *f
, fprintf_function cpu_fprintf
,
1952 MicroBlazeCPU
*cpu
= MICROBLAZE_CPU(cs
);
1953 CPUMBState
*env
= &cpu
->env
;
1959 cpu_fprintf(f
, "IN: PC=%x %s\n",
1960 env
->sregs
[SR_PC
], lookup_symbol(env
->sregs
[SR_PC
]));
1961 cpu_fprintf(f
, "rmsr=%x resr=%x rear=%x debug=%x imm=%x iflags=%x fsr=%x\n",
1962 env
->sregs
[SR_MSR
], env
->sregs
[SR_ESR
], env
->sregs
[SR_EAR
],
1963 env
->debug
, env
->imm
, env
->iflags
, env
->sregs
[SR_FSR
]);
1964 cpu_fprintf(f
, "btaken=%d btarget=%x mode=%s(saved=%s) eip=%d ie=%d\n",
1965 env
->btaken
, env
->btarget
,
1966 (env
->sregs
[SR_MSR
] & MSR_UM
) ? "user" : "kernel",
1967 (env
->sregs
[SR_MSR
] & MSR_UMS
) ? "user" : "kernel",
1968 (env
->sregs
[SR_MSR
] & MSR_EIP
),
1969 (env
->sregs
[SR_MSR
] & MSR_IE
));
1971 for (i
= 0; i
< 32; i
++) {
1972 cpu_fprintf(f
, "r%2.2d=%8.8x ", i
, env
->regs
[i
]);
1973 if ((i
+ 1) % 4 == 0)
1974 cpu_fprintf(f
, "\n");
1976 cpu_fprintf(f
, "\n\n");
1979 MicroBlazeCPU
*cpu_mb_init(const char *cpu_model
)
1983 cpu
= MICROBLAZE_CPU(object_new(TYPE_MICROBLAZE_CPU
));
1985 object_property_set_bool(OBJECT(cpu
), true, "realized", NULL
);
1990 void mb_tcg_init(void)
1994 cpu_env
= tcg_global_reg_new_ptr(TCG_AREG0
, "env");
1996 env_debug
= tcg_global_mem_new(TCG_AREG0
,
1997 offsetof(CPUMBState
, debug
),
1999 env_iflags
= tcg_global_mem_new(TCG_AREG0
,
2000 offsetof(CPUMBState
, iflags
),
2002 env_imm
= tcg_global_mem_new(TCG_AREG0
,
2003 offsetof(CPUMBState
, imm
),
2005 env_btarget
= tcg_global_mem_new(TCG_AREG0
,
2006 offsetof(CPUMBState
, btarget
),
2008 env_btaken
= tcg_global_mem_new(TCG_AREG0
,
2009 offsetof(CPUMBState
, btaken
),
2011 for (i
= 0; i
< ARRAY_SIZE(cpu_R
); i
++) {
2012 cpu_R
[i
] = tcg_global_mem_new(TCG_AREG0
,
2013 offsetof(CPUMBState
, regs
[i
]),
2016 for (i
= 0; i
< ARRAY_SIZE(cpu_SR
); i
++) {
2017 cpu_SR
[i
] = tcg_global_mem_new(TCG_AREG0
,
2018 offsetof(CPUMBState
, sregs
[i
]),
2019 special_regnames
[i
]);
2023 void restore_state_to_opc(CPUMBState
*env
, TranslationBlock
*tb
, int pc_pos
)
2025 env
->sregs
[SR_PC
] = tcg_ctx
.gen_opc_pc
[pc_pos
];