target/loongarch/translate.c

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * LoongArch emulation for QEMU - main translation routines.
   4  *
   5  * Copyright (c) 2021 Loongson Technology Corporation Limited
   6  */
   7
   8 #include "qemu/osdep.h"
   9 #include "cpu.h"
  10 #include "tcg/tcg-op.h"
  11 #include "exec/translator.h"
  12 #include "exec/helper-proto.h"
  13 #include "exec/helper-gen.h"
  14
  15 #include "exec/translator.h"
  16 #include "exec/log.h"
  17 #include "qemu/qemu-print.h"
  18 #include "translate.h"
  19 #include "internals.h"
  20
  21 /* Global register indices */
  22 TCGv cpu_gpr[32], cpu_pc;
  23 static TCGv cpu_lladdr, cpu_llval;
  24 TCGv_i32 cpu_fcsr0;
  25 TCGv_i64 cpu_fpr[32];
  26
  27 #define DISAS_STOP       DISAS_TARGET_0
  28
  29 static inline int plus_1(DisasContext *ctx, int x)
  30 {
  31     return x + 1;
  32 }
  33
  34 static inline int shl_2(DisasContext *ctx, int x)
  35 {
  36     return x << 2;
  37 }
  38
  39 void generate_exception(DisasContext *ctx, int excp)
  40 {
  41     tcg_gen_movi_tl(cpu_pc, ctx->base.pc_next);
  42     gen_helper_raise_exception(cpu_env, tcg_constant_i32(excp));
  43     ctx->base.is_jmp = DISAS_NORETURN;
  44 }
  45
  46 static inline void gen_goto_tb(DisasContext *ctx, int n, target_ulong dest)
  47 {
  48     if (translator_use_goto_tb(&ctx->base, dest)) {
  49         tcg_gen_goto_tb(n);
  50         tcg_gen_movi_tl(cpu_pc, dest);
  51         tcg_gen_exit_tb(ctx->base.tb, n);
  52     } else {
  53         tcg_gen_movi_tl(cpu_pc, dest);
  54         tcg_gen_lookup_and_goto_ptr();
  55     }
  56 }
  57
  58 static void loongarch_tr_init_disas_context(DisasContextBase *dcbase,
  59                                             CPUState *cs)
  60 {
  61     int64_t bound;
  62     DisasContext *ctx = container_of(dcbase, DisasContext, base);
  63
  64     ctx->page_start = ctx->base.pc_first & TARGET_PAGE_MASK;
  65     ctx->mem_idx = ctx->base.tb->flags;
  66
  67     /* Bound the number of insns to execute to those left on the page.  */
  68     bound = -(ctx->base.pc_first | TARGET_PAGE_MASK) / 4;
  69     ctx->base.max_insns = MIN(ctx->base.max_insns, bound);
  70
  71     ctx->ntemp = 0;
  72     memset(ctx->temp, 0, sizeof(ctx->temp));
  73
  74     ctx->zero = tcg_constant_tl(0);
  75 }
  76
  77 static void loongarch_tr_tb_start(DisasContextBase *dcbase, CPUState *cs)
  78 {
  79 }
  80
  81 static void loongarch_tr_insn_start(DisasContextBase *dcbase, CPUState *cs)
  82 {
  83     DisasContext *ctx = container_of(dcbase, DisasContext, base);
  84
  85     tcg_gen_insn_start(ctx->base.pc_next);
  86 }
  87
  88 /*
  89  * Wrappers for getting reg values.
  90  *
  91  * The $zero register does not have cpu_gpr[0] allocated -- we supply the
  92  * constant zero as a source, and an uninitialized sink as destination.
  93  *
  94  * Further, we may provide an extension for word operations.
  95  */
  96 static TCGv temp_new(DisasContext *ctx)
  97 {
  98     assert(ctx->ntemp < ARRAY_SIZE(ctx->temp));
  99     return ctx->temp[ctx->ntemp++] = tcg_temp_new();
 100 }
 101
 102 static TCGv gpr_src(DisasContext *ctx, int reg_num, DisasExtend src_ext)
 103 {
 104     TCGv t;
 105
 106     if (reg_num == 0) {
 107         return ctx->zero;
 108     }
 109
 110     switch (src_ext) {
 111     case EXT_NONE:
 112         return cpu_gpr[reg_num];
 113     case EXT_SIGN:
 114         t = temp_new(ctx);
 115         tcg_gen_ext32s_tl(t, cpu_gpr[reg_num]);
 116         return t;
 117     case EXT_ZERO:
 118         t = temp_new(ctx);
 119         tcg_gen_ext32u_tl(t, cpu_gpr[reg_num]);
 120         return t;
 121     }
 122     g_assert_not_reached();
 123 }
 124
 125 static TCGv gpr_dst(DisasContext *ctx, int reg_num, DisasExtend dst_ext)
 126 {
 127     if (reg_num == 0 || dst_ext) {
 128         return temp_new(ctx);
 129     }
 130     return cpu_gpr[reg_num];
 131 }
 132
 133 static void gen_set_gpr(int reg_num, TCGv t, DisasExtend dst_ext)
 134 {
 135     if (reg_num != 0) {
 136         switch (dst_ext) {
 137         case EXT_NONE:
 138             tcg_gen_mov_tl(cpu_gpr[reg_num], t);
 139             break;
 140         case EXT_SIGN:
 141             tcg_gen_ext32s_tl(cpu_gpr[reg_num], t);
 142             break;
 143         case EXT_ZERO:
 144             tcg_gen_ext32u_tl(cpu_gpr[reg_num], t);
 145             break;
 146         default:
 147             g_assert_not_reached();
 148         }
 149     }
 150 }
 151
 152 #include "decode-insns.c.inc"
 153 #include "insn_trans/trans_arith.c.inc"
 154 #include "insn_trans/trans_shift.c.inc"
 155 #include "insn_trans/trans_bit.c.inc"
 156 #include "insn_trans/trans_memory.c.inc"
 157 #include "insn_trans/trans_atomic.c.inc"
 158 #include "insn_trans/trans_extra.c.inc"
 159
 160 static void loongarch_tr_translate_insn(DisasContextBase *dcbase, CPUState *cs)
 161 {
 162     CPULoongArchState *env = cs->env_ptr;
 163     DisasContext *ctx = container_of(dcbase, DisasContext, base);
 164
 165     ctx->opcode = cpu_ldl_code(env, ctx->base.pc_next);
 166
 167     if (!decode(ctx, ctx->opcode)) {
 168         qemu_log_mask(LOG_UNIMP, "Error: unknown opcode. "
 169                       TARGET_FMT_lx ": 0x%x\n",
 170                       ctx->base.pc_next, ctx->opcode);
 171         generate_exception(ctx, EXCCODE_INE);
 172     }
 173
 174     for (int i = ctx->ntemp - 1; i >= 0; --i) {
 175         tcg_temp_free(ctx->temp[i]);
 176         ctx->temp[i] = NULL;
 177     }
 178     ctx->ntemp = 0;
 179
 180     ctx->base.pc_next += 4;
 181 }
 182
 183 static void loongarch_tr_tb_stop(DisasContextBase *dcbase, CPUState *cs)
 184 {
 185     DisasContext *ctx = container_of(dcbase, DisasContext, base);
 186
 187     switch (ctx->base.is_jmp) {
 188     case DISAS_STOP:
 189         tcg_gen_movi_tl(cpu_pc, ctx->base.pc_next);
 190         tcg_gen_lookup_and_goto_ptr();
 191         break;
 192     case DISAS_TOO_MANY:
 193         gen_goto_tb(ctx, 0, ctx->base.pc_next);
 194         break;
 195     case DISAS_NORETURN:
 196         break;
 197     default:
 198         g_assert_not_reached();
 199     }
 200 }
 201
 202 static void loongarch_tr_disas_log(const DisasContextBase *dcbase,
 203                                    CPUState *cpu, FILE *logfile)
 204 {
 205     qemu_log("IN: %s\n", lookup_symbol(dcbase->pc_first));
 206     target_disas(logfile, cpu, dcbase->pc_first, dcbase->tb->size);
 207 }
 208
 209 static const TranslatorOps loongarch_tr_ops = {
 210     .init_disas_context = loongarch_tr_init_disas_context,
 211     .tb_start           = loongarch_tr_tb_start,
 212     .insn_start         = loongarch_tr_insn_start,
 213     .translate_insn     = loongarch_tr_translate_insn,
 214     .tb_stop            = loongarch_tr_tb_stop,
 215     .disas_log          = loongarch_tr_disas_log,
 216 };
 217
 218 void gen_intermediate_code(CPUState *cs, TranslationBlock *tb, int max_insns)
 219 {
 220     DisasContext ctx;
 221
 222     translator_loop(&loongarch_tr_ops, &ctx.base, cs, tb, max_insns);
 223 }
 224
 225 void loongarch_translate_init(void)
 226 {
 227     int i;
 228
 229     cpu_gpr[0] = NULL;
 230     for (i = 1; i < 32; i++) {
 231         cpu_gpr[i] = tcg_global_mem_new(cpu_env,
 232                                         offsetof(CPULoongArchState, gpr[i]),
 233                                         regnames[i]);
 234     }
 235
 236     for (i = 0; i < 32; i++) {
 237         int off = offsetof(CPULoongArchState, fpr[i]);
 238         cpu_fpr[i] = tcg_global_mem_new_i64(cpu_env, off, fregnames[i]);
 239     }
 240
 241     cpu_pc = tcg_global_mem_new(cpu_env, offsetof(CPULoongArchState, pc), "pc");
 242     cpu_fcsr0 = tcg_global_mem_new_i32(cpu_env,
 243                     offsetof(CPULoongArchState, fcsr0), "fcsr0");
 244     cpu_lladdr = tcg_global_mem_new(cpu_env,
 245                     offsetof(CPULoongArchState, lladdr), "lladdr");
 246     cpu_llval = tcg_global_mem_new(cpu_env,
 247                     offsetof(CPULoongArchState, llval), "llval");
 248 }
 249
 250 void restore_state_to_opc(CPULoongArchState *env, TranslationBlock *tb,
 251                           target_ulong *data)
 252 {
 253     env->pc = data[0];
 254 }