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