1 /* SPDX-License-Identifier: GPL-2.0-or-later */
3 * LoongArch emulation for QEMU - main translation routines.
5 * Copyright (c) 2021 Loongson Technology Corporation Limited
8 #include "qemu/osdep.h"
10 #include "tcg/tcg-op.h"
11 #include "tcg/tcg-op-gvec.h"
12 #include "exec/translation-block.h"
13 #include "exec/translator.h"
14 #include "exec/helper-proto.h"
15 #include "exec/helper-gen.h"
17 #include "qemu/qemu-print.h"
18 #include "fpu/softfloat.h"
19 #include "translate.h"
20 #include "internals.h"
23 /* Global register indices */
24 TCGv cpu_gpr
[32], cpu_pc
;
25 static TCGv cpu_lladdr
, cpu_llval
;
27 #define HELPER_H "helper.h"
28 #include "exec/helper-info.c.inc"
31 #define DISAS_STOP DISAS_TARGET_0
32 #define DISAS_EXIT DISAS_TARGET_1
33 #define DISAS_EXIT_UPDATE DISAS_TARGET_2
35 static inline int vec_full_offset(int regno
)
37 return offsetof(CPULoongArchState
, fpr
[regno
]);
40 static inline int vec_reg_offset(int regno
, int index
, MemOp mop
)
42 const uint8_t size
= 1 << mop
;
43 int offs
= index
* size
;
45 if (HOST_BIG_ENDIAN
&& size
< 8 ) {
49 return offs
+ vec_full_offset(regno
);
52 static inline void get_vreg64(TCGv_i64 dest
, int regno
, int index
)
54 tcg_gen_ld_i64(dest
, tcg_env
,
55 offsetof(CPULoongArchState
, fpr
[regno
].vreg
.D(index
)));
58 static inline void set_vreg64(TCGv_i64 src
, int regno
, int index
)
60 tcg_gen_st_i64(src
, tcg_env
,
61 offsetof(CPULoongArchState
, fpr
[regno
].vreg
.D(index
)));
64 static inline int plus_1(DisasContext
*ctx
, int x
)
69 static inline int shl_1(DisasContext
*ctx
, int x
)
74 static inline int shl_2(DisasContext
*ctx
, int x
)
79 static inline int shl_3(DisasContext
*ctx
, int x
)
85 * LoongArch the upper 32 bits are undefined ("can be any value").
86 * QEMU chooses to nanbox, because it is most likely to show guest bugs early.
88 static void gen_nanbox_s(TCGv_i64 out
, TCGv_i64 in
)
90 tcg_gen_ori_i64(out
, in
, MAKE_64BIT_MASK(32, 32));
93 void generate_exception(DisasContext
*ctx
, int excp
)
95 tcg_gen_movi_tl(cpu_pc
, ctx
->base
.pc_next
);
96 gen_helper_raise_exception(tcg_env
, tcg_constant_i32(excp
));
97 ctx
->base
.is_jmp
= DISAS_NORETURN
;
100 static inline void gen_goto_tb(DisasContext
*ctx
, int n
, target_ulong dest
)
103 dest
= (uint32_t) dest
;
106 if (translator_use_goto_tb(&ctx
->base
, dest
)) {
108 tcg_gen_movi_tl(cpu_pc
, dest
);
109 tcg_gen_exit_tb(ctx
->base
.tb
, n
);
111 tcg_gen_movi_tl(cpu_pc
, dest
);
112 tcg_gen_lookup_and_goto_ptr();
116 static void loongarch_tr_init_disas_context(DisasContextBase
*dcbase
,
120 CPULoongArchState
*env
= cpu_env(cs
);
121 DisasContext
*ctx
= container_of(dcbase
, DisasContext
, base
);
123 ctx
->page_start
= ctx
->base
.pc_first
& TARGET_PAGE_MASK
;
124 ctx
->plv
= ctx
->base
.tb
->flags
& HW_FLAGS_PLV_MASK
;
125 if (ctx
->base
.tb
->flags
& HW_FLAGS_CRMD_PG
) {
126 ctx
->mem_idx
= ctx
->plv
;
128 ctx
->mem_idx
= MMU_IDX_DA
;
131 /* Bound the number of insns to execute to those left on the page. */
132 bound
= -(ctx
->base
.pc_first
| TARGET_PAGE_MASK
) / 4;
133 ctx
->base
.max_insns
= MIN(ctx
->base
.max_insns
, bound
);
135 if (FIELD_EX64(env
->cpucfg
[2], CPUCFG2
, LSX
)) {
139 if (FIELD_EX64(env
->cpucfg
[2], CPUCFG2
, LASX
)) {
143 ctx
->la64
= is_la64(env
);
144 ctx
->va32
= (ctx
->base
.tb
->flags
& HW_FLAGS_VA32
) != 0;
146 ctx
->zero
= tcg_constant_tl(0);
148 ctx
->cpucfg1
= env
->cpucfg
[1];
149 ctx
->cpucfg2
= env
->cpucfg
[2];
152 static void loongarch_tr_tb_start(DisasContextBase
*dcbase
, CPUState
*cs
)
156 static void loongarch_tr_insn_start(DisasContextBase
*dcbase
, CPUState
*cs
)
158 DisasContext
*ctx
= container_of(dcbase
, DisasContext
, base
);
160 tcg_gen_insn_start(ctx
->base
.pc_next
);
164 * Wrappers for getting reg values.
166 * The $zero register does not have cpu_gpr[0] allocated -- we supply the
167 * constant zero as a source, and an uninitialized sink as destination.
169 * Further, we may provide an extension for word operations.
171 static TCGv
gpr_src(DisasContext
*ctx
, int reg_num
, DisasExtend src_ext
)
181 return cpu_gpr
[reg_num
];
184 tcg_gen_ext32s_tl(t
, cpu_gpr
[reg_num
]);
188 tcg_gen_ext32u_tl(t
, cpu_gpr
[reg_num
]);
191 g_assert_not_reached();
194 static TCGv
gpr_dst(DisasContext
*ctx
, int reg_num
, DisasExtend dst_ext
)
196 if (reg_num
== 0 || dst_ext
) {
197 return tcg_temp_new();
199 return cpu_gpr
[reg_num
];
202 static void gen_set_gpr(int reg_num
, TCGv t
, DisasExtend dst_ext
)
207 tcg_gen_mov_tl(cpu_gpr
[reg_num
], t
);
210 tcg_gen_ext32s_tl(cpu_gpr
[reg_num
], t
);
213 tcg_gen_ext32u_tl(cpu_gpr
[reg_num
], t
);
216 g_assert_not_reached();
221 static TCGv
get_fpr(DisasContext
*ctx
, int reg_num
)
223 TCGv t
= tcg_temp_new();
224 tcg_gen_ld_i64(t
, tcg_env
,
225 offsetof(CPULoongArchState
, fpr
[reg_num
].vreg
.D(0)));
229 static void set_fpr(int reg_num
, TCGv val
)
231 tcg_gen_st_i64(val
, tcg_env
,
232 offsetof(CPULoongArchState
, fpr
[reg_num
].vreg
.D(0)));
235 static TCGv
make_address_x(DisasContext
*ctx
, TCGv base
, TCGv addend
)
239 if (addend
|| ctx
->va32
) {
240 temp
= tcg_temp_new();
243 tcg_gen_add_tl(temp
, base
, addend
);
247 tcg_gen_ext32u_tl(temp
, base
);
253 static TCGv
make_address_i(DisasContext
*ctx
, TCGv base
, target_long ofs
)
255 TCGv addend
= ofs
? tcg_constant_tl(ofs
) : NULL
;
256 return make_address_x(ctx
, base
, addend
);
259 static uint64_t make_address_pc(DisasContext
*ctx
, uint64_t addr
)
262 addr
= (int32_t)addr
;
267 #include "decode-insns.c.inc"
268 #include "insn_trans/trans_arith.c.inc"
269 #include "insn_trans/trans_shift.c.inc"
270 #include "insn_trans/trans_bit.c.inc"
271 #include "insn_trans/trans_memory.c.inc"
272 #include "insn_trans/trans_atomic.c.inc"
273 #include "insn_trans/trans_extra.c.inc"
274 #include "insn_trans/trans_farith.c.inc"
275 #include "insn_trans/trans_fcmp.c.inc"
276 #include "insn_trans/trans_fcnv.c.inc"
277 #include "insn_trans/trans_fmov.c.inc"
278 #include "insn_trans/trans_fmemory.c.inc"
279 #include "insn_trans/trans_branch.c.inc"
280 #include "insn_trans/trans_privileged.c.inc"
281 #include "insn_trans/trans_vec.c.inc"
283 static void loongarch_tr_translate_insn(DisasContextBase
*dcbase
, CPUState
*cs
)
285 CPULoongArchState
*env
= cpu_env(cs
);
286 DisasContext
*ctx
= container_of(dcbase
, DisasContext
, base
);
288 ctx
->opcode
= translator_ldl(env
, &ctx
->base
, ctx
->base
.pc_next
);
290 if (!decode(ctx
, ctx
->opcode
)) {
291 qemu_log_mask(LOG_UNIMP
, "Error: unknown opcode. "
292 TARGET_FMT_lx
": 0x%x\n",
293 ctx
->base
.pc_next
, ctx
->opcode
);
294 generate_exception(ctx
, EXCCODE_INE
);
297 ctx
->base
.pc_next
+= 4;
300 ctx
->base
.pc_next
= (uint32_t)ctx
->base
.pc_next
;
304 static void loongarch_tr_tb_stop(DisasContextBase
*dcbase
, CPUState
*cs
)
306 DisasContext
*ctx
= container_of(dcbase
, DisasContext
, base
);
308 switch (ctx
->base
.is_jmp
) {
310 tcg_gen_movi_tl(cpu_pc
, ctx
->base
.pc_next
);
311 tcg_gen_lookup_and_goto_ptr();
314 gen_goto_tb(ctx
, 0, ctx
->base
.pc_next
);
318 case DISAS_EXIT_UPDATE
:
319 tcg_gen_movi_tl(cpu_pc
, ctx
->base
.pc_next
);
322 tcg_gen_exit_tb(NULL
, 0);
325 g_assert_not_reached();
329 static void loongarch_tr_disas_log(const DisasContextBase
*dcbase
,
330 CPUState
*cpu
, FILE *logfile
)
332 qemu_log("IN: %s\n", lookup_symbol(dcbase
->pc_first
));
333 target_disas(logfile
, cpu
, dcbase
->pc_first
, dcbase
->tb
->size
);
336 static const TranslatorOps loongarch_tr_ops
= {
337 .init_disas_context
= loongarch_tr_init_disas_context
,
338 .tb_start
= loongarch_tr_tb_start
,
339 .insn_start
= loongarch_tr_insn_start
,
340 .translate_insn
= loongarch_tr_translate_insn
,
341 .tb_stop
= loongarch_tr_tb_stop
,
342 .disas_log
= loongarch_tr_disas_log
,
345 void gen_intermediate_code(CPUState
*cs
, TranslationBlock
*tb
, int *max_insns
,
346 target_ulong pc
, void *host_pc
)
350 translator_loop(cs
, tb
, max_insns
, pc
, host_pc
,
351 &loongarch_tr_ops
, &ctx
.base
);
354 void loongarch_translate_init(void)
359 for (i
= 1; i
< 32; i
++) {
360 cpu_gpr
[i
] = tcg_global_mem_new(tcg_env
,
361 offsetof(CPULoongArchState
, gpr
[i
]),
365 cpu_pc
= tcg_global_mem_new(tcg_env
, offsetof(CPULoongArchState
, pc
), "pc");
366 cpu_lladdr
= tcg_global_mem_new(tcg_env
,
367 offsetof(CPULoongArchState
, lladdr
), "lladdr");
368 cpu_llval
= tcg_global_mem_new(tcg_env
,
369 offsetof(CPULoongArchState
, llval
), "llval");