git.maemo.org Git - qemu/blob - target-sh4/translate.c

   1 /*
   2  *  SH4 translation
   3  *
   4  *  Copyright (c) 2005 Samuel Tardieu
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20 #include <stdarg.h>
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <inttypes.h>
  25 #include <assert.h>
  26
  27 #define DEBUG_DISAS
  28 #define SH4_DEBUG_DISAS
  29 //#define SH4_SINGLE_STEP
  30
  31 #include "cpu.h"
  32 #include "exec-all.h"
  33 #include "disas.h"
  34 #include "tcg-op.h"
  35 #include "qemu-common.h"
  36
  37 #include "helper.h"
  38 #define GEN_HELPER 1
  39 #include "helper.h"
  40
  41 typedef struct DisasContext {
  42     struct TranslationBlock *tb;
  43     target_ulong pc;
  44     uint32_t sr;
  45     uint32_t fpscr;
  46     uint16_t opcode;
  47     uint32_t flags;
  48     int bstate;
  49     int memidx;
  50     uint32_t delayed_pc;
  51     int singlestep_enabled;
  52 } DisasContext;
  53
  54 #if defined(CONFIG_USER_ONLY)
  55 #define IS_USER(ctx) 1
  56 #else
  57 #define IS_USER(ctx) (!(ctx->sr & SR_MD))
  58 #endif
  59
  60 enum {
  61     BS_NONE     = 0, /* We go out of the TB without reaching a branch or an
  62                       * exception condition
  63                       */
  64     BS_STOP     = 1, /* We want to stop translation for any reason */
  65     BS_BRANCH   = 2, /* We reached a branch condition     */
  66     BS_EXCP     = 3, /* We reached an exception condition */
  67 };
  68
  69 /* global register indexes */
  70 static TCGv_ptr cpu_env;
  71 static TCGv cpu_gregs[24];
  72 static TCGv cpu_pc, cpu_sr, cpu_ssr, cpu_spc, cpu_gbr;
  73 static TCGv cpu_vbr, cpu_sgr, cpu_dbr, cpu_mach, cpu_macl;
  74 static TCGv cpu_pr, cpu_fpscr, cpu_fpul, cpu_flags;
  75 static TCGv cpu_fregs[32];
  76
  77 /* internal register indexes */
  78 static TCGv cpu_flags, cpu_delayed_pc;
  79
  80 #include "gen-icount.h"
  81
  82 static void sh4_translate_init(void)
  83 {
  84     int i;
  85     static int done_init = 0;
  86     static const char * const gregnames[24] = {
  87         "R0_BANK0", "R1_BANK0", "R2_BANK0", "R3_BANK0",
  88         "R4_BANK0", "R5_BANK0", "R6_BANK0", "R7_BANK0",
  89         "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15",
  90         "R0_BANK1", "R1_BANK1", "R2_BANK1", "R3_BANK1",
  91         "R4_BANK1", "R5_BANK1", "R6_BANK1", "R7_BANK1"
  92     };
  93     static const char * const fregnames[32] = {
  94          "FPR0_BANK0",  "FPR1_BANK0",  "FPR2_BANK0",  "FPR3_BANK0",
  95          "FPR4_BANK0",  "FPR5_BANK0",  "FPR6_BANK0",  "FPR7_BANK0",
  96          "FPR8_BANK0",  "FPR9_BANK0", "FPR10_BANK0", "FPR11_BANK0",
  97         "FPR12_BANK0", "FPR13_BANK0", "FPR14_BANK0", "FPR15_BANK0",
  98          "FPR0_BANK1",  "FPR1_BANK1",  "FPR2_BANK1",  "FPR3_BANK1",
  99          "FPR4_BANK1",  "FPR5_BANK1",  "FPR6_BANK1",  "FPR7_BANK1",
 100          "FPR8_BANK1",  "FPR9_BANK1", "FPR10_BANK1", "FPR11_BANK1",
 101         "FPR12_BANK1", "FPR13_BANK1", "FPR14_BANK1", "FPR15_BANK1",
 102     };
 103
 104     if (done_init)
 105         return;
 106
 107     cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
 108
 109     for (i = 0; i < 24; i++)
 110         cpu_gregs[i] = tcg_global_mem_new_i32(TCG_AREG0,
 111                                               offsetof(CPUState, gregs[i]),
 112                                               gregnames[i]);
 113
 114     cpu_pc = tcg_global_mem_new_i32(TCG_AREG0,
 115                                     offsetof(CPUState, pc), "PC");
 116     cpu_sr = tcg_global_mem_new_i32(TCG_AREG0,
 117                                     offsetof(CPUState, sr), "SR");
 118     cpu_ssr = tcg_global_mem_new_i32(TCG_AREG0,
 119                                      offsetof(CPUState, ssr), "SSR");
 120     cpu_spc = tcg_global_mem_new_i32(TCG_AREG0,
 121                                      offsetof(CPUState, spc), "SPC");
 122     cpu_gbr = tcg_global_mem_new_i32(TCG_AREG0,
 123                                      offsetof(CPUState, gbr), "GBR");
 124     cpu_vbr = tcg_global_mem_new_i32(TCG_AREG0,
 125                                      offsetof(CPUState, vbr), "VBR");
 126     cpu_sgr = tcg_global_mem_new_i32(TCG_AREG0,
 127                                      offsetof(CPUState, sgr), "SGR");
 128     cpu_dbr = tcg_global_mem_new_i32(TCG_AREG0,
 129                                      offsetof(CPUState, dbr), "DBR");
 130     cpu_mach = tcg_global_mem_new_i32(TCG_AREG0,
 131                                       offsetof(CPUState, mach), "MACH");
 132     cpu_macl = tcg_global_mem_new_i32(TCG_AREG0,
 133                                       offsetof(CPUState, macl), "MACL");
 134     cpu_pr = tcg_global_mem_new_i32(TCG_AREG0,
 135                                     offsetof(CPUState, pr), "PR");
 136     cpu_fpscr = tcg_global_mem_new_i32(TCG_AREG0,
 137                                        offsetof(CPUState, fpscr), "FPSCR");
 138     cpu_fpul = tcg_global_mem_new_i32(TCG_AREG0,
 139                                       offsetof(CPUState, fpul), "FPUL");
 140
 141     cpu_flags = tcg_global_mem_new_i32(TCG_AREG0,
 142                                        offsetof(CPUState, flags), "_flags_");
 143     cpu_delayed_pc = tcg_global_mem_new_i32(TCG_AREG0,
 144                                             offsetof(CPUState, delayed_pc),
 145                                             "_delayed_pc_");
 146
 147     for (i = 0; i < 32; i++)
 148         cpu_fregs[i] = tcg_global_mem_new_i32(TCG_AREG0,
 149                                               offsetof(CPUState, fregs[i]),
 150                                               fregnames[i]);
 151
 152     /* register helpers */
 153 #define GEN_HELPER 2
 154 #include "helper.h"
 155
 156     done_init = 1;
 157 }
 158
 159 void cpu_dump_state(CPUState * env, FILE * f,
 160                     int (*cpu_fprintf) (FILE * f, const char *fmt, ...),
 161                     int flags)
 162 {
 163     int i;
 164     cpu_fprintf(f, "pc=0x%08x sr=0x%08x pr=0x%08x fpscr=0x%08x\n",
 165                 env->pc, env->sr, env->pr, env->fpscr);
 166     cpu_fprintf(f, "spc=0x%08x ssr=0x%08x gbr=0x%08x vbr=0x%08x\n",
 167                 env->spc, env->ssr, env->gbr, env->vbr);
 168     cpu_fprintf(f, "sgr=0x%08x dbr=0x%08x delayed_pc=0x%08x fpul=0x%08x\n",
 169                 env->sgr, env->dbr, env->delayed_pc, env->fpul);
 170     for (i = 0; i < 24; i += 4) {
 171         cpu_fprintf(f, "r%d=0x%08x r%d=0x%08x r%d=0x%08x r%d=0x%08x\n",
 172                     i, env->gregs[i], i + 1, env->gregs[i + 1],
 173                     i + 2, env->gregs[i + 2], i + 3, env->gregs[i + 3]);
 174     }
 175     if (env->flags & DELAY_SLOT) {
 176         cpu_fprintf(f, "in delay slot (delayed_pc=0x%08x)\n",
 177                     env->delayed_pc);
 178     } else if (env->flags & DELAY_SLOT_CONDITIONAL) {
 179         cpu_fprintf(f, "in conditional delay slot (delayed_pc=0x%08x)\n",
 180                     env->delayed_pc);
 181     }
 182 }
 183
 184 void cpu_sh4_reset(CPUSH4State * env)
 185 {
 186 #if defined(CONFIG_USER_ONLY)
 187     env->sr = SR_FD;            /* FD - kernel does lazy fpu context switch */
 188 #else
 189     env->sr = 0x700000F0;       /* MD, RB, BL, I3-I0 */
 190 #endif
 191     env->vbr = 0;
 192     env->pc = 0xA0000000;
 193 #if defined(CONFIG_USER_ONLY)
 194     env->fpscr = FPSCR_PR; /* value for userspace according to the kernel */
 195     set_float_rounding_mode(float_round_nearest_even, &env->fp_status); /* ?! */
 196 #else
 197     env->fpscr = 0x00040001; /* CPU reset value according to SH4 manual */
 198     set_float_rounding_mode(float_round_to_zero, &env->fp_status);
 199 #endif
 200     env->mmucr = 0;
 201 }
 202
 203 typedef struct {
 204     const char *name;
 205     int id;
 206     uint32_t pvr;
 207     uint32_t prr;
 208     uint32_t cvr;
 209 } sh4_def_t;
 210
 211 static sh4_def_t sh4_defs[] = {
 212     {
 213         .name = "SH7750R",
 214         .id = SH_CPU_SH7750R,
 215         .pvr = 0x00050000,
 216         .prr = 0x00000100,
 217         .cvr = 0x00110000,
 218     }, {
 219         .name = "SH7751R",
 220         .id = SH_CPU_SH7751R,
 221         .pvr = 0x04050005,
 222         .prr = 0x00000113,
 223         .cvr = 0x00110000,      /* Neutered caches, should be 0x20480000 */
 224     },
 225 };
 226
 227 static const sh4_def_t *cpu_sh4_find_by_name(const char *name)
 228 {
 229     int i;
 230
 231     if (strcasecmp(name, "any") == 0)
 232         return &sh4_defs[0];
 233
 234     for (i = 0; i < sizeof(sh4_defs) / sizeof(*sh4_defs); i++)
 235         if (strcasecmp(name, sh4_defs[i].name) == 0)
 236             return &sh4_defs[i];
 237
 238     return NULL;
 239 }
 240
 241 void sh4_cpu_list(FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...))
 242 {
 243     int i;
 244
 245     for (i = 0; i < sizeof(sh4_defs) / sizeof(*sh4_defs); i++)
 246         (*cpu_fprintf)(f, "%s\n", sh4_defs[i].name);
 247 }
 248
 249 static void cpu_sh4_register(CPUSH4State *env, const sh4_def_t *def)
 250 {
 251     env->pvr = def->pvr;
 252     env->prr = def->prr;
 253     env->cvr = def->cvr;
 254     env->id = def->id;
 255 }
 256
 257 CPUSH4State *cpu_sh4_init(const char *cpu_model)
 258 {
 259     CPUSH4State *env;
 260     const sh4_def_t *def;
 261
 262     def = cpu_sh4_find_by_name(cpu_model);
 263     if (!def)
 264         return NULL;
 265     env = qemu_mallocz(sizeof(CPUSH4State));
 266     if (!env)
 267         return NULL;
 268     cpu_exec_init(env);
 269     sh4_translate_init();
 270     env->cpu_model_str = cpu_model;
 271     cpu_sh4_reset(env);
 272     cpu_sh4_register(env, def);
 273     tlb_flush(env, 1);
 274     return env;
 275 }
 276
 277 static void gen_goto_tb(DisasContext * ctx, int n, target_ulong dest)
 278 {
 279     TranslationBlock *tb;
 280     tb = ctx->tb;
 281
 282     if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK) &&
 283         !ctx->singlestep_enabled) {
 284         /* Use a direct jump if in same page and singlestep not enabled */
 285         tcg_gen_goto_tb(n);
 286         tcg_gen_movi_i32(cpu_pc, dest);
 287         tcg_gen_exit_tb((long) tb + n);
 288     } else {
 289         tcg_gen_movi_i32(cpu_pc, dest);
 290         if (ctx->singlestep_enabled)
 291             gen_helper_debug();
 292         tcg_gen_exit_tb(0);
 293     }
 294 }
 295
 296 static void gen_jump(DisasContext * ctx)
 297 {
 298     if (ctx->delayed_pc == (uint32_t) - 1) {
 299         /* Target is not statically known, it comes necessarily from a
 300            delayed jump as immediate jump are conditinal jumps */
 301         tcg_gen_mov_i32(cpu_pc, cpu_delayed_pc);
 302         if (ctx->singlestep_enabled)
 303             gen_helper_debug();
 304         tcg_gen_exit_tb(0);
 305     } else {
 306         gen_goto_tb(ctx, 0, ctx->delayed_pc);
 307     }
 308 }
 309
 310 static inline void gen_branch_slot(uint32_t delayed_pc, int t)
 311 {
 312     TCGv sr;
 313     int label = gen_new_label();
 314     tcg_gen_movi_i32(cpu_delayed_pc, delayed_pc);
 315     sr = tcg_temp_new();
 316     tcg_gen_andi_i32(sr, cpu_sr, SR_T);
 317     tcg_gen_brcondi_i32(TCG_COND_NE, sr, t ? SR_T : 0, label);
 318     tcg_gen_ori_i32(cpu_flags, cpu_flags, DELAY_SLOT_TRUE);
 319     gen_set_label(label);
 320 }
 321
 322 /* Immediate conditional jump (bt or bf) */
 323 static void gen_conditional_jump(DisasContext * ctx,
 324                                  target_ulong ift, target_ulong ifnott)
 325 {
 326     int l1;
 327     TCGv sr;
 328
 329     l1 = gen_new_label();
 330     sr = tcg_temp_new();
 331     tcg_gen_andi_i32(sr, cpu_sr, SR_T);
 332     tcg_gen_brcondi_i32(TCG_COND_EQ, sr, SR_T, l1);
 333     gen_goto_tb(ctx, 0, ifnott);
 334     gen_set_label(l1);
 335     gen_goto_tb(ctx, 1, ift);
 336 }
 337
 338 /* Delayed conditional jump (bt or bf) */
 339 static void gen_delayed_conditional_jump(DisasContext * ctx)
 340 {
 341     int l1;
 342     TCGv ds;
 343
 344     l1 = gen_new_label();
 345     ds = tcg_temp_new();
 346     tcg_gen_andi_i32(ds, cpu_flags, DELAY_SLOT_TRUE);
 347     tcg_gen_brcondi_i32(TCG_COND_EQ, ds, DELAY_SLOT_TRUE, l1);
 348     gen_goto_tb(ctx, 1, ctx->pc + 2);
 349     gen_set_label(l1);
 350     tcg_gen_andi_i32(cpu_flags, cpu_flags, ~DELAY_SLOT_TRUE);
 351     gen_jump(ctx);
 352 }
 353
 354 static inline void gen_set_t(void)
 355 {
 356     tcg_gen_ori_i32(cpu_sr, cpu_sr, SR_T);
 357 }
 358
 359 static inline void gen_clr_t(void)
 360 {
 361     tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T);
 362 }
 363
 364 static inline void gen_cmp(int cond, TCGv t0, TCGv t1)
 365 {
 366     int label1 = gen_new_label();
 367     int label2 = gen_new_label();
 368     tcg_gen_brcond_i32(cond, t1, t0, label1);
 369     gen_clr_t();
 370     tcg_gen_br(label2);
 371     gen_set_label(label1);
 372     gen_set_t();
 373     gen_set_label(label2);
 374 }
 375
 376 static inline void gen_cmp_imm(int cond, TCGv t0, int32_t imm)
 377 {
 378     int label1 = gen_new_label();
 379     int label2 = gen_new_label();
 380     tcg_gen_brcondi_i32(cond, t0, imm, label1);
 381     gen_clr_t();
 382     tcg_gen_br(label2);
 383     gen_set_label(label1);
 384     gen_set_t();
 385     gen_set_label(label2);
 386 }
 387
 388 static inline void gen_store_flags(uint32_t flags)
 389 {
 390     tcg_gen_andi_i32(cpu_flags, cpu_flags, DELAY_SLOT_TRUE);
 391     tcg_gen_ori_i32(cpu_flags, cpu_flags, flags);
 392 }
 393
 394 static inline void gen_copy_bit_i32(TCGv t0, int p0, TCGv t1, int p1)
 395 {
 396     TCGv tmp = tcg_temp_new();
 397
 398     p0 &= 0x1f;
 399     p1 &= 0x1f;
 400
 401     tcg_gen_andi_i32(tmp, t1, (1 << p1));
 402     tcg_gen_andi_i32(t0, t0, ~(1 << p0));
 403     if (p0 < p1)
 404         tcg_gen_shri_i32(tmp, tmp, p1 - p0);
 405     else if (p0 > p1)
 406         tcg_gen_shli_i32(tmp, tmp, p0 - p1);
 407     tcg_gen_or_i32(t0, t0, tmp);
 408
 409     tcg_temp_free(tmp);
 410 }
 411
 412 static inline void gen_load_fpr64(TCGv_i64 t, int reg)
 413 {
 414     tcg_gen_concat_i32_i64(t, cpu_fregs[reg + 1], cpu_fregs[reg]);
 415 }
 416
 417 static inline void gen_store_fpr64 (TCGv_i64 t, int reg)
 418 {
 419     TCGv_i32 tmp = tcg_temp_new_i32();
 420     tcg_gen_trunc_i64_i32(tmp, t);
 421     tcg_gen_mov_i32(cpu_fregs[reg + 1], tmp);
 422     tcg_gen_shri_i64(t, t, 32);
 423     tcg_gen_trunc_i64_i32(tmp, t);
 424     tcg_gen_mov_i32(cpu_fregs[reg], tmp);
 425     tcg_temp_free_i32(tmp);
 426 }
 427
 428 #define B3_0 (ctx->opcode & 0xf)
 429 #define B6_4 ((ctx->opcode >> 4) & 0x7)
 430 #define B7_4 ((ctx->opcode >> 4) & 0xf)
 431 #define B7_0 (ctx->opcode & 0xff)
 432 #define B7_0s ((int32_t) (int8_t) (ctx->opcode & 0xff))
 433 #define B11_0s (ctx->opcode & 0x800 ? 0xfffff000 | (ctx->opcode & 0xfff) : \
 434   (ctx->opcode & 0xfff))
 435 #define B11_8 ((ctx->opcode >> 8) & 0xf)
 436 #define B15_12 ((ctx->opcode >> 12) & 0xf)
 437
 438 #define REG(x) ((x) < 8 && (ctx->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB) ? \
 439                 (cpu_gregs[x + 16]) : (cpu_gregs[x]))
 440
 441 #define ALTREG(x) ((x) < 8 && (ctx->sr & (SR_MD | SR_RB)) != (SR_MD | SR_RB) \
 442                 ? (cpu_gregs[x + 16]) : (cpu_gregs[x]))
 443
 444 #define FREG(x) (ctx->fpscr & FPSCR_FR ? (x) ^ 0x10 : (x))
 445 #define XHACK(x) ((((x) & 1 ) << 4) | ((x) & 0xe))
 446 #define XREG(x) (ctx->fpscr & FPSCR_FR ? XHACK(x) ^ 0x10 : XHACK(x))
 447 #define DREG(x) FREG(x) /* Assumes lsb of (x) is always 0 */
 448
 449 #define CHECK_NOT_DELAY_SLOT \
 450   if (ctx->flags & (DELAY_SLOT | DELAY_SLOT_CONDITIONAL)) \
 451   {gen_helper_raise_slot_illegal_instruction(); ctx->bstate = BS_EXCP; \
 452    return;}
 453
 454 #define CHECK_PRIVILEGED                                      \
 455   if (IS_USER(ctx)) {                                         \
 456       gen_helper_raise_illegal_instruction();                 \
 457       ctx->bstate = BS_EXCP;                                  \
 458       return;                                                 \
 459   }
 460
 461 static void _decode_opc(DisasContext * ctx)
 462 {
 463 #if 0
 464     fprintf(stderr, "Translating opcode 0x%04x\n", ctx->opcode);
 465 #endif
 466     switch (ctx->opcode) {
 467     case 0x0019:                /* div0u */
 468         tcg_gen_andi_i32(cpu_sr, cpu_sr, ~(SR_M | SR_Q | SR_T));
 469         return;
 470     case 0x000b:                /* rts */
 471         CHECK_NOT_DELAY_SLOT
 472         tcg_gen_mov_i32(cpu_delayed_pc, cpu_pr);
 473         ctx->flags |= DELAY_SLOT;
 474         ctx->delayed_pc = (uint32_t) - 1;
 475         return;
 476     case 0x0028:                /* clrmac */
 477         tcg_gen_movi_i32(cpu_mach, 0);
 478         tcg_gen_movi_i32(cpu_macl, 0);
 479         return;
 480     case 0x0048:                /* clrs */
 481         tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_S);
 482         return;
 483     case 0x0008:                /* clrt */
 484         gen_clr_t();
 485         return;
 486     case 0x0038:                /* ldtlb */
 487         CHECK_PRIVILEGED
 488         gen_helper_ldtlb();
 489         return;
 490     case 0x002b:                /* rte */
 491         CHECK_PRIVILEGED
 492         CHECK_NOT_DELAY_SLOT
 493         tcg_gen_mov_i32(cpu_sr, cpu_ssr);
 494         tcg_gen_mov_i32(cpu_delayed_pc, cpu_spc);
 495         ctx->flags |= DELAY_SLOT;
 496         ctx->delayed_pc = (uint32_t) - 1;
 497         return;
 498     case 0x0058:                /* sets */
 499         tcg_gen_ori_i32(cpu_sr, cpu_sr, SR_S);
 500         return;
 501     case 0x0018:                /* sett */
 502         gen_set_t();
 503         return;
 504     case 0xfbfd:                /* frchg */
 505         tcg_gen_xori_i32(cpu_fpscr, cpu_fpscr, FPSCR_FR);
 506         ctx->bstate = BS_STOP;
 507         return;
 508     case 0xf3fd:                /* fschg */
 509         tcg_gen_xori_i32(cpu_fpscr, cpu_fpscr, FPSCR_SZ);
 510         ctx->bstate = BS_STOP;
 511         return;
 512     case 0x0009:                /* nop */
 513         return;
 514     case 0x001b:                /* sleep */
 515         CHECK_PRIVILEGED
 516         gen_helper_sleep(tcg_const_i32(ctx->pc + 2));
 517         return;
 518     }
 519
 520     switch (ctx->opcode & 0xf000) {
 521     case 0x1000:                /* mov.l Rm,@(disp,Rn) */
 522         {
 523             TCGv addr = tcg_temp_new();
 524             tcg_gen_addi_i32(addr, REG(B11_8), B3_0 * 4);
 525             tcg_gen_qemu_st32(REG(B7_4), addr, ctx->memidx);
 526             tcg_temp_free(addr);
 527         }
 528         return;
 529     case 0x5000:                /* mov.l @(disp,Rm),Rn */
 530         {
 531             TCGv addr = tcg_temp_new();
 532             tcg_gen_addi_i32(addr, REG(B7_4), B3_0 * 4);
 533             tcg_gen_qemu_ld32s(REG(B11_8), addr, ctx->memidx);
 534             tcg_temp_free(addr);
 535         }
 536         return;
 537     case 0xe000:                /* mov #imm,Rn */
 538         tcg_gen_movi_i32(REG(B11_8), B7_0s);
 539         return;
 540     case 0x9000:                /* mov.w @(disp,PC),Rn */
 541         {
 542             TCGv addr = tcg_const_i32(ctx->pc + 4 + B7_0 * 2);
 543             tcg_gen_qemu_ld16s(REG(B11_8), addr, ctx->memidx);
 544             tcg_temp_free(addr);
 545         }
 546         return;
 547     case 0xd000:                /* mov.l @(disp,PC),Rn */
 548         {
 549             TCGv addr = tcg_const_i32((ctx->pc + 4 + B7_0 * 4) & ~3);
 550             tcg_gen_qemu_ld32s(REG(B11_8), addr, ctx->memidx);
 551             tcg_temp_free(addr);
 552         }
 553         return;
 554     case 0x7000:                /* add #imm,Rn */
 555         tcg_gen_addi_i32(REG(B11_8), REG(B11_8), B7_0s);
 556         return;
 557     case 0xa000:                /* bra disp */
 558         CHECK_NOT_DELAY_SLOT
 559         ctx->delayed_pc = ctx->pc + 4 + B11_0s * 2;
 560         tcg_gen_movi_i32(cpu_delayed_pc, ctx->delayed_pc);
 561         ctx->flags |= DELAY_SLOT;
 562         return;
 563     case 0xb000:                /* bsr disp */
 564         CHECK_NOT_DELAY_SLOT
 565         tcg_gen_movi_i32(cpu_pr, ctx->pc + 4);
 566         ctx->delayed_pc = ctx->pc + 4 + B11_0s * 2;
 567         tcg_gen_movi_i32(cpu_delayed_pc, ctx->delayed_pc);
 568         ctx->flags |= DELAY_SLOT;
 569         return;
 570     }
 571
 572     switch (ctx->opcode & 0xf00f) {
 573     case 0x6003:                /* mov Rm,Rn */
 574         tcg_gen_mov_i32(REG(B11_8), REG(B7_4));
 575         return;
 576     case 0x2000:                /* mov.b Rm,@Rn */
 577         tcg_gen_qemu_st8(REG(B7_4), REG(B11_8), ctx->memidx);
 578         return;
 579     case 0x2001:                /* mov.w Rm,@Rn */
 580         tcg_gen_qemu_st16(REG(B7_4), REG(B11_8), ctx->memidx);
 581         return;
 582     case 0x2002:                /* mov.l Rm,@Rn */
 583         tcg_gen_qemu_st32(REG(B7_4), REG(B11_8), ctx->memidx);
 584         return;
 585     case 0x6000:                /* mov.b @Rm,Rn */
 586         tcg_gen_qemu_ld8s(REG(B11_8), REG(B7_4), ctx->memidx);
 587         return;
 588     case 0x6001:                /* mov.w @Rm,Rn */
 589         tcg_gen_qemu_ld16s(REG(B11_8), REG(B7_4), ctx->memidx);
 590         return;
 591     case 0x6002:                /* mov.l @Rm,Rn */
 592         tcg_gen_qemu_ld32s(REG(B11_8), REG(B7_4), ctx->memidx);
 593         return;
 594     case 0x2004:                /* mov.b Rm,@-Rn */
 595         {
 596             TCGv addr = tcg_temp_new();
 597             tcg_gen_subi_i32(addr, REG(B11_8), 1);
 598             tcg_gen_qemu_st8(REG(B7_4), addr, ctx->memidx);     /* might cause re-execution */
 599             tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 1);        /* modify register status */
 600             tcg_temp_free(addr);
 601         }
 602         return;
 603     case 0x2005:                /* mov.w Rm,@-Rn */
 604         {
 605             TCGv addr = tcg_temp_new();
 606             tcg_gen_subi_i32(addr, REG(B11_8), 2);
 607             tcg_gen_qemu_st16(REG(B7_4), addr, ctx->memidx);
 608             tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 2);
 609             tcg_temp_free(addr);
 610         }
 611         return;
 612     case 0x2006:                /* mov.l Rm,@-Rn */
 613         {
 614             TCGv addr = tcg_temp_new();
 615             tcg_gen_subi_i32(addr, REG(B11_8), 4);
 616             tcg_gen_qemu_st32(REG(B7_4), addr, ctx->memidx);
 617             tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4);
 618         }
 619         return;
 620     case 0x6004:                /* mov.b @Rm+,Rn */
 621         tcg_gen_qemu_ld8s(REG(B11_8), REG(B7_4), ctx->memidx);
 622         if ( B11_8 != B7_4 )
 623                 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 1);
 624         return;
 625     case 0x6005:                /* mov.w @Rm+,Rn */
 626         tcg_gen_qemu_ld16s(REG(B11_8), REG(B7_4), ctx->memidx);
 627         if ( B11_8 != B7_4 )
 628                 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 2);
 629         return;
 630     case 0x6006:                /* mov.l @Rm+,Rn */
 631         tcg_gen_qemu_ld32s(REG(B11_8), REG(B7_4), ctx->memidx);
 632         if ( B11_8 != B7_4 )
 633                 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 4);
 634         return;
 635     case 0x0004:                /* mov.b Rm,@(R0,Rn) */
 636         {
 637             TCGv addr = tcg_temp_new();
 638             tcg_gen_add_i32(addr, REG(B11_8), REG(0));
 639             tcg_gen_qemu_st8(REG(B7_4), addr, ctx->memidx);
 640             tcg_temp_free(addr);
 641         }
 642         return;
 643     case 0x0005:                /* mov.w Rm,@(R0,Rn) */
 644         {
 645             TCGv addr = tcg_temp_new();
 646             tcg_gen_add_i32(addr, REG(B11_8), REG(0));
 647             tcg_gen_qemu_st16(REG(B7_4), addr, ctx->memidx);
 648             tcg_temp_free(addr);
 649         }
 650         return;
 651     case 0x0006:                /* mov.l Rm,@(R0,Rn) */
 652         {
 653             TCGv addr = tcg_temp_new();
 654             tcg_gen_add_i32(addr, REG(B11_8), REG(0));
 655             tcg_gen_qemu_st32(REG(B7_4), addr, ctx->memidx);
 656             tcg_temp_free(addr);
 657         }
 658         return;
 659     case 0x000c:                /* mov.b @(R0,Rm),Rn */
 660         {
 661             TCGv addr = tcg_temp_new();
 662             tcg_gen_add_i32(addr, REG(B7_4), REG(0));
 663             tcg_gen_qemu_ld8s(REG(B11_8), addr, ctx->memidx);
 664             tcg_temp_free(addr);
 665         }
 666         return;
 667     case 0x000d:                /* mov.w @(R0,Rm),Rn */
 668         {
 669             TCGv addr = tcg_temp_new();
 670             tcg_gen_add_i32(addr, REG(B7_4), REG(0));
 671             tcg_gen_qemu_ld16s(REG(B11_8), addr, ctx->memidx);
 672             tcg_temp_free(addr);
 673         }
 674         return;
 675     case 0x000e:                /* mov.l @(R0,Rm),Rn */
 676         {
 677             TCGv addr = tcg_temp_new();
 678             tcg_gen_add_i32(addr, REG(B7_4), REG(0));
 679             tcg_gen_qemu_ld32s(REG(B11_8), addr, ctx->memidx);
 680             tcg_temp_free(addr);
 681         }
 682         return;
 683     case 0x6008:                /* swap.b Rm,Rn */
 684         {
 685             TCGv highw, high, low;
 686             highw = tcg_temp_new();
 687             tcg_gen_andi_i32(highw, REG(B7_4), 0xffff0000);
 688             high = tcg_temp_new();
 689             tcg_gen_ext8u_i32(high, REG(B7_4));
 690             tcg_gen_shli_i32(high, high, 8);
 691             low = tcg_temp_new();
 692             tcg_gen_shri_i32(low, REG(B7_4), 8);
 693             tcg_gen_ext8u_i32(low, low);
 694             tcg_gen_or_i32(REG(B11_8), high, low);
 695             tcg_gen_or_i32(REG(B11_8), REG(B11_8), highw);
 696             tcg_temp_free(low);
 697             tcg_temp_free(high);
 698         }
 699         return;
 700     case 0x6009:                /* swap.w Rm,Rn */
 701         {
 702             TCGv high, low;
 703             high = tcg_temp_new();
 704             tcg_gen_ext16u_i32(high, REG(B7_4));
 705             tcg_gen_shli_i32(high, high, 16);
 706             low = tcg_temp_new();
 707             tcg_gen_shri_i32(low, REG(B7_4), 16);
 708             tcg_gen_ext16u_i32(low, low);
 709             tcg_gen_or_i32(REG(B11_8), high, low);
 710             tcg_temp_free(low);
 711             tcg_temp_free(high);
 712         }
 713         return;
 714     case 0x200d:                /* xtrct Rm,Rn */
 715         {
 716             TCGv high, low;
 717             high = tcg_temp_new();
 718             tcg_gen_ext16u_i32(high, REG(B7_4));
 719             tcg_gen_shli_i32(high, high, 16);
 720             low = tcg_temp_new();
 721             tcg_gen_shri_i32(low, REG(B11_8), 16);
 722             tcg_gen_ext16u_i32(low, low);
 723             tcg_gen_or_i32(REG(B11_8), high, low);
 724             tcg_temp_free(low);
 725             tcg_temp_free(high);
 726         }
 727         return;
 728     case 0x300c:                /* add Rm,Rn */
 729         tcg_gen_add_i32(REG(B11_8), REG(B11_8), REG(B7_4));
 730         return;
 731     case 0x300e:                /* addc Rm,Rn */
 732         gen_helper_addc(REG(B11_8), REG(B7_4), REG(B11_8));
 733         return;
 734     case 0x300f:                /* addv Rm,Rn */
 735         gen_helper_addv(REG(B11_8), REG(B7_4), REG(B11_8));
 736         return;
 737     case 0x2009:                /* and Rm,Rn */
 738         tcg_gen_and_i32(REG(B11_8), REG(B11_8), REG(B7_4));
 739         return;
 740     case 0x3000:                /* cmp/eq Rm,Rn */
 741         gen_cmp(TCG_COND_EQ, REG(B7_4), REG(B11_8));
 742         return;
 743     case 0x3003:                /* cmp/ge Rm,Rn */
 744         gen_cmp(TCG_COND_GE, REG(B7_4), REG(B11_8));
 745         return;
 746     case 0x3007:                /* cmp/gt Rm,Rn */
 747         gen_cmp(TCG_COND_GT, REG(B7_4), REG(B11_8));
 748         return;
 749     case 0x3006:                /* cmp/hi Rm,Rn */
 750         gen_cmp(TCG_COND_GTU, REG(B7_4), REG(B11_8));
 751         return;
 752     case 0x3002:                /* cmp/hs Rm,Rn */
 753         gen_cmp(TCG_COND_GEU, REG(B7_4), REG(B11_8));
 754         return;
 755     case 0x200c:                /* cmp/str Rm,Rn */
 756         {
 757             int label1 = gen_new_label();
 758             int label2 = gen_new_label();
 759             TCGv cmp1 = tcg_temp_local_new(TCG_TYPE_I32);
 760             TCGv cmp2 = tcg_temp_local_new(TCG_TYPE_I32);
 761             tcg_gen_xor_i32(cmp1, REG(B7_4), REG(B11_8));
 762             tcg_gen_andi_i32(cmp2, cmp1, 0xff000000);
 763             tcg_gen_brcondi_i32(TCG_COND_EQ, cmp2, 0, label1);
 764             tcg_gen_andi_i32(cmp2, cmp1, 0x00ff0000);
 765             tcg_gen_brcondi_i32(TCG_COND_EQ, cmp2, 0, label1);
 766             tcg_gen_andi_i32(cmp2, cmp1, 0x0000ff00);
 767             tcg_gen_brcondi_i32(TCG_COND_EQ, cmp2, 0, label1);
 768             tcg_gen_andi_i32(cmp2, cmp1, 0x000000ff);
 769             tcg_gen_brcondi_i32(TCG_COND_EQ, cmp2, 0, label1);
 770             tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T);
 771             tcg_gen_br(label2);
 772             gen_set_label(label1);
 773             tcg_gen_ori_i32(cpu_sr, cpu_sr, SR_T);
 774             gen_set_label(label2);
 775             tcg_temp_free(cmp2);
 776             tcg_temp_free(cmp1);
 777         }
 778         return;
 779     case 0x2007:                /* div0s Rm,Rn */
 780         {
 781             gen_copy_bit_i32(cpu_sr, 8, REG(B11_8), 31);        /* SR_Q */
 782             gen_copy_bit_i32(cpu_sr, 9, REG(B7_4), 31);         /* SR_M */
 783             TCGv val = tcg_temp_new();
 784             tcg_gen_xor_i32(val, REG(B7_4), REG(B11_8));
 785             gen_copy_bit_i32(cpu_sr, 0, val, 31);               /* SR_T */
 786             tcg_temp_free(val);
 787         }
 788         return;
 789     case 0x3004:                /* div1 Rm,Rn */
 790         gen_helper_div1(REG(B11_8), REG(B7_4), REG(B11_8));
 791         return;
 792     case 0x300d:                /* dmuls.l Rm,Rn */
 793         {
 794             TCGv_i64 tmp1 = tcg_temp_new_i64();
 795             TCGv_i64 tmp2 = tcg_temp_new_i64();
 796
 797             tcg_gen_ext_i32_i64(tmp1, REG(B7_4));
 798             tcg_gen_ext_i32_i64(tmp2, REG(B11_8));
 799             tcg_gen_mul_i64(tmp1, tmp1, tmp2);
 800             tcg_gen_trunc_i64_i32(cpu_macl, tmp1);
 801             tcg_gen_shri_i64(tmp1, tmp1, 32);
 802             tcg_gen_trunc_i64_i32(cpu_mach, tmp1);
 803
 804             tcg_temp_free_i64(tmp2);
 805             tcg_temp_free_i64(tmp1);
 806         }
 807         return;
 808     case 0x3005:                /* dmulu.l Rm,Rn */
 809         {
 810             TCGv_i64 tmp1 = tcg_temp_new_i64();
 811             TCGv_i64 tmp2 = tcg_temp_new_i64();
 812
 813             tcg_gen_extu_i32_i64(tmp1, REG(B7_4));
 814             tcg_gen_extu_i32_i64(tmp2, REG(B11_8));
 815             tcg_gen_mul_i64(tmp1, tmp1, tmp2);
 816             tcg_gen_trunc_i64_i32(cpu_macl, tmp1);
 817             tcg_gen_shri_i64(tmp1, tmp1, 32);
 818             tcg_gen_trunc_i64_i32(cpu_mach, tmp1);
 819
 820             tcg_temp_free_i64(tmp2);
 821             tcg_temp_free_i64(tmp1);
 822         }
 823         return;
 824     case 0x600e:                /* exts.b Rm,Rn */
 825         tcg_gen_ext8s_i32(REG(B11_8), REG(B7_4));
 826         return;
 827     case 0x600f:                /* exts.w Rm,Rn */
 828         tcg_gen_ext16s_i32(REG(B11_8), REG(B7_4));
 829         return;
 830     case 0x600c:                /* extu.b Rm,Rn */
 831         tcg_gen_ext8u_i32(REG(B11_8), REG(B7_4));
 832         return;
 833     case 0x600d:                /* extu.w Rm,Rn */
 834         tcg_gen_ext16u_i32(REG(B11_8), REG(B7_4));
 835         return;
 836     case 0x000f:                /* mac.l @Rm+,@Rn+ */
 837         {
 838             TCGv arg0, arg1;
 839             arg0 = tcg_temp_new();
 840             tcg_gen_qemu_ld32s(arg0, REG(B7_4), ctx->memidx);
 841             arg1 = tcg_temp_new();
 842             tcg_gen_qemu_ld32s(arg1, REG(B11_8), ctx->memidx);
 843             gen_helper_macl(arg0, arg1);
 844             tcg_temp_free(arg1);
 845             tcg_temp_free(arg0);
 846             tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 4);
 847             tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
 848         }
 849         return;
 850     case 0x400f:                /* mac.w @Rm+,@Rn+ */
 851         {
 852             TCGv arg0, arg1;
 853             arg0 = tcg_temp_new();
 854             tcg_gen_qemu_ld32s(arg0, REG(B7_4), ctx->memidx);
 855             arg1 = tcg_temp_new();
 856             tcg_gen_qemu_ld32s(arg1, REG(B11_8), ctx->memidx);
 857             gen_helper_macw(arg0, arg1);
 858             tcg_temp_free(arg1);
 859             tcg_temp_free(arg0);
 860             tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 2);
 861             tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 2);
 862         }
 863         return;
 864     case 0x0007:                /* mul.l Rm,Rn */
 865         tcg_gen_mul_i32(cpu_macl, REG(B7_4), REG(B11_8));
 866         return;
 867     case 0x200f:                /* muls.w Rm,Rn */
 868         {
 869             TCGv arg0, arg1;
 870             arg0 = tcg_temp_new();
 871             tcg_gen_ext16s_i32(arg0, REG(B7_4));
 872             arg1 = tcg_temp_new();
 873             tcg_gen_ext16s_i32(arg1, REG(B11_8));
 874             tcg_gen_mul_i32(cpu_macl, arg0, arg1);
 875             tcg_temp_free(arg1);
 876             tcg_temp_free(arg0);
 877         }
 878         return;
 879     case 0x200e:                /* mulu.w Rm,Rn */
 880         {
 881             TCGv arg0, arg1;
 882             arg0 = tcg_temp_new();
 883             tcg_gen_ext16u_i32(arg0, REG(B7_4));
 884             arg1 = tcg_temp_new();
 885             tcg_gen_ext16u_i32(arg1, REG(B11_8));
 886             tcg_gen_mul_i32(cpu_macl, arg0, arg1);
 887             tcg_temp_free(arg1);
 888             tcg_temp_free(arg0);
 889         }
 890         return;
 891     case 0x600b:                /* neg Rm,Rn */
 892         tcg_gen_neg_i32(REG(B11_8), REG(B7_4));
 893         return;
 894     case 0x600a:                /* negc Rm,Rn */
 895         gen_helper_negc(REG(B11_8), REG(B7_4));
 896         return;
 897     case 0x6007:                /* not Rm,Rn */
 898         tcg_gen_not_i32(REG(B11_8), REG(B7_4));
 899         return;
 900     case 0x200b:                /* or Rm,Rn */
 901         tcg_gen_or_i32(REG(B11_8), REG(B11_8), REG(B7_4));
 902         return;
 903     case 0x400c:                /* shad Rm,Rn */
 904         {
 905             int label1 = gen_new_label();
 906             int label2 = gen_new_label();
 907             int label3 = gen_new_label();
 908             int label4 = gen_new_label();
 909             TCGv shift = tcg_temp_local_new(TCG_TYPE_I32);
 910             tcg_gen_brcondi_i32(TCG_COND_LT, REG(B7_4), 0, label1);
 911             /* Rm positive, shift to the left */
 912             tcg_gen_andi_i32(shift, REG(B7_4), 0x1f);
 913             tcg_gen_shl_i32(REG(B11_8), REG(B11_8), shift);
 914             tcg_gen_br(label4);
 915             /* Rm negative, shift to the right */
 916             gen_set_label(label1);
 917             tcg_gen_andi_i32(shift, REG(B7_4), 0x1f);
 918             tcg_gen_brcondi_i32(TCG_COND_EQ, shift, 0, label2);
 919             tcg_gen_not_i32(shift, REG(B7_4));
 920             tcg_gen_andi_i32(shift, shift, 0x1f);
 921             tcg_gen_addi_i32(shift, shift, 1);
 922             tcg_gen_sar_i32(REG(B11_8), REG(B11_8), shift);
 923             tcg_gen_br(label4);
 924             /* Rm = -32 */
 925             gen_set_label(label2);
 926             tcg_gen_brcondi_i32(TCG_COND_LT, REG(B11_8), 0, label3);
 927             tcg_gen_movi_i32(REG(B11_8), 0);
 928             tcg_gen_br(label4);
 929             gen_set_label(label3);
 930             tcg_gen_movi_i32(REG(B11_8), 0xffffffff);
 931             gen_set_label(label4);
 932             tcg_temp_free(shift);
 933         }
 934         return;
 935     case 0x400d:                /* shld Rm,Rn */
 936         {
 937             int label1 = gen_new_label();
 938             int label2 = gen_new_label();
 939             int label3 = gen_new_label();
 940             TCGv shift = tcg_temp_local_new(TCG_TYPE_I32);
 941             tcg_gen_brcondi_i32(TCG_COND_LT, REG(B7_4), 0, label1);
 942             /* Rm positive, shift to the left */
 943             tcg_gen_andi_i32(shift, REG(B7_4), 0x1f);
 944             tcg_gen_shl_i32(REG(B11_8), REG(B11_8), shift);
 945             tcg_gen_br(label3);
 946             /* Rm negative, shift to the right */
 947             gen_set_label(label1);
 948             tcg_gen_andi_i32(shift, REG(B7_4), 0x1f);
 949             tcg_gen_brcondi_i32(TCG_COND_EQ, shift, 0, label2);
 950             tcg_gen_not_i32(shift, REG(B7_4));
 951             tcg_gen_andi_i32(shift, shift, 0x1f);
 952             tcg_gen_addi_i32(shift, shift, 1);
 953             tcg_gen_shr_i32(REG(B11_8), REG(B11_8), shift);
 954             tcg_gen_br(label3);
 955             /* Rm = -32 */
 956             gen_set_label(label2);
 957             tcg_gen_movi_i32(REG(B11_8), 0);
 958             gen_set_label(label3);
 959             tcg_temp_free(shift);
 960         }
 961         return;
 962     case 0x3008:                /* sub Rm,Rn */
 963         tcg_gen_sub_i32(REG(B11_8), REG(B11_8), REG(B7_4));
 964         return;
 965     case 0x300a:                /* subc Rm,Rn */
 966         gen_helper_subc(REG(B11_8), REG(B7_4), REG(B11_8));
 967         return;
 968     case 0x300b:                /* subv Rm,Rn */
 969         gen_helper_subv(REG(B11_8), REG(B7_4), REG(B11_8));
 970         return;
 971     case 0x2008:                /* tst Rm,Rn */
 972         {
 973             TCGv val = tcg_temp_new();
 974             tcg_gen_and_i32(val, REG(B7_4), REG(B11_8));
 975             gen_cmp_imm(TCG_COND_EQ, val, 0);
 976             tcg_temp_free(val);
 977         }
 978         return;
 979     case 0x200a:                /* xor Rm,Rn */
 980         tcg_gen_xor_i32(REG(B11_8), REG(B11_8), REG(B7_4));
 981         return;
 982     case 0xf00c: /* fmov {F,D,X}Rm,{F,D,X}Rn - FPSCR: Nothing */
 983         if (ctx->fpscr & FPSCR_SZ) {
 984             TCGv_i64 fp = tcg_temp_new_i64();
 985             gen_load_fpr64(fp, XREG(B7_4));
 986             gen_store_fpr64(fp, XREG(B11_8));
 987             tcg_temp_free_i64(fp);
 988         } else {
 989             tcg_gen_mov_i32(cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B7_4)]);
 990         }
 991         return;
 992     case 0xf00a: /* fmov {F,D,X}Rm,@Rn - FPSCR: Nothing */
 993         if (ctx->fpscr & FPSCR_SZ) {
 994             TCGv_i64 fp = tcg_temp_new_i64();
 995             gen_load_fpr64(fp, XREG(B7_4));
 996             tcg_gen_qemu_st64(fp, REG(B11_8), ctx->memidx);
 997             tcg_temp_free_i64(fp);
 998         } else {
 999             tcg_gen_qemu_st32(cpu_fregs[FREG(B7_4)], REG(B11_8), ctx->memidx);
1000         }
1001         return;
1002     case 0xf008: /* fmov @Rm,{F,D,X}Rn - FPSCR: Nothing */
1003         if (ctx->fpscr & FPSCR_SZ) {
1004             TCGv_i64 fp = tcg_temp_new_i64();
1005             tcg_gen_qemu_ld64(fp, REG(B7_4), ctx->memidx);
1006             gen_store_fpr64(fp, XREG(B11_8));
1007             tcg_temp_free_i64(fp);
1008         } else {
1009             tcg_gen_qemu_ld32u(cpu_fregs[FREG(B11_8)], REG(B7_4), ctx->memidx);
1010         }
1011         return;
1012     case 0xf009: /* fmov @Rm+,{F,D,X}Rn - FPSCR: Nothing */
1013         if (ctx->fpscr & FPSCR_SZ) {
1014             TCGv_i64 fp = tcg_temp_new_i64();
1015             tcg_gen_qemu_ld64(fp, REG(B7_4), ctx->memidx);
1016             gen_store_fpr64(fp, XREG(B11_8));
1017             tcg_temp_free_i64(fp);
1018             tcg_gen_addi_i32(REG(B7_4),REG(B7_4), 8);
1019         } else {
1020             tcg_gen_qemu_ld32u(cpu_fregs[FREG(B11_8)], REG(B7_4), ctx->memidx);
1021             tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 4);
1022         }
1023         return;
1024     case 0xf00b: /* fmov {F,D,X}Rm,@-Rn - FPSCR: Nothing */
1025         if (ctx->fpscr & FPSCR_SZ) {
1026             TCGv addr;
1027             TCGv_i64 fp;
1028             addr = tcg_temp_new();
1029             tcg_gen_subi_i32(addr, REG(B11_8), 8);
1030             fp = tcg_temp_new_i64();
1031             gen_load_fpr64(fp, XREG(B7_4));
1032             tcg_gen_qemu_st64(fp, addr, ctx->memidx);
1033             tcg_temp_free_i64(fp);
1034             tcg_temp_free(addr);
1035             tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 8);
1036         } else {
1037             TCGv addr;
1038             addr = tcg_temp_new_i32();
1039             tcg_gen_subi_i32(addr, REG(B11_8), 4);
1040             tcg_gen_qemu_st32(cpu_fregs[FREG(B7_4)], addr, ctx->memidx);
1041             tcg_temp_free(addr);
1042             tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4);
1043         }
1044         return;
1045     case 0xf006: /* fmov @(R0,Rm),{F,D,X}Rm - FPSCR: Nothing */
1046         {
1047             TCGv addr = tcg_temp_new_i32();
1048             tcg_gen_add_i32(addr, REG(B7_4), REG(0));
1049             if (ctx->fpscr & FPSCR_SZ) {
1050                 TCGv_i64 fp = tcg_temp_new_i64();
1051                 tcg_gen_qemu_ld64(fp, addr, ctx->memidx);
1052                 gen_store_fpr64(fp, XREG(B11_8));
1053                 tcg_temp_free_i64(fp);
1054             } else {
1055                 tcg_gen_qemu_ld32u(cpu_fregs[FREG(B11_8)], addr, ctx->memidx);
1056             }
1057             tcg_temp_free(addr);
1058         }
1059         return;
1060     case 0xf007: /* fmov {F,D,X}Rn,@(R0,Rn) - FPSCR: Nothing */
1061         {
1062             TCGv addr = tcg_temp_new();
1063             tcg_gen_add_i32(addr, REG(B11_8), REG(0));
1064             if (ctx->fpscr & FPSCR_SZ) {
1065                 TCGv_i64 fp = tcg_temp_new_i64();
1066                 gen_load_fpr64(fp, XREG(B7_4));
1067                 tcg_gen_qemu_st64(fp, addr, ctx->memidx);
1068                 tcg_temp_free_i64(fp);
1069             } else {
1070                 tcg_gen_qemu_st32(cpu_fregs[FREG(B7_4)], addr, ctx->memidx);
1071             }
1072             tcg_temp_free(addr);
1073         }
1074         return;
1075     case 0xf000: /* fadd Rm,Rn - FPSCR: R[PR,Enable.O/U/I]/W[Cause,Flag] */
1076     case 0xf001: /* fsub Rm,Rn - FPSCR: R[PR,Enable.O/U/I]/W[Cause,Flag] */
1077     case 0xf002: /* fmul Rm,Rn - FPSCR: R[PR,Enable.O/U/I]/W[Cause,Flag] */
1078     case 0xf003: /* fdiv Rm,Rn - FPSCR: R[PR,Enable.O/U/I]/W[Cause,Flag] */
1079     case 0xf004: /* fcmp/eq Rm,Rn - FPSCR: R[PR,Enable.V]/W[Cause,Flag] */
1080     case 0xf005: /* fcmp/gt Rm,Rn - FPSCR: R[PR,Enable.V]/W[Cause,Flag] */
1081         {
1082             if (ctx->fpscr & FPSCR_PR) {
1083                 TCGv_i64 fp0, fp1;
1084
1085                 if (ctx->opcode & 0x0110)
1086                     break; /* illegal instruction */
1087                 fp0 = tcg_temp_new_i64();
1088                 fp1 = tcg_temp_new_i64();
1089                 gen_load_fpr64(fp0, DREG(B11_8));
1090                 gen_load_fpr64(fp1, DREG(B7_4));
1091                 switch (ctx->opcode & 0xf00f) {
1092                 case 0xf000:            /* fadd Rm,Rn */
1093                     gen_helper_fadd_DT(fp0, fp0, fp1);
1094                     break;
1095                 case 0xf001:            /* fsub Rm,Rn */
1096                     gen_helper_fsub_DT(fp0, fp0, fp1);
1097                     break;
1098                 case 0xf002:            /* fmul Rm,Rn */
1099                     gen_helper_fmul_DT(fp0, fp0, fp1);
1100                     break;
1101                 case 0xf003:            /* fdiv Rm,Rn */
1102                     gen_helper_fdiv_DT(fp0, fp0, fp1);
1103                     break;
1104                 case 0xf004:            /* fcmp/eq Rm,Rn */
1105                     gen_helper_fcmp_eq_DT(fp0, fp1);
1106                     return;
1107                 case 0xf005:            /* fcmp/gt Rm,Rn */
1108                     gen_helper_fcmp_gt_DT(fp0, fp1);
1109                     return;
1110                 }
1111                 gen_store_fpr64(fp0, DREG(B11_8));
1112                 tcg_temp_free_i64(fp0);
1113                 tcg_temp_free_i64(fp1);
1114             } else {
1115                 switch (ctx->opcode & 0xf00f) {
1116                 case 0xf000:            /* fadd Rm,Rn */
1117                     gen_helper_fadd_FT(cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B7_4)]);
1118                     break;
1119                 case 0xf001:            /* fsub Rm,Rn */
1120                     gen_helper_fsub_FT(cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B7_4)]);
1121                     break;
1122                 case 0xf002:            /* fmul Rm,Rn */
1123                     gen_helper_fmul_FT(cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B7_4)]);
1124                     break;
1125                 case 0xf003:            /* fdiv Rm,Rn */
1126                     gen_helper_fdiv_FT(cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B7_4)]);
1127                     break;
1128                 case 0xf004:            /* fcmp/eq Rm,Rn */
1129                     gen_helper_fcmp_eq_FT(cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B7_4)]);
1130                     return;
1131                 case 0xf005:            /* fcmp/gt Rm,Rn */
1132                     gen_helper_fcmp_gt_FT(cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B7_4)]);
1133                     return;
1134                 }
1135             }
1136         }
1137         return;
1138     }
1139
1140     switch (ctx->opcode & 0xff00) {
1141     case 0xc900:                /* and #imm,R0 */
1142         tcg_gen_andi_i32(REG(0), REG(0), B7_0);
1143         return;
1144     case 0xcd00:                /* and.b #imm,@(R0,GBR) */
1145         {
1146             TCGv addr, val;
1147             addr = tcg_temp_new();
1148             tcg_gen_add_i32(addr, REG(0), cpu_gbr);
1149             val = tcg_temp_new();
1150             tcg_gen_qemu_ld8u(val, addr, ctx->memidx);
1151             tcg_gen_andi_i32(val, val, B7_0);
1152             tcg_gen_qemu_st8(val, addr, ctx->memidx);
1153             tcg_temp_free(val);
1154             tcg_temp_free(addr);
1155         }
1156         return;
1157     case 0x8b00:                /* bf label */
1158         CHECK_NOT_DELAY_SLOT
1159             gen_conditional_jump(ctx, ctx->pc + 2,
1160                                  ctx->pc + 4 + B7_0s * 2);
1161         ctx->bstate = BS_BRANCH;
1162         return;
1163     case 0x8f00:                /* bf/s label */
1164         CHECK_NOT_DELAY_SLOT
1165         gen_branch_slot(ctx->delayed_pc = ctx->pc + 4 + B7_0s * 2, 0);
1166         ctx->flags |= DELAY_SLOT_CONDITIONAL;
1167         return;
1168     case 0x8900:                /* bt label */
1169         CHECK_NOT_DELAY_SLOT
1170             gen_conditional_jump(ctx, ctx->pc + 4 + B7_0s * 2,
1171                                  ctx->pc + 2);
1172         ctx->bstate = BS_BRANCH;
1173         return;
1174     case 0x8d00:                /* bt/s label */
1175         CHECK_NOT_DELAY_SLOT
1176         gen_branch_slot(ctx->delayed_pc = ctx->pc + 4 + B7_0s * 2, 1);
1177         ctx->flags |= DELAY_SLOT_CONDITIONAL;
1178         return;
1179     case 0x8800:                /* cmp/eq #imm,R0 */
1180         gen_cmp_imm(TCG_COND_EQ, REG(0), B7_0s);
1181         return;
1182     case 0xc400:                /* mov.b @(disp,GBR),R0 */
1183         {
1184             TCGv addr = tcg_temp_new();
1185             tcg_gen_addi_i32(addr, cpu_gbr, B7_0);
1186             tcg_gen_qemu_ld8s(REG(0), addr, ctx->memidx);
1187             tcg_temp_free(addr);
1188         }
1189         return;
1190     case 0xc500:                /* mov.w @(disp,GBR),R0 */
1191         {
1192             TCGv addr = tcg_temp_new();
1193             tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 2);
1194             tcg_gen_qemu_ld16s(REG(0), addr, ctx->memidx);
1195             tcg_temp_free(addr);
1196         }
1197         return;
1198     case 0xc600:                /* mov.l @(disp,GBR),R0 */
1199         {
1200             TCGv addr = tcg_temp_new();
1201             tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 4);
1202             tcg_gen_qemu_ld32s(REG(0), addr, ctx->memidx);
1203             tcg_temp_free(addr);
1204         }
1205         return;
1206     case 0xc000:                /* mov.b R0,@(disp,GBR) */
1207         {
1208             TCGv addr = tcg_temp_new();
1209             tcg_gen_addi_i32(addr, cpu_gbr, B7_0);
1210             tcg_gen_qemu_st8(REG(0), addr, ctx->memidx);
1211             tcg_temp_free(addr);
1212         }
1213         return;
1214     case 0xc100:                /* mov.w R0,@(disp,GBR) */
1215         {
1216             TCGv addr = tcg_temp_new();
1217             tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 2);
1218             tcg_gen_qemu_st16(REG(0), addr, ctx->memidx);
1219             tcg_temp_free(addr);
1220         }
1221         return;
1222     case 0xc200:                /* mov.l R0,@(disp,GBR) */
1223         {
1224             TCGv addr = tcg_temp_new();
1225             tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 4);
1226             tcg_gen_qemu_st32(REG(0), addr, ctx->memidx);
1227             tcg_temp_free(addr);
1228         }
1229         return;
1230     case 0x8000:                /* mov.b R0,@(disp,Rn) */
1231         {
1232             TCGv addr = tcg_temp_new();
1233             tcg_gen_addi_i32(addr, REG(B7_4), B3_0);
1234             tcg_gen_qemu_st8(REG(0), addr, ctx->memidx);
1235             tcg_temp_free(addr);
1236         }
1237         return;
1238     case 0x8100:                /* mov.w R0,@(disp,Rn) */
1239         {
1240             TCGv addr = tcg_temp_new();
1241             tcg_gen_addi_i32(addr, REG(B7_4), B3_0 * 2);
1242             tcg_gen_qemu_st16(REG(0), addr, ctx->memidx);
1243             tcg_temp_free(addr);
1244         }
1245         return;
1246     case 0x8400:                /* mov.b @(disp,Rn),R0 */
1247         {
1248             TCGv addr = tcg_temp_new();
1249             tcg_gen_addi_i32(addr, REG(B7_4), B3_0);
1250             tcg_gen_qemu_ld8s(REG(0), addr, ctx->memidx);
1251             tcg_temp_free(addr);
1252         }
1253         return;
1254     case 0x8500:                /* mov.w @(disp,Rn),R0 */
1255         {
1256             TCGv addr = tcg_temp_new();
1257             tcg_gen_addi_i32(addr, REG(B7_4), B3_0 * 2);
1258             tcg_gen_qemu_ld16s(REG(0), addr, ctx->memidx);
1259             tcg_temp_free(addr);
1260         }
1261         return;
1262     case 0xc700:                /* mova @(disp,PC),R0 */
1263         tcg_gen_movi_i32(REG(0), ((ctx->pc & 0xfffffffc) + 4 + B7_0 * 4) & ~3);
1264         return;
1265     case 0xcb00:                /* or #imm,R0 */
1266         tcg_gen_ori_i32(REG(0), REG(0), B7_0);
1267         return;
1268     case 0xcf00:                /* or.b #imm,@(R0,GBR) */
1269         {
1270             TCGv addr, val;
1271             addr = tcg_temp_new();
1272             tcg_gen_add_i32(addr, REG(0), cpu_gbr);
1273             val = tcg_temp_new();
1274             tcg_gen_qemu_ld8u(val, addr, ctx->memidx);
1275             tcg_gen_ori_i32(val, val, B7_0);
1276             tcg_gen_qemu_st8(val, addr, ctx->memidx);
1277             tcg_temp_free(val);
1278             tcg_temp_free(addr);
1279         }
1280         return;
1281     case 0xc300:                /* trapa #imm */
1282         {
1283             TCGv imm;
1284             CHECK_NOT_DELAY_SLOT
1285             tcg_gen_movi_i32(cpu_pc, ctx->pc);
1286             imm = tcg_const_i32(B7_0);
1287             gen_helper_trapa(imm);
1288             tcg_temp_free(imm);
1289             ctx->bstate = BS_BRANCH;
1290         }
1291         return;
1292     case 0xc800:                /* tst #imm,R0 */
1293         {
1294             TCGv val = tcg_temp_new();
1295             tcg_gen_andi_i32(val, REG(0), B7_0);
1296             gen_cmp_imm(TCG_COND_EQ, val, 0);
1297             tcg_temp_free(val);
1298         }
1299         return;
1300     case 0xcc00:                /* tst.b #imm,@(R0,GBR) */
1301         {
1302             TCGv val = tcg_temp_new();
1303             tcg_gen_add_i32(val, REG(0), cpu_gbr);
1304             tcg_gen_qemu_ld8u(val, val, ctx->memidx);
1305             tcg_gen_andi_i32(val, val, B7_0);
1306             gen_cmp_imm(TCG_COND_EQ, val, 0);
1307             tcg_temp_free(val);
1308         }
1309         return;
1310     case 0xca00:                /* xor #imm,R0 */
1311         tcg_gen_xori_i32(REG(0), REG(0), B7_0);
1312         return;
1313     case 0xce00:                /* xor.b #imm,@(R0,GBR) */
1314         {
1315             TCGv addr, val;
1316             addr = tcg_temp_new();
1317             tcg_gen_add_i32(addr, REG(0), cpu_gbr);
1318             val = tcg_temp_new();
1319             tcg_gen_qemu_ld8u(val, addr, ctx->memidx);
1320             tcg_gen_xori_i32(val, val, B7_0);
1321             tcg_gen_qemu_st8(val, addr, ctx->memidx);
1322             tcg_temp_free(val);
1323             tcg_temp_free(addr);
1324         }
1325         return;
1326     }
1327
1328     switch (ctx->opcode & 0xf08f) {
1329     case 0x408e:                /* ldc Rm,Rn_BANK */
1330         CHECK_PRIVILEGED
1331         tcg_gen_mov_i32(ALTREG(B6_4), REG(B11_8));
1332         return;
1333     case 0x4087:                /* ldc.l @Rm+,Rn_BANK */
1334         CHECK_PRIVILEGED
1335         tcg_gen_qemu_ld32s(ALTREG(B6_4), REG(B11_8), ctx->memidx);
1336         tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
1337         return;
1338     case 0x0082:                /* stc Rm_BANK,Rn */
1339         CHECK_PRIVILEGED
1340         tcg_gen_mov_i32(REG(B11_8), ALTREG(B6_4));
1341         return;
1342     case 0x4083:                /* stc.l Rm_BANK,@-Rn */
1343         CHECK_PRIVILEGED
1344         {
1345             TCGv addr = tcg_temp_new();
1346             tcg_gen_subi_i32(addr, REG(B11_8), 4);
1347             tcg_gen_qemu_st32(ALTREG(B6_4), addr, ctx->memidx);
1348             tcg_temp_free(addr);
1349             tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4);
1350         }
1351         return;
1352     }
1353
1354     switch (ctx->opcode & 0xf0ff) {
1355     case 0x0023:                /* braf Rn */
1356         CHECK_NOT_DELAY_SLOT
1357         tcg_gen_addi_i32(cpu_delayed_pc, REG(B11_8), ctx->pc + 4);
1358         ctx->flags |= DELAY_SLOT;
1359         ctx->delayed_pc = (uint32_t) - 1;
1360         return;
1361     case 0x0003:                /* bsrf Rn */
1362         CHECK_NOT_DELAY_SLOT
1363         tcg_gen_movi_i32(cpu_pr, ctx->pc + 4);
1364         tcg_gen_add_i32(cpu_delayed_pc, REG(B11_8), cpu_pr);
1365         ctx->flags |= DELAY_SLOT;
1366         ctx->delayed_pc = (uint32_t) - 1;
1367         return;
1368     case 0x4015:                /* cmp/pl Rn */
1369         gen_cmp_imm(TCG_COND_GT, REG(B11_8), 0);
1370         return;
1371     case 0x4011:                /* cmp/pz Rn */
1372         gen_cmp_imm(TCG_COND_GE, REG(B11_8), 0);
1373         return;
1374     case 0x4010:                /* dt Rn */
1375         tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 1);
1376         gen_cmp_imm(TCG_COND_EQ, REG(B11_8), 0);
1377         return;
1378     case 0x402b:                /* jmp @Rn */
1379         CHECK_NOT_DELAY_SLOT
1380         tcg_gen_mov_i32(cpu_delayed_pc, REG(B11_8));
1381         ctx->flags |= DELAY_SLOT;
1382         ctx->delayed_pc = (uint32_t) - 1;
1383         return;
1384     case 0x400b:                /* jsr @Rn */
1385         CHECK_NOT_DELAY_SLOT
1386         tcg_gen_movi_i32(cpu_pr, ctx->pc + 4);
1387         tcg_gen_mov_i32(cpu_delayed_pc, REG(B11_8));
1388         ctx->flags |= DELAY_SLOT;
1389         ctx->delayed_pc = (uint32_t) - 1;
1390         return;
1391     case 0x400e:                /* ldc Rm,SR */
1392         CHECK_PRIVILEGED
1393         tcg_gen_andi_i32(cpu_sr, REG(B11_8), 0x700083f3);
1394         ctx->bstate = BS_STOP;
1395         return;
1396     case 0x4007:                /* ldc.l @Rm+,SR */
1397         CHECK_PRIVILEGED
1398         {
1399             TCGv val = tcg_temp_new();
1400             tcg_gen_qemu_ld32s(val, REG(B11_8), ctx->memidx);
1401             tcg_gen_andi_i32(cpu_sr, val, 0x700083f3);
1402             tcg_temp_free(val);
1403             tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
1404             ctx->bstate = BS_STOP;
1405         }
1406         return;
1407     case 0x0002:                /* stc SR,Rn */
1408         CHECK_PRIVILEGED
1409         tcg_gen_mov_i32(REG(B11_8), cpu_sr);
1410         return;
1411     case 0x4003:                /* stc SR,@-Rn */
1412         CHECK_PRIVILEGED
1413         {
1414             TCGv addr = tcg_temp_new();
1415             tcg_gen_subi_i32(addr, REG(B11_8), 4);
1416             tcg_gen_qemu_st32(cpu_sr, addr, ctx->memidx);
1417             tcg_temp_free(addr);
1418             tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4);
1419         }
1420         return;
1421 #define LDST(reg,ldnum,ldpnum,stnum,stpnum,prechk)              \
1422   case ldnum:                                                   \
1423     prechk                                                      \
1424     tcg_gen_mov_i32 (cpu_##reg, REG(B11_8));                    \
1425     return;                                                     \
1426   case ldpnum:                                                  \
1427     prechk                                                      \
1428     tcg_gen_qemu_ld32s (cpu_##reg, REG(B11_8), ctx->memidx);    \
1429     tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);                \
1430     return;                                                     \
1431   case stnum:                                                   \
1432     prechk                                                      \
1433     tcg_gen_mov_i32 (REG(B11_8), cpu_##reg);                    \
1434     return;                                                     \
1435   case stpnum:                                                  \
1436     prechk                                                      \
1437     {                                                           \
1438         TCGv addr = tcg_temp_new();                     \
1439         tcg_gen_subi_i32(addr, REG(B11_8), 4);                  \
1440         tcg_gen_qemu_st32 (cpu_##reg, addr, ctx->memidx);       \
1441         tcg_temp_free(addr);                                    \
1442         tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4);            \
1443     }                                                           \
1444     return;
1445         LDST(gbr,  0x401e, 0x4017, 0x0012, 0x4013, {})
1446         LDST(vbr,  0x402e, 0x4027, 0x0022, 0x4023, CHECK_PRIVILEGED)
1447         LDST(ssr,  0x403e, 0x4037, 0x0032, 0x4033, CHECK_PRIVILEGED)
1448         LDST(spc,  0x404e, 0x4047, 0x0042, 0x4043, CHECK_PRIVILEGED)
1449         LDST(dbr,  0x40fa, 0x40f6, 0x00fa, 0x40f2, CHECK_PRIVILEGED)
1450         LDST(mach, 0x400a, 0x4006, 0x000a, 0x4002, {})
1451         LDST(macl, 0x401a, 0x4016, 0x001a, 0x4012, {})
1452         LDST(pr,   0x402a, 0x4026, 0x002a, 0x4022, {})
1453         LDST(fpul, 0x405a, 0x4056, 0x005a, 0x4052, {})
1454     case 0x406a:                /* lds Rm,FPSCR */
1455         gen_helper_ld_fpscr(REG(B11_8));
1456         ctx->bstate = BS_STOP;
1457         return;
1458     case 0x4066:                /* lds.l @Rm+,FPSCR */
1459         {
1460             TCGv addr = tcg_temp_new();
1461             tcg_gen_qemu_ld32s(addr, REG(B11_8), ctx->memidx);
1462             tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
1463             gen_helper_ld_fpscr(addr);
1464             tcg_temp_free(addr);
1465             ctx->bstate = BS_STOP;
1466         }
1467         return;
1468     case 0x006a:                /* sts FPSCR,Rn */
1469         tcg_gen_andi_i32(REG(B11_8), cpu_fpscr, 0x003fffff);
1470         return;
1471     case 0x4062:                /* sts FPSCR,@-Rn */
1472         {
1473             TCGv addr, val;
1474             val = tcg_temp_new();
1475             tcg_gen_andi_i32(val, cpu_fpscr, 0x003fffff);
1476             addr = tcg_temp_new();
1477             tcg_gen_subi_i32(addr, REG(B11_8), 4);
1478             tcg_gen_qemu_st32(val, addr, ctx->memidx);
1479             tcg_temp_free(addr);
1480             tcg_temp_free(val);
1481             tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 4);
1482         }
1483         return;
1484     case 0x00c3:                /* movca.l R0,@Rm */
1485         tcg_gen_qemu_st32(REG(0), REG(B11_8), ctx->memidx);
1486         return;
1487     case 0x40a9:
1488         /* MOVUA.L @Rm,R0 (Rm) -> R0
1489            Load non-boundary-aligned data */
1490         tcg_gen_qemu_ld32u(REG(0), REG(B11_8), ctx->memidx);
1491         return;
1492     case 0x40e9:
1493         /* MOVUA.L @Rm+,R0   (Rm) -> R0, Rm + 4 -> Rm
1494            Load non-boundary-aligned data */
1495         tcg_gen_qemu_ld32u(REG(0), REG(B11_8), ctx->memidx);
1496         tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
1497         return;
1498     case 0x0029:                /* movt Rn */
1499         tcg_gen_andi_i32(REG(B11_8), cpu_sr, SR_T);
1500         return;
1501     case 0x0093:                /* ocbi @Rn */
1502         {
1503             TCGv dummy = tcg_temp_new();
1504             tcg_gen_qemu_ld32s(dummy, REG(B11_8), ctx->memidx);
1505             tcg_temp_free(dummy);
1506         }
1507         return;
1508     case 0x00a3:                /* ocbp @Rn */
1509         {
1510             TCGv dummy = tcg_temp_new();
1511             tcg_gen_qemu_ld32s(dummy, REG(B11_8), ctx->memidx);
1512             tcg_temp_free(dummy);
1513         }
1514         return;
1515     case 0x00b3:                /* ocbwb @Rn */
1516         {
1517             TCGv dummy = tcg_temp_new();
1518             tcg_gen_qemu_ld32s(dummy, REG(B11_8), ctx->memidx);
1519             tcg_temp_free(dummy);
1520         }
1521         return;
1522     case 0x0083:                /* pref @Rn */
1523         return;
1524     case 0x4024:                /* rotcl Rn */
1525         {
1526             TCGv tmp = tcg_temp_new();
1527             tcg_gen_mov_i32(tmp, cpu_sr);
1528             gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 31);
1529             tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 1);
1530             gen_copy_bit_i32(REG(B11_8), 0, tmp, 0);
1531             tcg_temp_free(tmp);
1532         }
1533         return;
1534     case 0x4025:                /* rotcr Rn */
1535         {
1536             TCGv tmp = tcg_temp_new();
1537             tcg_gen_mov_i32(tmp, cpu_sr);
1538             gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 0);
1539             tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 1);
1540             gen_copy_bit_i32(REG(B11_8), 31, tmp, 0);
1541             tcg_temp_free(tmp);
1542         }
1543         return;
1544     case 0x4004:                /* rotl Rn */
1545         gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 31);
1546         tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 1);
1547         gen_copy_bit_i32(REG(B11_8), 0, cpu_sr, 0);
1548         return;
1549     case 0x4005:                /* rotr Rn */
1550         gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 0);
1551         tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 1);
1552         gen_copy_bit_i32(REG(B11_8), 31, cpu_sr, 0);
1553         return;
1554     case 0x4000:                /* shll Rn */
1555     case 0x4020:                /* shal Rn */
1556         gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 31);
1557         tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 1);
1558         return;
1559     case 0x4021:                /* shar Rn */
1560         gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 0);
1561         tcg_gen_sari_i32(REG(B11_8), REG(B11_8), 1);
1562         return;
1563     case 0x4001:                /* shlr Rn */
1564         gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 0);
1565         tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 1);
1566         return;
1567     case 0x4008:                /* shll2 Rn */
1568         tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 2);
1569         return;
1570     case 0x4018:                /* shll8 Rn */
1571         tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 8);
1572         return;
1573     case 0x4028:                /* shll16 Rn */
1574         tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 16);
1575         return;
1576     case 0x4009:                /* shlr2 Rn */
1577         tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 2);
1578         return;
1579     case 0x4019:                /* shlr8 Rn */
1580         tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 8);
1581         return;
1582     case 0x4029:                /* shlr16 Rn */
1583         tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 16);
1584         return;
1585     case 0x401b:                /* tas.b @Rn */
1586         {
1587             TCGv addr, val;
1588             addr = tcg_temp_local_new(TCG_TYPE_I32);
1589             tcg_gen_mov_i32(addr, REG(B11_8));
1590             val = tcg_temp_local_new(TCG_TYPE_I32);
1591             tcg_gen_qemu_ld8u(val, addr, ctx->memidx);
1592             gen_cmp_imm(TCG_COND_EQ, val, 0);
1593             tcg_gen_ori_i32(val, val, 0x80);
1594             tcg_gen_qemu_st8(val, addr, ctx->memidx);
1595             tcg_temp_free(val);
1596             tcg_temp_free(addr);
1597         }
1598         return;
1599     case 0xf00d: /* fsts FPUL,FRn - FPSCR: Nothing */
1600         {
1601             tcg_gen_mov_i32(cpu_fregs[FREG(B11_8)], cpu_fpul);
1602         }
1603         return;
1604     case 0xf01d: /* flds FRm,FPUL - FPSCR: Nothing */
1605         {
1606             tcg_gen_mov_i32(cpu_fpul, cpu_fregs[FREG(B11_8)]);
1607         }
1608         return;
1609     case 0xf02d: /* float FPUL,FRn/DRn - FPSCR: R[PR,Enable.I]/W[Cause,Flag] */
1610         if (ctx->fpscr & FPSCR_PR) {
1611             TCGv_i64 fp;
1612             if (ctx->opcode & 0x0100)
1613                 break; /* illegal instruction */
1614             fp = tcg_temp_new_i64();
1615             gen_helper_float_DT(fp, cpu_fpul);
1616             gen_store_fpr64(fp, DREG(B11_8));
1617             tcg_temp_free_i64(fp);
1618         }
1619         else {
1620             gen_helper_float_FT(cpu_fregs[FREG(B11_8)], cpu_fpul);
1621         }
1622         return;
1623     case 0xf03d: /* ftrc FRm/DRm,FPUL - FPSCR: R[PR,Enable.V]/W[Cause,Flag] */
1624         if (ctx->fpscr & FPSCR_PR) {
1625             TCGv_i64 fp;
1626             if (ctx->opcode & 0x0100)
1627                 break; /* illegal instruction */
1628             fp = tcg_temp_new_i64();
1629             gen_load_fpr64(fp, DREG(B11_8));
1630             gen_helper_ftrc_DT(cpu_fpul, fp);
1631             tcg_temp_free_i64(fp);
1632         }
1633         else {
1634             gen_helper_ftrc_FT(cpu_fpul, cpu_fregs[FREG(B11_8)]);
1635         }
1636         return;
1637     case 0xf04d: /* fneg FRn/DRn - FPSCR: Nothing */
1638         {
1639             gen_helper_fneg_T(cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B11_8)]);
1640         }
1641         return;
1642     case 0xf05d: /* fabs FRn/DRn */
1643         if (ctx->fpscr & FPSCR_PR) {
1644             if (ctx->opcode & 0x0100)
1645                 break; /* illegal instruction */
1646             TCGv_i64 fp = tcg_temp_new_i64();
1647             gen_load_fpr64(fp, DREG(B11_8));
1648             gen_helper_fabs_DT(fp, fp);
1649             gen_store_fpr64(fp, DREG(B11_8));
1650             tcg_temp_free_i64(fp);
1651         } else {
1652             gen_helper_fabs_FT(cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B11_8)]);
1653         }
1654         return;
1655     case 0xf06d: /* fsqrt FRn */
1656         if (ctx->fpscr & FPSCR_PR) {
1657             if (ctx->opcode & 0x0100)
1658                 break; /* illegal instruction */
1659             TCGv_i64 fp = tcg_temp_new_i64();
1660             gen_load_fpr64(fp, DREG(B11_8));
1661             gen_helper_fsqrt_DT(fp, fp);
1662             gen_store_fpr64(fp, DREG(B11_8));
1663             tcg_temp_free_i64(fp);
1664         } else {
1665             gen_helper_fsqrt_FT(cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B11_8)]);
1666         }
1667         return;
1668     case 0xf07d: /* fsrra FRn */
1669         break;
1670     case 0xf08d: /* fldi0 FRn - FPSCR: R[PR] */
1671         if (!(ctx->fpscr & FPSCR_PR)) {
1672             tcg_gen_movi_i32(cpu_fregs[FREG(B11_8)], 0);
1673         }
1674         return;
1675     case 0xf09d: /* fldi1 FRn - FPSCR: R[PR] */
1676         if (!(ctx->fpscr & FPSCR_PR)) {
1677             tcg_gen_movi_i32(cpu_fregs[FREG(B11_8)], 0x3f800000);
1678         }
1679         return;
1680     case 0xf0ad: /* fcnvsd FPUL,DRn */
1681         {
1682             TCGv_i64 fp = tcg_temp_new_i64();
1683             gen_helper_fcnvsd_FT_DT(fp, cpu_fpul);
1684             gen_store_fpr64(fp, DREG(B11_8));
1685             tcg_temp_free_i64(fp);
1686         }
1687         return;
1688     case 0xf0bd: /* fcnvds DRn,FPUL */
1689         {
1690             TCGv_i64 fp = tcg_temp_new_i64();
1691             gen_load_fpr64(fp, DREG(B11_8));
1692             gen_helper_fcnvds_DT_FT(cpu_fpul, fp);
1693             tcg_temp_free_i64(fp);
1694         }
1695         return;
1696     }
1697
1698     fprintf(stderr, "unknown instruction 0x%04x at pc 0x%08x\n",
1699             ctx->opcode, ctx->pc);
1700     gen_helper_raise_illegal_instruction();
1701     ctx->bstate = BS_EXCP;
1702 }
1703
1704 static void decode_opc(DisasContext * ctx)
1705 {
1706     uint32_t old_flags = ctx->flags;
1707
1708     _decode_opc(ctx);
1709
1710     if (old_flags & (DELAY_SLOT | DELAY_SLOT_CONDITIONAL)) {
1711         if (ctx->flags & DELAY_SLOT_CLEARME) {
1712             gen_store_flags(0);
1713         } else {
1714             /* go out of the delay slot */
1715             uint32_t new_flags = ctx->flags;
1716             new_flags &= ~(DELAY_SLOT | DELAY_SLOT_CONDITIONAL);
1717             gen_store_flags(new_flags);
1718         }
1719         ctx->flags = 0;
1720         ctx->bstate = BS_BRANCH;
1721         if (old_flags & DELAY_SLOT_CONDITIONAL) {
1722             gen_delayed_conditional_jump(ctx);
1723         } else if (old_flags & DELAY_SLOT) {
1724             gen_jump(ctx);
1725         }
1726
1727     }
1728
1729     /* go into a delay slot */
1730     if (ctx->flags & (DELAY_SLOT | DELAY_SLOT_CONDITIONAL))
1731         gen_store_flags(ctx->flags);
1732 }
1733
1734 static inline void
1735 gen_intermediate_code_internal(CPUState * env, TranslationBlock * tb,
1736                                int search_pc)
1737 {
1738     DisasContext ctx;
1739     target_ulong pc_start;
1740     static uint16_t *gen_opc_end;
1741     CPUBreakpoint *bp;
1742     int i, ii;
1743     int num_insns;
1744     int max_insns;
1745
1746     pc_start = tb->pc;
1747     gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
1748     ctx.pc = pc_start;
1749     ctx.flags = (uint32_t)tb->flags;
1750     ctx.bstate = BS_NONE;
1751     ctx.sr = env->sr;
1752     ctx.fpscr = env->fpscr;
1753     ctx.memidx = (env->sr & SR_MD) ? 1 : 0;
1754     /* We don't know if the delayed pc came from a dynamic or static branch,
1755        so assume it is a dynamic branch.  */
1756     ctx.delayed_pc = -1; /* use delayed pc from env pointer */
1757     ctx.tb = tb;
1758     ctx.singlestep_enabled = env->singlestep_enabled;
1759
1760 #ifdef DEBUG_DISAS
1761     if (loglevel & CPU_LOG_TB_CPU) {
1762         fprintf(logfile,
1763                 "------------------------------------------------\n");
1764         cpu_dump_state(env, logfile, fprintf, 0);
1765     }
1766 #endif
1767
1768     ii = -1;
1769     num_insns = 0;
1770     max_insns = tb->cflags & CF_COUNT_MASK;
1771     if (max_insns == 0)
1772         max_insns = CF_COUNT_MASK;
1773     gen_icount_start();
1774     while (ctx.bstate == BS_NONE && gen_opc_ptr < gen_opc_end) {
1775         if (unlikely(env->breakpoints)) {
1776             for (bp = env->breakpoints; bp != NULL; bp = bp->next) {
1777                 if (ctx.pc == bp->pc) {
1778                     /* We have hit a breakpoint - make sure PC is up-to-date */
1779                     tcg_gen_movi_i32(cpu_pc, ctx.pc);
1780                     gen_helper_debug();
1781                     ctx.bstate = BS_EXCP;
1782                     break;
1783                 }
1784             }
1785         }
1786         if (search_pc) {
1787             i = gen_opc_ptr - gen_opc_buf;
1788             if (ii < i) {
1789                 ii++;
1790                 while (ii < i)
1791                     gen_opc_instr_start[ii++] = 0;
1792             }
1793             gen_opc_pc[ii] = ctx.pc;
1794             gen_opc_hflags[ii] = ctx.flags;
1795             gen_opc_instr_start[ii] = 1;
1796             gen_opc_icount[ii] = num_insns;
1797         }
1798         if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))
1799             gen_io_start();
1800 #if 0
1801         fprintf(stderr, "Loading opcode at address 0x%08x\n", ctx.pc);
1802         fflush(stderr);
1803 #endif
1804         ctx.opcode = lduw_code(ctx.pc);
1805         decode_opc(&ctx);
1806         num_insns++;
1807         ctx.pc += 2;
1808         if ((ctx.pc & (TARGET_PAGE_SIZE - 1)) == 0)
1809             break;
1810         if (env->singlestep_enabled)
1811             break;
1812         if (num_insns >= max_insns)
1813             break;
1814 #ifdef SH4_SINGLE_STEP
1815         break;
1816 #endif
1817     }
1818     if (tb->cflags & CF_LAST_IO)
1819         gen_io_end();
1820     if (env->singlestep_enabled) {
1821         tcg_gen_movi_i32(cpu_pc, ctx.pc);
1822         gen_helper_debug();
1823     } else {
1824         switch (ctx.bstate) {
1825         case BS_STOP:
1826             /* gen_op_interrupt_restart(); */
1827             /* fall through */
1828         case BS_NONE:
1829             if (ctx.flags) {
1830                 gen_store_flags(ctx.flags | DELAY_SLOT_CLEARME);
1831             }
1832             gen_goto_tb(&ctx, 0, ctx.pc);
1833             break;
1834         case BS_EXCP:
1835             /* gen_op_interrupt_restart(); */
1836             tcg_gen_exit_tb(0);
1837             break;
1838         case BS_BRANCH:
1839         default:
1840             break;
1841         }
1842     }
1843
1844     gen_icount_end(tb, num_insns);
1845     *gen_opc_ptr = INDEX_op_end;
1846     if (search_pc) {
1847         i = gen_opc_ptr - gen_opc_buf;
1848         ii++;
1849         while (ii <= i)
1850             gen_opc_instr_start[ii++] = 0;
1851     } else {
1852         tb->size = ctx.pc - pc_start;
1853         tb->icount = num_insns;
1854     }
1855
1856 #ifdef DEBUG_DISAS
1857 #ifdef SH4_DEBUG_DISAS
1858     if (loglevel & CPU_LOG_TB_IN_ASM)
1859         fprintf(logfile, "\n");
1860 #endif
1861     if (loglevel & CPU_LOG_TB_IN_ASM) {
1862         fprintf(logfile, "IN:\n");      /* , lookup_symbol(pc_start)); */
1863         target_disas(logfile, pc_start, ctx.pc - pc_start, 0);
1864         fprintf(logfile, "\n");
1865     }
1866 #endif
1867 }
1868
1869 void gen_intermediate_code(CPUState * env, struct TranslationBlock *tb)
1870 {
1871     gen_intermediate_code_internal(env, tb, 0);
1872 }
1873
1874 void gen_intermediate_code_pc(CPUState * env, struct TranslationBlock *tb)
1875 {
1876     gen_intermediate_code_internal(env, tb, 1);
1877 }
1878
1879 void gen_pc_load(CPUState *env, TranslationBlock *tb,
1880                 unsigned long searched_pc, int pc_pos, void *puc)
1881 {
1882     env->pc = gen_opc_pc[pc_pos];
1883     env->flags = gen_opc_hflags[pc_pos];
1884 }