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 tbflags;    /* should stay unmodified during the TB translation */
  41     uint32_t envflags;   /* should stay in sync with env->flags using TCG ops */
  42     int bstate;
  43     int memidx;
  44     int gbank;
  45     int fbank;
  46     uint32_t delayed_pc;
  47     int singlestep_enabled;
  48     uint32_t features;
  49     int has_movcal;
  50 } DisasContext;
  51
  52 #if defined(CONFIG_USER_ONLY)
  53 #define IS_USER(ctx) 1
  54 #else
  55 #define IS_USER(ctx) (!(ctx->tbflags & (1u << SR_MD)))
  56 #endif
  57
  58 enum {
  59     BS_NONE     = 0, /* We go out of the TB without reaching a branch or an
  60                       * exception condition
  61                       */
  62     BS_STOP     = 1, /* We want to stop translation for any reason */
  63     BS_BRANCH   = 2, /* We reached a branch condition     */
  64     BS_EXCP     = 3, /* We reached an exception condition */
  65 };
  66
  67 /* global register indexes */
  68 static TCGv cpu_gregs[32];
  69 static TCGv cpu_sr, cpu_sr_m, cpu_sr_q, cpu_sr_t;
  70 static TCGv cpu_pc, cpu_ssr, cpu_spc, cpu_gbr;
  71 static TCGv cpu_vbr, cpu_sgr, cpu_dbr, cpu_mach, cpu_macl;
  72 static TCGv cpu_pr, cpu_fpscr, cpu_fpul, cpu_ldst;
  73 static TCGv cpu_fregs[32];
  74
  75 /* internal register indexes */
  76 static TCGv cpu_flags, cpu_delayed_pc, cpu_delayed_cond;
  77
  78 #include "exec/gen-icount.h"
  79
  80 void sh4_translate_init(void)
  81 {
  82     int i;
  83     static const char * const gregnames[24] = {
  84         "R0_BANK0", "R1_BANK0", "R2_BANK0", "R3_BANK0",
  85         "R4_BANK0", "R5_BANK0", "R6_BANK0", "R7_BANK0",
  86         "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15",
  87         "R0_BANK1", "R1_BANK1", "R2_BANK1", "R3_BANK1",
  88         "R4_BANK1", "R5_BANK1", "R6_BANK1", "R7_BANK1"
  89     };
  90     static const char * const fregnames[32] = {
  91          "FPR0_BANK0",  "FPR1_BANK0",  "FPR2_BANK0",  "FPR3_BANK0",
  92          "FPR4_BANK0",  "FPR5_BANK0",  "FPR6_BANK0",  "FPR7_BANK0",
  93          "FPR8_BANK0",  "FPR9_BANK0", "FPR10_BANK0", "FPR11_BANK0",
  94         "FPR12_BANK0", "FPR13_BANK0", "FPR14_BANK0", "FPR15_BANK0",
  95          "FPR0_BANK1",  "FPR1_BANK1",  "FPR2_BANK1",  "FPR3_BANK1",
  96          "FPR4_BANK1",  "FPR5_BANK1",  "FPR6_BANK1",  "FPR7_BANK1",
  97          "FPR8_BANK1",  "FPR9_BANK1", "FPR10_BANK1", "FPR11_BANK1",
  98         "FPR12_BANK1", "FPR13_BANK1", "FPR14_BANK1", "FPR15_BANK1",
  99     };
 100
 101     for (i = 0; i < 24; i++) {
 102         cpu_gregs[i] = tcg_global_mem_new_i32(cpu_env,
 103                                               offsetof(CPUSH4State, gregs[i]),
 104                                               gregnames[i]);
 105     }
 106     memcpy(cpu_gregs + 24, cpu_gregs + 8, 8 * sizeof(TCGv));
 107
 108     cpu_pc = tcg_global_mem_new_i32(cpu_env,
 109                                     offsetof(CPUSH4State, pc), "PC");
 110     cpu_sr = tcg_global_mem_new_i32(cpu_env,
 111                                     offsetof(CPUSH4State, sr), "SR");
 112     cpu_sr_m = tcg_global_mem_new_i32(cpu_env,
 113                                       offsetof(CPUSH4State, sr_m), "SR_M");
 114     cpu_sr_q = tcg_global_mem_new_i32(cpu_env,
 115                                       offsetof(CPUSH4State, sr_q), "SR_Q");
 116     cpu_sr_t = tcg_global_mem_new_i32(cpu_env,
 117                                       offsetof(CPUSH4State, sr_t), "SR_T");
 118     cpu_ssr = tcg_global_mem_new_i32(cpu_env,
 119                                      offsetof(CPUSH4State, ssr), "SSR");
 120     cpu_spc = tcg_global_mem_new_i32(cpu_env,
 121                                      offsetof(CPUSH4State, spc), "SPC");
 122     cpu_gbr = tcg_global_mem_new_i32(cpu_env,
 123                                      offsetof(CPUSH4State, gbr), "GBR");
 124     cpu_vbr = tcg_global_mem_new_i32(cpu_env,
 125                                      offsetof(CPUSH4State, vbr), "VBR");
 126     cpu_sgr = tcg_global_mem_new_i32(cpu_env,
 127                                      offsetof(CPUSH4State, sgr), "SGR");
 128     cpu_dbr = tcg_global_mem_new_i32(cpu_env,
 129                                      offsetof(CPUSH4State, dbr), "DBR");
 130     cpu_mach = tcg_global_mem_new_i32(cpu_env,
 131                                       offsetof(CPUSH4State, mach), "MACH");
 132     cpu_macl = tcg_global_mem_new_i32(cpu_env,
 133                                       offsetof(CPUSH4State, macl), "MACL");
 134     cpu_pr = tcg_global_mem_new_i32(cpu_env,
 135                                     offsetof(CPUSH4State, pr), "PR");
 136     cpu_fpscr = tcg_global_mem_new_i32(cpu_env,
 137                                        offsetof(CPUSH4State, fpscr), "FPSCR");
 138     cpu_fpul = tcg_global_mem_new_i32(cpu_env,
 139                                       offsetof(CPUSH4State, fpul), "FPUL");
 140
 141     cpu_flags = tcg_global_mem_new_i32(cpu_env,
 142                                        offsetof(CPUSH4State, flags), "_flags_");
 143     cpu_delayed_pc = tcg_global_mem_new_i32(cpu_env,
 144                                             offsetof(CPUSH4State, delayed_pc),
 145                                             "_delayed_pc_");
 146     cpu_delayed_cond = tcg_global_mem_new_i32(cpu_env,
 147                                               offsetof(CPUSH4State,
 148                                                        delayed_cond),
 149                                               "_delayed_cond_");
 150     cpu_ldst = tcg_global_mem_new_i32(cpu_env,
 151                                       offsetof(CPUSH4State, ldst), "_ldst_");
 152
 153     for (i = 0; i < 32; i++)
 154         cpu_fregs[i] = tcg_global_mem_new_i32(cpu_env,
 155                                               offsetof(CPUSH4State, fregs[i]),
 156                                               fregnames[i]);
 157 }
 158
 159 void superh_cpu_dump_state(CPUState *cs, FILE *f,
 160                            fprintf_function cpu_fprintf, int flags)
 161 {
 162     SuperHCPU *cpu = SUPERH_CPU(cs);
 163     CPUSH4State *env = &cpu->env;
 164     int i;
 165     cpu_fprintf(f, "pc=0x%08x sr=0x%08x pr=0x%08x fpscr=0x%08x\n",
 166                 env->pc, cpu_read_sr(env), env->pr, env->fpscr);
 167     cpu_fprintf(f, "spc=0x%08x ssr=0x%08x gbr=0x%08x vbr=0x%08x\n",
 168                 env->spc, env->ssr, env->gbr, env->vbr);
 169     cpu_fprintf(f, "sgr=0x%08x dbr=0x%08x delayed_pc=0x%08x fpul=0x%08x\n",
 170                 env->sgr, env->dbr, env->delayed_pc, env->fpul);
 171     for (i = 0; i < 24; i += 4) {
 172         cpu_fprintf(f, "r%d=0x%08x r%d=0x%08x r%d=0x%08x r%d=0x%08x\n",
 173                     i, env->gregs[i], i + 1, env->gregs[i + 1],
 174                     i + 2, env->gregs[i + 2], i + 3, env->gregs[i + 3]);
 175     }
 176     if (env->flags & DELAY_SLOT) {
 177         cpu_fprintf(f, "in delay slot (delayed_pc=0x%08x)\n",
 178                     env->delayed_pc);
 179     } else if (env->flags & DELAY_SLOT_CONDITIONAL) {
 180         cpu_fprintf(f, "in conditional delay slot (delayed_pc=0x%08x)\n",
 181                     env->delayed_pc);
 182     } else if (env->flags & DELAY_SLOT_RTE) {
 183         cpu_fprintf(f, "in rte delay slot (delayed_pc=0x%08x)\n",
 184                     env->delayed_pc);
 185     }
 186 }
 187
 188 static void gen_read_sr(TCGv dst)
 189 {
 190     TCGv t0 = tcg_temp_new();
 191     tcg_gen_shli_i32(t0, cpu_sr_q, SR_Q);
 192     tcg_gen_or_i32(dst, dst, t0);
 193     tcg_gen_shli_i32(t0, cpu_sr_m, SR_M);
 194     tcg_gen_or_i32(dst, dst, t0);
 195     tcg_gen_shli_i32(t0, cpu_sr_t, SR_T);
 196     tcg_gen_or_i32(dst, cpu_sr, t0);
 197     tcg_temp_free_i32(t0);
 198 }
 199
 200 static void gen_write_sr(TCGv src)
 201 {
 202     tcg_gen_andi_i32(cpu_sr, src,
 203                      ~((1u << SR_Q) | (1u << SR_M) | (1u << SR_T)));
 204     tcg_gen_extract_i32(cpu_sr_q, src, SR_Q, 1);
 205     tcg_gen_extract_i32(cpu_sr_m, src, SR_M, 1);
 206     tcg_gen_extract_i32(cpu_sr_t, src, SR_T, 1);
 207 }
 208
 209 static inline void gen_save_cpu_state(DisasContext *ctx, bool save_pc)
 210 {
 211     if (save_pc) {
 212         tcg_gen_movi_i32(cpu_pc, ctx->pc);
 213     }
 214     if (ctx->delayed_pc != (uint32_t) -1) {
 215         tcg_gen_movi_i32(cpu_delayed_pc, ctx->delayed_pc);
 216     }
 217     if ((ctx->tbflags & TB_FLAG_ENVFLAGS_MASK) != ctx->envflags) {
 218         tcg_gen_movi_i32(cpu_flags, ctx->envflags);
 219     }
 220 }
 221
 222 static inline bool use_exit_tb(DisasContext *ctx)
 223 {
 224     return (ctx->tbflags & GUSA_EXCLUSIVE) != 0;
 225 }
 226
 227 static inline bool use_goto_tb(DisasContext *ctx, target_ulong dest)
 228 {
 229     /* Use a direct jump if in same page and singlestep not enabled */
 230     if (unlikely(ctx->singlestep_enabled || use_exit_tb(ctx))) {
 231         return false;
 232     }
 233 #ifndef CONFIG_USER_ONLY
 234     return (ctx->tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK);
 235 #else
 236     return true;
 237 #endif
 238 }
 239
 240 static void gen_goto_tb(DisasContext *ctx, int n, target_ulong dest)
 241 {
 242     if (use_goto_tb(ctx, dest)) {
 243         tcg_gen_goto_tb(n);
 244         tcg_gen_movi_i32(cpu_pc, dest);
 245         tcg_gen_exit_tb((uintptr_t)ctx->tb + n);
 246     } else {
 247         tcg_gen_movi_i32(cpu_pc, dest);
 248         if (ctx->singlestep_enabled) {
 249             gen_helper_debug(cpu_env);
 250         } else if (use_exit_tb(ctx)) {
 251             tcg_gen_exit_tb(0);
 252         } else {
 253             tcg_gen_lookup_and_goto_ptr();
 254         }
 255     }
 256 }
 257
 258 static void gen_jump(DisasContext * ctx)
 259 {
 260     if (ctx->delayed_pc == -1) {
 261         /* Target is not statically known, it comes necessarily from a
 262            delayed jump as immediate jump are conditinal jumps */
 263         tcg_gen_mov_i32(cpu_pc, cpu_delayed_pc);
 264         tcg_gen_discard_i32(cpu_delayed_pc);
 265         if (ctx->singlestep_enabled) {
 266             gen_helper_debug(cpu_env);
 267         } else if (use_exit_tb(ctx)) {
 268             tcg_gen_exit_tb(0);
 269         } else {
 270             tcg_gen_lookup_and_goto_ptr();
 271         }
 272     } else {
 273         gen_goto_tb(ctx, 0, ctx->delayed_pc);
 274     }
 275 }
 276
 277 /* Immediate conditional jump (bt or bf) */
 278 static void gen_conditional_jump(DisasContext *ctx, target_ulong dest,
 279                                  bool jump_if_true)
 280 {
 281     TCGLabel *l1 = gen_new_label();
 282     TCGCond cond_not_taken = jump_if_true ? TCG_COND_EQ : TCG_COND_NE;
 283
 284     if (ctx->tbflags & GUSA_EXCLUSIVE) {
 285         /* When in an exclusive region, we must continue to the end.
 286            Therefore, exit the region on a taken branch, but otherwise
 287            fall through to the next instruction.  */
 288         tcg_gen_brcondi_i32(cond_not_taken, cpu_sr_t, 0, l1);
 289         tcg_gen_movi_i32(cpu_flags, ctx->envflags & ~GUSA_MASK);
 290         /* Note that this won't actually use a goto_tb opcode because we
 291            disallow it in use_goto_tb, but it handles exit + singlestep.  */
 292         gen_goto_tb(ctx, 0, dest);
 293         gen_set_label(l1);
 294         return;
 295     }
 296
 297     gen_save_cpu_state(ctx, false);
 298     tcg_gen_brcondi_i32(cond_not_taken, cpu_sr_t, 0, l1);
 299     gen_goto_tb(ctx, 0, dest);
 300     gen_set_label(l1);
 301     gen_goto_tb(ctx, 1, ctx->pc + 2);
 302     ctx->bstate = BS_BRANCH;
 303 }
 304
 305 /* Delayed conditional jump (bt or bf) */
 306 static void gen_delayed_conditional_jump(DisasContext * ctx)
 307 {
 308     TCGLabel *l1 = gen_new_label();
 309     TCGv ds = tcg_temp_new();
 310
 311     tcg_gen_mov_i32(ds, cpu_delayed_cond);
 312     tcg_gen_discard_i32(cpu_delayed_cond);
 313
 314     if (ctx->tbflags & GUSA_EXCLUSIVE) {
 315         /* When in an exclusive region, we must continue to the end.
 316            Therefore, exit the region on a taken branch, but otherwise
 317            fall through to the next instruction.  */
 318         tcg_gen_brcondi_i32(TCG_COND_EQ, ds, 0, l1);
 319
 320         /* Leave the gUSA region.  */
 321         tcg_gen_movi_i32(cpu_flags, ctx->envflags & ~GUSA_MASK);
 322         gen_jump(ctx);
 323
 324         gen_set_label(l1);
 325         return;
 326     }
 327
 328     tcg_gen_brcondi_i32(TCG_COND_NE, ds, 0, l1);
 329     gen_goto_tb(ctx, 1, ctx->pc + 2);
 330     gen_set_label(l1);
 331     gen_jump(ctx);
 332 }
 333
 334 static inline void gen_load_fpr64(DisasContext *ctx, TCGv_i64 t, int reg)
 335 {
 336     /* We have already signaled illegal instruction for odd Dr.  */
 337     tcg_debug_assert((reg & 1) == 0);
 338     reg ^= ctx->fbank;
 339     tcg_gen_concat_i32_i64(t, cpu_fregs[reg + 1], cpu_fregs[reg]);
 340 }
 341
 342 static inline void gen_store_fpr64(DisasContext *ctx, TCGv_i64 t, int reg)
 343 {
 344     /* We have already signaled illegal instruction for odd Dr.  */
 345     tcg_debug_assert((reg & 1) == 0);
 346     reg ^= ctx->fbank;
 347     tcg_gen_extr_i64_i32(cpu_fregs[reg + 1], cpu_fregs[reg], t);
 348 }
 349
 350 #define B3_0 (ctx->opcode & 0xf)
 351 #define B6_4 ((ctx->opcode >> 4) & 0x7)
 352 #define B7_4 ((ctx->opcode >> 4) & 0xf)
 353 #define B7_0 (ctx->opcode & 0xff)
 354 #define B7_0s ((int32_t) (int8_t) (ctx->opcode & 0xff))
 355 #define B11_0s (ctx->opcode & 0x800 ? 0xfffff000 | (ctx->opcode & 0xfff) : \
 356   (ctx->opcode & 0xfff))
 357 #define B11_8 ((ctx->opcode >> 8) & 0xf)
 358 #define B15_12 ((ctx->opcode >> 12) & 0xf)
 359
 360 #define REG(x)     cpu_gregs[(x) ^ ctx->gbank]
 361 #define ALTREG(x)  cpu_gregs[(x) ^ ctx->gbank ^ 0x10]
 362 #define FREG(x)    cpu_fregs[(x) ^ ctx->fbank]
 363
 364 #define XHACK(x) ((((x) & 1 ) << 4) | ((x) & 0xe))
 365
 366 #define CHECK_NOT_DELAY_SLOT \
 367     if (ctx->envflags & DELAY_SLOT_MASK) {  \
 368         goto do_illegal_slot;               \
 369     }
 370
 371 #define CHECK_PRIVILEGED \
 372     if (IS_USER(ctx)) {                     \
 373         goto do_illegal;                    \
 374     }
 375
 376 #define CHECK_FPU_ENABLED \
 377     if (ctx->tbflags & (1u << SR_FD)) {     \
 378         goto do_fpu_disabled;               \
 379     }
 380
 381 #define CHECK_FPSCR_PR_0 \
 382     if (ctx->tbflags & FPSCR_PR) {          \
 383         goto do_illegal;                    \
 384     }
 385
 386 #define CHECK_FPSCR_PR_1 \
 387     if (!(ctx->tbflags & FPSCR_PR)) {       \
 388         goto do_illegal;                    \
 389     }
 390
 391 #define CHECK_SH4A \
 392     if (!(ctx->features & SH_FEATURE_SH4A)) { \
 393         goto do_illegal;                      \
 394     }
 395
 396 static void _decode_opc(DisasContext * ctx)
 397 {
 398     /* This code tries to make movcal emulation sufficiently
 399        accurate for Linux purposes.  This instruction writes
 400        memory, and prior to that, always allocates a cache line.
 401        It is used in two contexts:
 402        - in memcpy, where data is copied in blocks, the first write
 403        of to a block uses movca.l for performance.
 404        - in arch/sh/mm/cache-sh4.c, movcal.l + ocbi combination is used
 405        to flush the cache. Here, the data written by movcal.l is never
 406        written to memory, and the data written is just bogus.
 407
 408        To simulate this, we simulate movcal.l, we store the value to memory,
 409        but we also remember the previous content. If we see ocbi, we check
 410        if movcal.l for that address was done previously. If so, the write should
 411        not have hit the memory, so we restore the previous content.
 412        When we see an instruction that is neither movca.l
 413        nor ocbi, the previous content is discarded.
 414
 415        To optimize, we only try to flush stores when we're at the start of
 416        TB, or if we already saw movca.l in this TB and did not flush stores
 417        yet.  */
 418     if (ctx->has_movcal)
 419         {
 420           int opcode = ctx->opcode & 0xf0ff;
 421           if (opcode != 0x0093 /* ocbi */
 422               && opcode != 0x00c3 /* movca.l */)
 423               {
 424                   gen_helper_discard_movcal_backup(cpu_env);
 425                   ctx->has_movcal = 0;
 426               }
 427         }
 428
 429 #if 0
 430     fprintf(stderr, "Translating opcode 0x%04x\n", ctx->opcode);
 431 #endif
 432
 433     switch (ctx->opcode) {
 434     case 0x0019:                /* div0u */
 435         tcg_gen_movi_i32(cpu_sr_m, 0);
 436         tcg_gen_movi_i32(cpu_sr_q, 0);
 437         tcg_gen_movi_i32(cpu_sr_t, 0);
 438         return;
 439     case 0x000b:                /* rts */
 440         CHECK_NOT_DELAY_SLOT
 441         tcg_gen_mov_i32(cpu_delayed_pc, cpu_pr);
 442         ctx->envflags |= DELAY_SLOT;
 443         ctx->delayed_pc = (uint32_t) - 1;
 444         return;
 445     case 0x0028:                /* clrmac */
 446         tcg_gen_movi_i32(cpu_mach, 0);
 447         tcg_gen_movi_i32(cpu_macl, 0);
 448         return;
 449     case 0x0048:                /* clrs */
 450         tcg_gen_andi_i32(cpu_sr, cpu_sr, ~(1u << SR_S));
 451         return;
 452     case 0x0008:                /* clrt */
 453         tcg_gen_movi_i32(cpu_sr_t, 0);
 454         return;
 455     case 0x0038:                /* ldtlb */
 456         CHECK_PRIVILEGED
 457         gen_helper_ldtlb(cpu_env);
 458         return;
 459     case 0x002b:                /* rte */
 460         CHECK_PRIVILEGED
 461         CHECK_NOT_DELAY_SLOT
 462         gen_write_sr(cpu_ssr);
 463         tcg_gen_mov_i32(cpu_delayed_pc, cpu_spc);
 464         ctx->envflags |= DELAY_SLOT_RTE;
 465         ctx->delayed_pc = (uint32_t) - 1;
 466         ctx->bstate = BS_STOP;
 467         return;
 468     case 0x0058:                /* sets */
 469         tcg_gen_ori_i32(cpu_sr, cpu_sr, (1u << SR_S));
 470         return;
 471     case 0x0018:                /* sett */
 472         tcg_gen_movi_i32(cpu_sr_t, 1);
 473         return;
 474     case 0xfbfd:                /* frchg */
 475         CHECK_FPSCR_PR_0
 476         tcg_gen_xori_i32(cpu_fpscr, cpu_fpscr, FPSCR_FR);
 477         ctx->bstate = BS_STOP;
 478         return;
 479     case 0xf3fd:                /* fschg */
 480         CHECK_FPSCR_PR_0
 481         tcg_gen_xori_i32(cpu_fpscr, cpu_fpscr, FPSCR_SZ);
 482         ctx->bstate = BS_STOP;
 483         return;
 484     case 0xf7fd:                /* fpchg */
 485         CHECK_SH4A
 486         tcg_gen_xori_i32(cpu_fpscr, cpu_fpscr, FPSCR_PR);
 487         ctx->bstate = BS_STOP;
 488         return;
 489     case 0x0009:                /* nop */
 490         return;
 491     case 0x001b:                /* sleep */
 492         CHECK_PRIVILEGED
 493         tcg_gen_movi_i32(cpu_pc, ctx->pc + 2);
 494         gen_helper_sleep(cpu_env);
 495         return;
 496     }
 497
 498     switch (ctx->opcode & 0xf000) {
 499     case 0x1000:                /* mov.l Rm,@(disp,Rn) */
 500         {
 501             TCGv addr = tcg_temp_new();
 502             tcg_gen_addi_i32(addr, REG(B11_8), B3_0 * 4);
 503             tcg_gen_qemu_st_i32(REG(B7_4), addr, ctx->memidx, MO_TEUL);
 504             tcg_temp_free(addr);
 505         }
 506         return;
 507     case 0x5000:                /* mov.l @(disp,Rm),Rn */
 508         {
 509             TCGv addr = tcg_temp_new();
 510             tcg_gen_addi_i32(addr, REG(B7_4), B3_0 * 4);
 511             tcg_gen_qemu_ld_i32(REG(B11_8), addr, ctx->memidx, MO_TESL);
 512             tcg_temp_free(addr);
 513         }
 514         return;
 515     case 0xe000:                /* mov #imm,Rn */
 516 #ifdef CONFIG_USER_ONLY
 517         /* Detect the start of a gUSA region.  If so, update envflags
 518            and end the TB.  This will allow us to see the end of the
 519            region (stored in R0) in the next TB.  */
 520         if (B11_8 == 15 && B7_0s < 0 && (tb_cflags(ctx->tb) & CF_PARALLEL)) {
 521             ctx->envflags = deposit32(ctx->envflags, GUSA_SHIFT, 8, B7_0s);
 522             ctx->bstate = BS_STOP;
 523         }
 524 #endif
 525         tcg_gen_movi_i32(REG(B11_8), B7_0s);
 526         return;
 527     case 0x9000:                /* mov.w @(disp,PC),Rn */
 528         {
 529             TCGv addr = tcg_const_i32(ctx->pc + 4 + B7_0 * 2);
 530             tcg_gen_qemu_ld_i32(REG(B11_8), addr, ctx->memidx, MO_TESW);
 531             tcg_temp_free(addr);
 532         }
 533         return;
 534     case 0xd000:                /* mov.l @(disp,PC),Rn */
 535         {
 536             TCGv addr = tcg_const_i32((ctx->pc + 4 + B7_0 * 4) & ~3);
 537             tcg_gen_qemu_ld_i32(REG(B11_8), addr, ctx->memidx, MO_TESL);
 538             tcg_temp_free(addr);
 539         }
 540         return;
 541     case 0x7000:                /* add #imm,Rn */
 542         tcg_gen_addi_i32(REG(B11_8), REG(B11_8), B7_0s);
 543         return;
 544     case 0xa000:                /* bra disp */
 545         CHECK_NOT_DELAY_SLOT
 546         ctx->delayed_pc = ctx->pc + 4 + B11_0s * 2;
 547         ctx->envflags |= DELAY_SLOT;
 548         return;
 549     case 0xb000:                /* bsr disp */
 550         CHECK_NOT_DELAY_SLOT
 551         tcg_gen_movi_i32(cpu_pr, ctx->pc + 4);
 552         ctx->delayed_pc = ctx->pc + 4 + B11_0s * 2;
 553         ctx->envflags |= DELAY_SLOT;
 554         return;
 555     }
 556
 557     switch (ctx->opcode & 0xf00f) {
 558     case 0x6003:                /* mov Rm,Rn */
 559         tcg_gen_mov_i32(REG(B11_8), REG(B7_4));
 560         return;
 561     case 0x2000:                /* mov.b Rm,@Rn */
 562         tcg_gen_qemu_st_i32(REG(B7_4), REG(B11_8), ctx->memidx, MO_UB);
 563         return;
 564     case 0x2001:                /* mov.w Rm,@Rn */
 565         tcg_gen_qemu_st_i32(REG(B7_4), REG(B11_8), ctx->memidx, MO_TEUW);
 566         return;
 567     case 0x2002:                /* mov.l Rm,@Rn */
 568         tcg_gen_qemu_st_i32(REG(B7_4), REG(B11_8), ctx->memidx, MO_TEUL);
 569         return;
 570     case 0x6000:                /* mov.b @Rm,Rn */
 571         tcg_gen_qemu_ld_i32(REG(B11_8), REG(B7_4), ctx->memidx, MO_SB);
 572         return;
 573     case 0x6001:                /* mov.w @Rm,Rn */
 574         tcg_gen_qemu_ld_i32(REG(B11_8), REG(B7_4), ctx->memidx, MO_TESW);
 575         return;
 576     case 0x6002:                /* mov.l @Rm,Rn */
 577         tcg_gen_qemu_ld_i32(REG(B11_8), REG(B7_4), ctx->memidx, MO_TESL);
 578         return;
 579     case 0x2004:                /* mov.b Rm,@-Rn */
 580         {
 581             TCGv addr = tcg_temp_new();
 582             tcg_gen_subi_i32(addr, REG(B11_8), 1);
 583             /* might cause re-execution */
 584             tcg_gen_qemu_st_i32(REG(B7_4), addr, ctx->memidx, MO_UB);
 585             tcg_gen_mov_i32(REG(B11_8), addr);                  /* modify register status */
 586             tcg_temp_free(addr);
 587         }
 588         return;
 589     case 0x2005:                /* mov.w Rm,@-Rn */
 590         {
 591             TCGv addr = tcg_temp_new();
 592             tcg_gen_subi_i32(addr, REG(B11_8), 2);
 593             tcg_gen_qemu_st_i32(REG(B7_4), addr, ctx->memidx, MO_TEUW);
 594             tcg_gen_mov_i32(REG(B11_8), addr);
 595             tcg_temp_free(addr);
 596         }
 597         return;
 598     case 0x2006:                /* mov.l Rm,@-Rn */
 599         {
 600             TCGv addr = tcg_temp_new();
 601             tcg_gen_subi_i32(addr, REG(B11_8), 4);
 602             tcg_gen_qemu_st_i32(REG(B7_4), addr, ctx->memidx, MO_TEUL);
 603             tcg_gen_mov_i32(REG(B11_8), addr);
 604         }
 605         return;
 606     case 0x6004:                /* mov.b @Rm+,Rn */
 607         tcg_gen_qemu_ld_i32(REG(B11_8), REG(B7_4), ctx->memidx, MO_SB);
 608         if ( B11_8 != B7_4 )
 609                 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 1);
 610         return;
 611     case 0x6005:                /* mov.w @Rm+,Rn */
 612         tcg_gen_qemu_ld_i32(REG(B11_8), REG(B7_4), ctx->memidx, MO_TESW);
 613         if ( B11_8 != B7_4 )
 614                 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 2);
 615         return;
 616     case 0x6006:                /* mov.l @Rm+,Rn */
 617         tcg_gen_qemu_ld_i32(REG(B11_8), REG(B7_4), ctx->memidx, MO_TESL);
 618         if ( B11_8 != B7_4 )
 619                 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 4);
 620         return;
 621     case 0x0004:                /* mov.b Rm,@(R0,Rn) */
 622         {
 623             TCGv addr = tcg_temp_new();
 624             tcg_gen_add_i32(addr, REG(B11_8), REG(0));
 625             tcg_gen_qemu_st_i32(REG(B7_4), addr, ctx->memidx, MO_UB);
 626             tcg_temp_free(addr);
 627         }
 628         return;
 629     case 0x0005:                /* mov.w Rm,@(R0,Rn) */
 630         {
 631             TCGv addr = tcg_temp_new();
 632             tcg_gen_add_i32(addr, REG(B11_8), REG(0));
 633             tcg_gen_qemu_st_i32(REG(B7_4), addr, ctx->memidx, MO_TEUW);
 634             tcg_temp_free(addr);
 635         }
 636         return;
 637     case 0x0006:                /* mov.l Rm,@(R0,Rn) */
 638         {
 639             TCGv addr = tcg_temp_new();
 640             tcg_gen_add_i32(addr, REG(B11_8), REG(0));
 641             tcg_gen_qemu_st_i32(REG(B7_4), addr, ctx->memidx, MO_TEUL);
 642             tcg_temp_free(addr);
 643         }
 644         return;
 645     case 0x000c:                /* mov.b @(R0,Rm),Rn */
 646         {
 647             TCGv addr = tcg_temp_new();
 648             tcg_gen_add_i32(addr, REG(B7_4), REG(0));
 649             tcg_gen_qemu_ld_i32(REG(B11_8), addr, ctx->memidx, MO_SB);
 650             tcg_temp_free(addr);
 651         }
 652         return;
 653     case 0x000d:                /* mov.w @(R0,Rm),Rn */
 654         {
 655             TCGv addr = tcg_temp_new();
 656             tcg_gen_add_i32(addr, REG(B7_4), REG(0));
 657             tcg_gen_qemu_ld_i32(REG(B11_8), addr, ctx->memidx, MO_TESW);
 658             tcg_temp_free(addr);
 659         }
 660         return;
 661     case 0x000e:                /* mov.l @(R0,Rm),Rn */
 662         {
 663             TCGv addr = tcg_temp_new();
 664             tcg_gen_add_i32(addr, REG(B7_4), REG(0));
 665             tcg_gen_qemu_ld_i32(REG(B11_8), addr, ctx->memidx, MO_TESL);
 666             tcg_temp_free(addr);
 667         }
 668         return;
 669     case 0x6008:                /* swap.b Rm,Rn */
 670         {
 671             TCGv low = tcg_temp_new();;
 672             tcg_gen_ext16u_i32(low, REG(B7_4));
 673             tcg_gen_bswap16_i32(low, low);
 674             tcg_gen_deposit_i32(REG(B11_8), REG(B7_4), low, 0, 16);
 675             tcg_temp_free(low);
 676         }
 677         return;
 678     case 0x6009:                /* swap.w Rm,Rn */
 679         tcg_gen_rotli_i32(REG(B11_8), REG(B7_4), 16);
 680         return;
 681     case 0x200d:                /* xtrct Rm,Rn */
 682         {
 683             TCGv high, low;
 684             high = tcg_temp_new();
 685             tcg_gen_shli_i32(high, REG(B7_4), 16);
 686             low = tcg_temp_new();
 687             tcg_gen_shri_i32(low, REG(B11_8), 16);
 688             tcg_gen_or_i32(REG(B11_8), high, low);
 689             tcg_temp_free(low);
 690             tcg_temp_free(high);
 691         }
 692         return;
 693     case 0x300c:                /* add Rm,Rn */
 694         tcg_gen_add_i32(REG(B11_8), REG(B11_8), REG(B7_4));
 695         return;
 696     case 0x300e:                /* addc Rm,Rn */
 697         {
 698             TCGv t0, t1;
 699             t0 = tcg_const_tl(0);
 700             t1 = tcg_temp_new();
 701             tcg_gen_add2_i32(t1, cpu_sr_t, cpu_sr_t, t0, REG(B7_4), t0);
 702             tcg_gen_add2_i32(REG(B11_8), cpu_sr_t,
 703                              REG(B11_8), t0, t1, cpu_sr_t);
 704             tcg_temp_free(t0);
 705             tcg_temp_free(t1);
 706         }
 707         return;
 708     case 0x300f:                /* addv Rm,Rn */
 709         {
 710             TCGv t0, t1, t2;
 711             t0 = tcg_temp_new();
 712             tcg_gen_add_i32(t0, REG(B7_4), REG(B11_8));
 713             t1 = tcg_temp_new();
 714             tcg_gen_xor_i32(t1, t0, REG(B11_8));
 715             t2 = tcg_temp_new();
 716             tcg_gen_xor_i32(t2, REG(B7_4), REG(B11_8));
 717             tcg_gen_andc_i32(cpu_sr_t, t1, t2);
 718             tcg_temp_free(t2);
 719             tcg_gen_shri_i32(cpu_sr_t, cpu_sr_t, 31);
 720             tcg_temp_free(t1);
 721             tcg_gen_mov_i32(REG(B7_4), t0);
 722             tcg_temp_free(t0);
 723         }
 724         return;
 725     case 0x2009:                /* and Rm,Rn */
 726         tcg_gen_and_i32(REG(B11_8), REG(B11_8), REG(B7_4));
 727         return;
 728     case 0x3000:                /* cmp/eq Rm,Rn */
 729         tcg_gen_setcond_i32(TCG_COND_EQ, cpu_sr_t, REG(B11_8), REG(B7_4));
 730         return;
 731     case 0x3003:                /* cmp/ge Rm,Rn */
 732         tcg_gen_setcond_i32(TCG_COND_GE, cpu_sr_t, REG(B11_8), REG(B7_4));
 733         return;
 734     case 0x3007:                /* cmp/gt Rm,Rn */
 735         tcg_gen_setcond_i32(TCG_COND_GT, cpu_sr_t, REG(B11_8), REG(B7_4));
 736         return;
 737     case 0x3006:                /* cmp/hi Rm,Rn */
 738         tcg_gen_setcond_i32(TCG_COND_GTU, cpu_sr_t, REG(B11_8), REG(B7_4));
 739         return;
 740     case 0x3002:                /* cmp/hs Rm,Rn */
 741         tcg_gen_setcond_i32(TCG_COND_GEU, cpu_sr_t, REG(B11_8), REG(B7_4));
 742         return;
 743     case 0x200c:                /* cmp/str Rm,Rn */
 744         {
 745             TCGv cmp1 = tcg_temp_new();
 746             TCGv cmp2 = tcg_temp_new();
 747             tcg_gen_xor_i32(cmp2, REG(B7_4), REG(B11_8));
 748             tcg_gen_subi_i32(cmp1, cmp2, 0x01010101);
 749             tcg_gen_andc_i32(cmp1, cmp1, cmp2);
 750             tcg_gen_andi_i32(cmp1, cmp1, 0x80808080);
 751             tcg_gen_setcondi_i32(TCG_COND_NE, cpu_sr_t, cmp1, 0);
 752             tcg_temp_free(cmp2);
 753             tcg_temp_free(cmp1);
 754         }
 755         return;
 756     case 0x2007:                /* div0s Rm,Rn */
 757         tcg_gen_shri_i32(cpu_sr_q, REG(B11_8), 31);         /* SR_Q */
 758         tcg_gen_shri_i32(cpu_sr_m, REG(B7_4), 31);          /* SR_M */
 759         tcg_gen_xor_i32(cpu_sr_t, cpu_sr_q, cpu_sr_m);      /* SR_T */
 760         return;
 761     case 0x3004:                /* div1 Rm,Rn */
 762         {
 763             TCGv t0 = tcg_temp_new();
 764             TCGv t1 = tcg_temp_new();
 765             TCGv t2 = tcg_temp_new();
 766             TCGv zero = tcg_const_i32(0);
 767
 768             /* shift left arg1, saving the bit being pushed out and inserting
 769                T on the right */
 770             tcg_gen_shri_i32(t0, REG(B11_8), 31);
 771             tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 1);
 772             tcg_gen_or_i32(REG(B11_8), REG(B11_8), cpu_sr_t);
 773
 774             /* Add or subtract arg0 from arg1 depending if Q == M. To avoid
 775                using 64-bit temps, we compute arg0's high part from q ^ m, so
 776                that it is 0x00000000 when adding the value or 0xffffffff when
 777                subtracting it. */
 778             tcg_gen_xor_i32(t1, cpu_sr_q, cpu_sr_m);
 779             tcg_gen_subi_i32(t1, t1, 1);
 780             tcg_gen_neg_i32(t2, REG(B7_4));
 781             tcg_gen_movcond_i32(TCG_COND_EQ, t2, t1, zero, REG(B7_4), t2);
 782             tcg_gen_add2_i32(REG(B11_8), t1, REG(B11_8), zero, t2, t1);
 783
 784             /* compute T and Q depending on carry */
 785             tcg_gen_andi_i32(t1, t1, 1);
 786             tcg_gen_xor_i32(t1, t1, t0);
 787             tcg_gen_xori_i32(cpu_sr_t, t1, 1);
 788             tcg_gen_xor_i32(cpu_sr_q, cpu_sr_m, t1);
 789
 790             tcg_temp_free(zero);
 791             tcg_temp_free(t2);
 792             tcg_temp_free(t1);
 793             tcg_temp_free(t0);
 794         }
 795         return;
 796     case 0x300d:                /* dmuls.l Rm,Rn */
 797         tcg_gen_muls2_i32(cpu_macl, cpu_mach, REG(B7_4), REG(B11_8));
 798         return;
 799     case 0x3005:                /* dmulu.l Rm,Rn */
 800         tcg_gen_mulu2_i32(cpu_macl, cpu_mach, REG(B7_4), REG(B11_8));
 801         return;
 802     case 0x600e:                /* exts.b Rm,Rn */
 803         tcg_gen_ext8s_i32(REG(B11_8), REG(B7_4));
 804         return;
 805     case 0x600f:                /* exts.w Rm,Rn */
 806         tcg_gen_ext16s_i32(REG(B11_8), REG(B7_4));
 807         return;
 808     case 0x600c:                /* extu.b Rm,Rn */
 809         tcg_gen_ext8u_i32(REG(B11_8), REG(B7_4));
 810         return;
 811     case 0x600d:                /* extu.w Rm,Rn */
 812         tcg_gen_ext16u_i32(REG(B11_8), REG(B7_4));
 813         return;
 814     case 0x000f:                /* mac.l @Rm+,@Rn+ */
 815         {
 816             TCGv arg0, arg1;
 817             arg0 = tcg_temp_new();
 818             tcg_gen_qemu_ld_i32(arg0, REG(B7_4), ctx->memidx, MO_TESL);
 819             arg1 = tcg_temp_new();
 820             tcg_gen_qemu_ld_i32(arg1, REG(B11_8), ctx->memidx, MO_TESL);
 821             gen_helper_macl(cpu_env, arg0, arg1);
 822             tcg_temp_free(arg1);
 823             tcg_temp_free(arg0);
 824             tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 4);
 825             tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
 826         }
 827         return;
 828     case 0x400f:                /* mac.w @Rm+,@Rn+ */
 829         {
 830             TCGv arg0, arg1;
 831             arg0 = tcg_temp_new();
 832             tcg_gen_qemu_ld_i32(arg0, REG(B7_4), ctx->memidx, MO_TESL);
 833             arg1 = tcg_temp_new();
 834             tcg_gen_qemu_ld_i32(arg1, REG(B11_8), ctx->memidx, MO_TESL);
 835             gen_helper_macw(cpu_env, arg0, arg1);
 836             tcg_temp_free(arg1);
 837             tcg_temp_free(arg0);
 838             tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 2);
 839             tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 2);
 840         }
 841         return;
 842     case 0x0007:                /* mul.l Rm,Rn */
 843         tcg_gen_mul_i32(cpu_macl, REG(B7_4), REG(B11_8));
 844         return;
 845     case 0x200f:                /* muls.w Rm,Rn */
 846         {
 847             TCGv arg0, arg1;
 848             arg0 = tcg_temp_new();
 849             tcg_gen_ext16s_i32(arg0, REG(B7_4));
 850             arg1 = tcg_temp_new();
 851             tcg_gen_ext16s_i32(arg1, REG(B11_8));
 852             tcg_gen_mul_i32(cpu_macl, arg0, arg1);
 853             tcg_temp_free(arg1);
 854             tcg_temp_free(arg0);
 855         }
 856         return;
 857     case 0x200e:                /* mulu.w Rm,Rn */
 858         {
 859             TCGv arg0, arg1;
 860             arg0 = tcg_temp_new();
 861             tcg_gen_ext16u_i32(arg0, REG(B7_4));
 862             arg1 = tcg_temp_new();
 863             tcg_gen_ext16u_i32(arg1, REG(B11_8));
 864             tcg_gen_mul_i32(cpu_macl, arg0, arg1);
 865             tcg_temp_free(arg1);
 866             tcg_temp_free(arg0);
 867         }
 868         return;
 869     case 0x600b:                /* neg Rm,Rn */
 870         tcg_gen_neg_i32(REG(B11_8), REG(B7_4));
 871         return;
 872     case 0x600a:                /* negc Rm,Rn */
 873         {
 874             TCGv t0 = tcg_const_i32(0);
 875             tcg_gen_add2_i32(REG(B11_8), cpu_sr_t,
 876                              REG(B7_4), t0, cpu_sr_t, t0);
 877             tcg_gen_sub2_i32(REG(B11_8), cpu_sr_t,
 878                              t0, t0, REG(B11_8), cpu_sr_t);
 879             tcg_gen_andi_i32(cpu_sr_t, cpu_sr_t, 1);
 880             tcg_temp_free(t0);
 881         }
 882         return;
 883     case 0x6007:                /* not Rm,Rn */
 884         tcg_gen_not_i32(REG(B11_8), REG(B7_4));
 885         return;
 886     case 0x200b:                /* or Rm,Rn */
 887         tcg_gen_or_i32(REG(B11_8), REG(B11_8), REG(B7_4));
 888         return;
 889     case 0x400c:                /* shad Rm,Rn */
 890         {
 891             TCGv t0 = tcg_temp_new();
 892             TCGv t1 = tcg_temp_new();
 893             TCGv t2 = tcg_temp_new();
 894
 895             tcg_gen_andi_i32(t0, REG(B7_4), 0x1f);
 896
 897             /* positive case: shift to the left */
 898             tcg_gen_shl_i32(t1, REG(B11_8), t0);
 899
 900             /* negative case: shift to the right in two steps to
 901                correctly handle the -32 case */
 902             tcg_gen_xori_i32(t0, t0, 0x1f);
 903             tcg_gen_sar_i32(t2, REG(B11_8), t0);
 904             tcg_gen_sari_i32(t2, t2, 1);
 905
 906             /* select between the two cases */
 907             tcg_gen_movi_i32(t0, 0);
 908             tcg_gen_movcond_i32(TCG_COND_GE, REG(B11_8), REG(B7_4), t0, t1, t2);
 909
 910             tcg_temp_free(t0);
 911             tcg_temp_free(t1);
 912             tcg_temp_free(t2);
 913         }
 914         return;
 915     case 0x400d:                /* shld Rm,Rn */
 916         {
 917             TCGv t0 = tcg_temp_new();
 918             TCGv t1 = tcg_temp_new();
 919             TCGv t2 = tcg_temp_new();
 920
 921             tcg_gen_andi_i32(t0, REG(B7_4), 0x1f);
 922
 923             /* positive case: shift to the left */
 924             tcg_gen_shl_i32(t1, REG(B11_8), t0);
 925
 926             /* negative case: shift to the right in two steps to
 927                correctly handle the -32 case */
 928             tcg_gen_xori_i32(t0, t0, 0x1f);
 929             tcg_gen_shr_i32(t2, REG(B11_8), t0);
 930             tcg_gen_shri_i32(t2, t2, 1);
 931
 932             /* select between the two cases */
 933             tcg_gen_movi_i32(t0, 0);
 934             tcg_gen_movcond_i32(TCG_COND_GE, REG(B11_8), REG(B7_4), t0, t1, t2);
 935
 936             tcg_temp_free(t0);
 937             tcg_temp_free(t1);
 938             tcg_temp_free(t2);
 939         }
 940         return;
 941     case 0x3008:                /* sub Rm,Rn */
 942         tcg_gen_sub_i32(REG(B11_8), REG(B11_8), REG(B7_4));
 943         return;
 944     case 0x300a:                /* subc Rm,Rn */
 945         {
 946             TCGv t0, t1;
 947             t0 = tcg_const_tl(0);
 948             t1 = tcg_temp_new();
 949             tcg_gen_add2_i32(t1, cpu_sr_t, cpu_sr_t, t0, REG(B7_4), t0);
 950             tcg_gen_sub2_i32(REG(B11_8), cpu_sr_t,
 951                              REG(B11_8), t0, t1, cpu_sr_t);
 952             tcg_gen_andi_i32(cpu_sr_t, cpu_sr_t, 1);
 953             tcg_temp_free(t0);
 954             tcg_temp_free(t1);
 955         }
 956         return;
 957     case 0x300b:                /* subv Rm,Rn */
 958         {
 959             TCGv t0, t1, t2;
 960             t0 = tcg_temp_new();
 961             tcg_gen_sub_i32(t0, REG(B11_8), REG(B7_4));
 962             t1 = tcg_temp_new();
 963             tcg_gen_xor_i32(t1, t0, REG(B7_4));
 964             t2 = tcg_temp_new();
 965             tcg_gen_xor_i32(t2, REG(B11_8), REG(B7_4));
 966             tcg_gen_and_i32(t1, t1, t2);
 967             tcg_temp_free(t2);
 968             tcg_gen_shri_i32(cpu_sr_t, t1, 31);
 969             tcg_temp_free(t1);
 970             tcg_gen_mov_i32(REG(B11_8), t0);
 971             tcg_temp_free(t0);
 972         }
 973         return;
 974     case 0x2008:                /* tst Rm,Rn */
 975         {
 976             TCGv val = tcg_temp_new();
 977             tcg_gen_and_i32(val, REG(B7_4), REG(B11_8));
 978             tcg_gen_setcondi_i32(TCG_COND_EQ, cpu_sr_t, val, 0);
 979             tcg_temp_free(val);
 980         }
 981         return;
 982     case 0x200a:                /* xor Rm,Rn */
 983         tcg_gen_xor_i32(REG(B11_8), REG(B11_8), REG(B7_4));
 984         return;
 985     case 0xf00c: /* fmov {F,D,X}Rm,{F,D,X}Rn - FPSCR: Nothing */
 986         CHECK_FPU_ENABLED
 987         if (ctx->tbflags & FPSCR_SZ) {
 988             int xsrc = XHACK(B7_4);
 989             int xdst = XHACK(B11_8);
 990             tcg_gen_mov_i32(FREG(xdst), FREG(xsrc));
 991             tcg_gen_mov_i32(FREG(xdst + 1), FREG(xsrc + 1));
 992         } else {
 993             tcg_gen_mov_i32(FREG(B11_8), FREG(B7_4));
 994         }
 995         return;
 996     case 0xf00a: /* fmov {F,D,X}Rm,@Rn - FPSCR: Nothing */
 997         CHECK_FPU_ENABLED
 998         if (ctx->tbflags & FPSCR_SZ) {
 999             TCGv_i64 fp = tcg_temp_new_i64();
1000             gen_load_fpr64(ctx, fp, XHACK(B7_4));
1001             tcg_gen_qemu_st_i64(fp, REG(B11_8), ctx->memidx, MO_TEQ);
1002             tcg_temp_free_i64(fp);
1003         } else {
1004             tcg_gen_qemu_st_i32(FREG(B7_4), REG(B11_8), ctx->memidx, MO_TEUL);
1005         }
1006         return;
1007     case 0xf008: /* fmov @Rm,{F,D,X}Rn - FPSCR: Nothing */
1008         CHECK_FPU_ENABLED
1009         if (ctx->tbflags & FPSCR_SZ) {
1010             TCGv_i64 fp = tcg_temp_new_i64();
1011             tcg_gen_qemu_ld_i64(fp, REG(B7_4), ctx->memidx, MO_TEQ);
1012             gen_store_fpr64(ctx, fp, XHACK(B11_8));
1013             tcg_temp_free_i64(fp);
1014         } else {
1015             tcg_gen_qemu_ld_i32(FREG(B11_8), REG(B7_4), ctx->memidx, MO_TEUL);
1016         }
1017         return;
1018     case 0xf009: /* fmov @Rm+,{F,D,X}Rn - FPSCR: Nothing */
1019         CHECK_FPU_ENABLED
1020         if (ctx->tbflags & FPSCR_SZ) {
1021             TCGv_i64 fp = tcg_temp_new_i64();
1022             tcg_gen_qemu_ld_i64(fp, REG(B7_4), ctx->memidx, MO_TEQ);
1023             gen_store_fpr64(ctx, fp, XHACK(B11_8));
1024             tcg_temp_free_i64(fp);
1025             tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 8);
1026         } else {
1027             tcg_gen_qemu_ld_i32(FREG(B11_8), REG(B7_4), ctx->memidx, MO_TEUL);
1028             tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 4);
1029         }
1030         return;
1031     case 0xf00b: /* fmov {F,D,X}Rm,@-Rn - FPSCR: Nothing */
1032         CHECK_FPU_ENABLED
1033         {
1034             TCGv addr = tcg_temp_new_i32();
1035             if (ctx->tbflags & FPSCR_SZ) {
1036                 TCGv_i64 fp = tcg_temp_new_i64();
1037                 gen_load_fpr64(ctx, fp, XHACK(B7_4));
1038                 tcg_gen_subi_i32(addr, REG(B11_8), 8);
1039                 tcg_gen_qemu_st_i64(fp, addr, ctx->memidx, MO_TEQ);
1040                 tcg_temp_free_i64(fp);
1041             } else {
1042                 tcg_gen_subi_i32(addr, REG(B11_8), 4);
1043                 tcg_gen_qemu_st_i32(FREG(B7_4), addr, ctx->memidx, MO_TEUL);
1044             }
1045             tcg_gen_mov_i32(REG(B11_8), addr);
1046             tcg_temp_free(addr);
1047         }
1048         return;
1049     case 0xf006: /* fmov @(R0,Rm),{F,D,X}Rm - FPSCR: Nothing */
1050         CHECK_FPU_ENABLED
1051         {
1052             TCGv addr = tcg_temp_new_i32();
1053             tcg_gen_add_i32(addr, REG(B7_4), REG(0));
1054             if (ctx->tbflags & FPSCR_SZ) {
1055                 TCGv_i64 fp = tcg_temp_new_i64();
1056                 tcg_gen_qemu_ld_i64(fp, addr, ctx->memidx, MO_TEQ);
1057                 gen_store_fpr64(ctx, fp, XHACK(B11_8));
1058                 tcg_temp_free_i64(fp);
1059             } else {
1060                 tcg_gen_qemu_ld_i32(FREG(B11_8), addr, ctx->memidx, MO_TEUL);
1061             }
1062             tcg_temp_free(addr);
1063         }
1064         return;
1065     case 0xf007: /* fmov {F,D,X}Rn,@(R0,Rn) - FPSCR: Nothing */
1066         CHECK_FPU_ENABLED
1067         {
1068             TCGv addr = tcg_temp_new();
1069             tcg_gen_add_i32(addr, REG(B11_8), REG(0));
1070             if (ctx->tbflags & FPSCR_SZ) {
1071                 TCGv_i64 fp = tcg_temp_new_i64();
1072                 gen_load_fpr64(ctx, fp, XHACK(B7_4));
1073                 tcg_gen_qemu_st_i64(fp, addr, ctx->memidx, MO_TEQ);
1074                 tcg_temp_free_i64(fp);
1075             } else {
1076                 tcg_gen_qemu_st_i32(FREG(B7_4), addr, ctx->memidx, MO_TEUL);
1077             }
1078             tcg_temp_free(addr);
1079         }
1080         return;
1081     case 0xf000: /* fadd Rm,Rn - FPSCR: R[PR,Enable.O/U/I]/W[Cause,Flag] */
1082     case 0xf001: /* fsub Rm,Rn - FPSCR: R[PR,Enable.O/U/I]/W[Cause,Flag] */
1083     case 0xf002: /* fmul Rm,Rn - FPSCR: R[PR,Enable.O/U/I]/W[Cause,Flag] */
1084     case 0xf003: /* fdiv Rm,Rn - FPSCR: R[PR,Enable.O/U/I]/W[Cause,Flag] */
1085     case 0xf004: /* fcmp/eq Rm,Rn - FPSCR: R[PR,Enable.V]/W[Cause,Flag] */
1086     case 0xf005: /* fcmp/gt Rm,Rn - FPSCR: R[PR,Enable.V]/W[Cause,Flag] */
1087         {
1088             CHECK_FPU_ENABLED
1089             if (ctx->tbflags & FPSCR_PR) {
1090                 TCGv_i64 fp0, fp1;
1091
1092                 if (ctx->opcode & 0x0110) {
1093                     goto do_illegal;
1094                 }
1095                 fp0 = tcg_temp_new_i64();
1096                 fp1 = tcg_temp_new_i64();
1097                 gen_load_fpr64(ctx, fp0, B11_8);
1098                 gen_load_fpr64(ctx, fp1, B7_4);
1099                 switch (ctx->opcode & 0xf00f) {
1100                 case 0xf000:            /* fadd Rm,Rn */
1101                     gen_helper_fadd_DT(fp0, cpu_env, fp0, fp1);
1102                     break;
1103                 case 0xf001:            /* fsub Rm,Rn */
1104                     gen_helper_fsub_DT(fp0, cpu_env, fp0, fp1);
1105                     break;
1106                 case 0xf002:            /* fmul Rm,Rn */
1107                     gen_helper_fmul_DT(fp0, cpu_env, fp0, fp1);
1108                     break;
1109                 case 0xf003:            /* fdiv Rm,Rn */
1110                     gen_helper_fdiv_DT(fp0, cpu_env, fp0, fp1);
1111                     break;
1112                 case 0xf004:            /* fcmp/eq Rm,Rn */
1113                     gen_helper_fcmp_eq_DT(cpu_sr_t, cpu_env, fp0, fp1);
1114                     return;
1115                 case 0xf005:            /* fcmp/gt Rm,Rn */
1116                     gen_helper_fcmp_gt_DT(cpu_sr_t, cpu_env, fp0, fp1);
1117                     return;
1118                 }
1119                 gen_store_fpr64(ctx, fp0, B11_8);
1120                 tcg_temp_free_i64(fp0);
1121                 tcg_temp_free_i64(fp1);
1122             } else {
1123                 switch (ctx->opcode & 0xf00f) {
1124                 case 0xf000:            /* fadd Rm,Rn */
1125                     gen_helper_fadd_FT(FREG(B11_8), cpu_env,
1126                                        FREG(B11_8), FREG(B7_4));
1127                     break;
1128                 case 0xf001:            /* fsub Rm,Rn */
1129                     gen_helper_fsub_FT(FREG(B11_8), cpu_env,
1130                                        FREG(B11_8), FREG(B7_4));
1131                     break;
1132                 case 0xf002:            /* fmul Rm,Rn */
1133                     gen_helper_fmul_FT(FREG(B11_8), cpu_env,
1134                                        FREG(B11_8), FREG(B7_4));
1135                     break;
1136                 case 0xf003:            /* fdiv Rm,Rn */
1137                     gen_helper_fdiv_FT(FREG(B11_8), cpu_env,
1138                                        FREG(B11_8), FREG(B7_4));
1139                     break;
1140                 case 0xf004:            /* fcmp/eq Rm,Rn */
1141                     gen_helper_fcmp_eq_FT(cpu_sr_t, cpu_env,
1142                                           FREG(B11_8), FREG(B7_4));
1143                     return;
1144                 case 0xf005:            /* fcmp/gt Rm,Rn */
1145                     gen_helper_fcmp_gt_FT(cpu_sr_t, cpu_env,
1146                                           FREG(B11_8), FREG(B7_4));
1147                     return;
1148                 }
1149             }
1150         }
1151         return;
1152     case 0xf00e: /* fmac FR0,RM,Rn */
1153         CHECK_FPU_ENABLED
1154         CHECK_FPSCR_PR_0
1155         gen_helper_fmac_FT(FREG(B11_8), cpu_env,
1156                            FREG(0), FREG(B7_4), FREG(B11_8));
1157         return;
1158     }
1159
1160     switch (ctx->opcode & 0xff00) {
1161     case 0xc900:                /* and #imm,R0 */
1162         tcg_gen_andi_i32(REG(0), REG(0), B7_0);
1163         return;
1164     case 0xcd00:                /* and.b #imm,@(R0,GBR) */
1165         {
1166             TCGv addr, val;
1167             addr = tcg_temp_new();
1168             tcg_gen_add_i32(addr, REG(0), cpu_gbr);
1169             val = tcg_temp_new();
1170             tcg_gen_qemu_ld_i32(val, addr, ctx->memidx, MO_UB);
1171             tcg_gen_andi_i32(val, val, B7_0);
1172             tcg_gen_qemu_st_i32(val, addr, ctx->memidx, MO_UB);
1173             tcg_temp_free(val);
1174             tcg_temp_free(addr);
1175         }
1176         return;
1177     case 0x8b00:                /* bf label */
1178         CHECK_NOT_DELAY_SLOT
1179         gen_conditional_jump(ctx, ctx->pc + 4 + B7_0s * 2, false);
1180         return;
1181     case 0x8f00:                /* bf/s label */
1182         CHECK_NOT_DELAY_SLOT
1183         tcg_gen_xori_i32(cpu_delayed_cond, cpu_sr_t, 1);
1184         ctx->delayed_pc = ctx->pc + 4 + B7_0s * 2;
1185         ctx->envflags |= DELAY_SLOT_CONDITIONAL;
1186         return;
1187     case 0x8900:                /* bt label */
1188         CHECK_NOT_DELAY_SLOT
1189         gen_conditional_jump(ctx, ctx->pc + 4 + B7_0s * 2, true);
1190         return;
1191     case 0x8d00:                /* bt/s label */
1192         CHECK_NOT_DELAY_SLOT
1193         tcg_gen_mov_i32(cpu_delayed_cond, cpu_sr_t);
1194         ctx->delayed_pc = ctx->pc + 4 + B7_0s * 2;
1195         ctx->envflags |= DELAY_SLOT_CONDITIONAL;
1196         return;
1197     case 0x8800:                /* cmp/eq #imm,R0 */
1198         tcg_gen_setcondi_i32(TCG_COND_EQ, cpu_sr_t, REG(0), B7_0s);
1199         return;
1200     case 0xc400:                /* mov.b @(disp,GBR),R0 */
1201         {
1202             TCGv addr = tcg_temp_new();
1203             tcg_gen_addi_i32(addr, cpu_gbr, B7_0);
1204             tcg_gen_qemu_ld_i32(REG(0), addr, ctx->memidx, MO_SB);
1205             tcg_temp_free(addr);
1206         }
1207         return;
1208     case 0xc500:                /* mov.w @(disp,GBR),R0 */
1209         {
1210             TCGv addr = tcg_temp_new();
1211             tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 2);
1212             tcg_gen_qemu_ld_i32(REG(0), addr, ctx->memidx, MO_TESW);
1213             tcg_temp_free(addr);
1214         }
1215         return;
1216     case 0xc600:                /* mov.l @(disp,GBR),R0 */
1217         {
1218             TCGv addr = tcg_temp_new();
1219             tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 4);
1220             tcg_gen_qemu_ld_i32(REG(0), addr, ctx->memidx, MO_TESL);
1221             tcg_temp_free(addr);
1222         }
1223         return;
1224     case 0xc000:                /* mov.b R0,@(disp,GBR) */
1225         {
1226             TCGv addr = tcg_temp_new();
1227             tcg_gen_addi_i32(addr, cpu_gbr, B7_0);
1228             tcg_gen_qemu_st_i32(REG(0), addr, ctx->memidx, MO_UB);
1229             tcg_temp_free(addr);
1230         }
1231         return;
1232     case 0xc100:                /* mov.w R0,@(disp,GBR) */
1233         {
1234             TCGv addr = tcg_temp_new();
1235             tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 2);
1236             tcg_gen_qemu_st_i32(REG(0), addr, ctx->memidx, MO_TEUW);
1237             tcg_temp_free(addr);
1238         }
1239         return;
1240     case 0xc200:                /* mov.l R0,@(disp,GBR) */
1241         {
1242             TCGv addr = tcg_temp_new();
1243             tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 4);
1244             tcg_gen_qemu_st_i32(REG(0), addr, ctx->memidx, MO_TEUL);
1245             tcg_temp_free(addr);
1246         }
1247         return;
1248     case 0x8000:                /* mov.b R0,@(disp,Rn) */
1249         {
1250             TCGv addr = tcg_temp_new();
1251             tcg_gen_addi_i32(addr, REG(B7_4), B3_0);
1252             tcg_gen_qemu_st_i32(REG(0), addr, ctx->memidx, MO_UB);
1253             tcg_temp_free(addr);
1254         }
1255         return;
1256     case 0x8100:                /* mov.w R0,@(disp,Rn) */
1257         {
1258             TCGv addr = tcg_temp_new();
1259             tcg_gen_addi_i32(addr, REG(B7_4), B3_0 * 2);
1260             tcg_gen_qemu_st_i32(REG(0), addr, ctx->memidx, MO_TEUW);
1261             tcg_temp_free(addr);
1262         }
1263         return;
1264     case 0x8400:                /* mov.b @(disp,Rn),R0 */
1265         {
1266             TCGv addr = tcg_temp_new();
1267             tcg_gen_addi_i32(addr, REG(B7_4), B3_0);
1268             tcg_gen_qemu_ld_i32(REG(0), addr, ctx->memidx, MO_SB);
1269             tcg_temp_free(addr);
1270         }
1271         return;
1272     case 0x8500:                /* mov.w @(disp,Rn),R0 */
1273         {
1274             TCGv addr = tcg_temp_new();
1275             tcg_gen_addi_i32(addr, REG(B7_4), B3_0 * 2);
1276             tcg_gen_qemu_ld_i32(REG(0), addr, ctx->memidx, MO_TESW);
1277             tcg_temp_free(addr);
1278         }
1279         return;
1280     case 0xc700:                /* mova @(disp,PC),R0 */
1281         tcg_gen_movi_i32(REG(0), ((ctx->pc & 0xfffffffc) + 4 + B7_0 * 4) & ~3);
1282         return;
1283     case 0xcb00:                /* or #imm,R0 */
1284         tcg_gen_ori_i32(REG(0), REG(0), B7_0);
1285         return;
1286     case 0xcf00:                /* or.b #imm,@(R0,GBR) */
1287         {
1288             TCGv addr, val;
1289             addr = tcg_temp_new();
1290             tcg_gen_add_i32(addr, REG(0), cpu_gbr);
1291             val = tcg_temp_new();
1292             tcg_gen_qemu_ld_i32(val, addr, ctx->memidx, MO_UB);
1293             tcg_gen_ori_i32(val, val, B7_0);
1294             tcg_gen_qemu_st_i32(val, addr, ctx->memidx, MO_UB);
1295             tcg_temp_free(val);
1296             tcg_temp_free(addr);
1297         }
1298         return;
1299     case 0xc300:                /* trapa #imm */
1300         {
1301             TCGv imm;
1302             CHECK_NOT_DELAY_SLOT
1303             gen_save_cpu_state(ctx, true);
1304             imm = tcg_const_i32(B7_0);
1305             gen_helper_trapa(cpu_env, imm);
1306             tcg_temp_free(imm);
1307             ctx->bstate = BS_EXCP;
1308         }
1309         return;
1310     case 0xc800:                /* tst #imm,R0 */
1311         {
1312             TCGv val = tcg_temp_new();
1313             tcg_gen_andi_i32(val, REG(0), B7_0);
1314             tcg_gen_setcondi_i32(TCG_COND_EQ, cpu_sr_t, val, 0);
1315             tcg_temp_free(val);
1316         }
1317         return;
1318     case 0xcc00:                /* tst.b #imm,@(R0,GBR) */
1319         {
1320             TCGv val = tcg_temp_new();
1321             tcg_gen_add_i32(val, REG(0), cpu_gbr);
1322             tcg_gen_qemu_ld_i32(val, val, ctx->memidx, MO_UB);
1323             tcg_gen_andi_i32(val, val, B7_0);
1324             tcg_gen_setcondi_i32(TCG_COND_EQ, cpu_sr_t, val, 0);
1325             tcg_temp_free(val);
1326         }
1327         return;
1328     case 0xca00:                /* xor #imm,R0 */
1329         tcg_gen_xori_i32(REG(0), REG(0), B7_0);
1330         return;
1331     case 0xce00:                /* xor.b #imm,@(R0,GBR) */
1332         {
1333             TCGv addr, val;
1334             addr = tcg_temp_new();
1335             tcg_gen_add_i32(addr, REG(0), cpu_gbr);
1336             val = tcg_temp_new();
1337             tcg_gen_qemu_ld_i32(val, addr, ctx->memidx, MO_UB);
1338             tcg_gen_xori_i32(val, val, B7_0);
1339             tcg_gen_qemu_st_i32(val, addr, ctx->memidx, MO_UB);
1340             tcg_temp_free(val);
1341             tcg_temp_free(addr);
1342         }
1343         return;
1344     }
1345
1346     switch (ctx->opcode & 0xf08f) {
1347     case 0x408e:                /* ldc Rm,Rn_BANK */
1348         CHECK_PRIVILEGED
1349         tcg_gen_mov_i32(ALTREG(B6_4), REG(B11_8));
1350         return;
1351     case 0x4087:                /* ldc.l @Rm+,Rn_BANK */
1352         CHECK_PRIVILEGED
1353         tcg_gen_qemu_ld_i32(ALTREG(B6_4), REG(B11_8), ctx->memidx, MO_TESL);
1354         tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
1355         return;
1356     case 0x0082:                /* stc Rm_BANK,Rn */
1357         CHECK_PRIVILEGED
1358         tcg_gen_mov_i32(REG(B11_8), ALTREG(B6_4));
1359         return;
1360     case 0x4083:                /* stc.l Rm_BANK,@-Rn */
1361         CHECK_PRIVILEGED
1362         {
1363             TCGv addr = tcg_temp_new();
1364             tcg_gen_subi_i32(addr, REG(B11_8), 4);
1365             tcg_gen_qemu_st_i32(ALTREG(B6_4), addr, ctx->memidx, MO_TEUL);
1366             tcg_gen_mov_i32(REG(B11_8), addr);
1367             tcg_temp_free(addr);
1368         }
1369         return;
1370     }
1371
1372     switch (ctx->opcode & 0xf0ff) {
1373     case 0x0023:                /* braf Rn */
1374         CHECK_NOT_DELAY_SLOT
1375         tcg_gen_addi_i32(cpu_delayed_pc, REG(B11_8), ctx->pc + 4);
1376         ctx->envflags |= DELAY_SLOT;
1377         ctx->delayed_pc = (uint32_t) - 1;
1378         return;
1379     case 0x0003:                /* bsrf Rn */
1380         CHECK_NOT_DELAY_SLOT
1381         tcg_gen_movi_i32(cpu_pr, ctx->pc + 4);
1382         tcg_gen_add_i32(cpu_delayed_pc, REG(B11_8), cpu_pr);
1383         ctx->envflags |= DELAY_SLOT;
1384         ctx->delayed_pc = (uint32_t) - 1;
1385         return;
1386     case 0x4015:                /* cmp/pl Rn */
1387         tcg_gen_setcondi_i32(TCG_COND_GT, cpu_sr_t, REG(B11_8), 0);
1388         return;
1389     case 0x4011:                /* cmp/pz Rn */
1390         tcg_gen_setcondi_i32(TCG_COND_GE, cpu_sr_t, REG(B11_8), 0);
1391         return;
1392     case 0x4010:                /* dt Rn */
1393         tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 1);
1394         tcg_gen_setcondi_i32(TCG_COND_EQ, cpu_sr_t, REG(B11_8), 0);
1395         return;
1396     case 0x402b:                /* jmp @Rn */
1397         CHECK_NOT_DELAY_SLOT
1398         tcg_gen_mov_i32(cpu_delayed_pc, REG(B11_8));
1399         ctx->envflags |= DELAY_SLOT;
1400         ctx->delayed_pc = (uint32_t) - 1;
1401         return;
1402     case 0x400b:                /* jsr @Rn */
1403         CHECK_NOT_DELAY_SLOT
1404         tcg_gen_movi_i32(cpu_pr, ctx->pc + 4);
1405         tcg_gen_mov_i32(cpu_delayed_pc, REG(B11_8));
1406         ctx->envflags |= DELAY_SLOT;
1407         ctx->delayed_pc = (uint32_t) - 1;
1408         return;
1409     case 0x400e:                /* ldc Rm,SR */
1410         CHECK_PRIVILEGED
1411         {
1412             TCGv val = tcg_temp_new();
1413             tcg_gen_andi_i32(val, REG(B11_8), 0x700083f3);
1414             gen_write_sr(val);
1415             tcg_temp_free(val);
1416             ctx->bstate = BS_STOP;
1417         }
1418         return;
1419     case 0x4007:                /* ldc.l @Rm+,SR */
1420         CHECK_PRIVILEGED
1421         {
1422             TCGv val = tcg_temp_new();
1423             tcg_gen_qemu_ld_i32(val, REG(B11_8), ctx->memidx, MO_TESL);
1424             tcg_gen_andi_i32(val, val, 0x700083f3);
1425             gen_write_sr(val);
1426             tcg_temp_free(val);
1427             tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
1428             ctx->bstate = BS_STOP;
1429         }
1430         return;
1431     case 0x0002:                /* stc SR,Rn */
1432         CHECK_PRIVILEGED
1433         gen_read_sr(REG(B11_8));
1434         return;
1435     case 0x4003:                /* stc SR,@-Rn */
1436         CHECK_PRIVILEGED
1437         {
1438             TCGv addr = tcg_temp_new();
1439             TCGv val = tcg_temp_new();
1440             tcg_gen_subi_i32(addr, REG(B11_8), 4);
1441             gen_read_sr(val);
1442             tcg_gen_qemu_st_i32(val, addr, ctx->memidx, MO_TEUL);
1443             tcg_gen_mov_i32(REG(B11_8), addr);
1444             tcg_temp_free(val);
1445             tcg_temp_free(addr);
1446         }
1447         return;
1448 #define LD(reg,ldnum,ldpnum,prechk)             \
1449   case ldnum:                                                   \
1450     prechk                                                      \
1451     tcg_gen_mov_i32 (cpu_##reg, REG(B11_8));                    \
1452     return;                                                     \
1453   case ldpnum:                                                  \
1454     prechk                                                      \
1455     tcg_gen_qemu_ld_i32(cpu_##reg, REG(B11_8), ctx->memidx, MO_TESL); \
1456     tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);                \
1457     return;
1458 #define ST(reg,stnum,stpnum,prechk)             \
1459   case stnum:                                                   \
1460     prechk                                                      \
1461     tcg_gen_mov_i32 (REG(B11_8), cpu_##reg);                    \
1462     return;                                                     \
1463   case stpnum:                                                  \
1464     prechk                                                      \
1465     {                                                           \
1466         TCGv addr = tcg_temp_new();                             \
1467         tcg_gen_subi_i32(addr, REG(B11_8), 4);                  \
1468         tcg_gen_qemu_st_i32(cpu_##reg, addr, ctx->memidx, MO_TEUL); \
1469         tcg_gen_mov_i32(REG(B11_8), addr);                      \
1470         tcg_temp_free(addr);                                    \
1471     }                                                           \
1472     return;
1473 #define LDST(reg,ldnum,ldpnum,stnum,stpnum,prechk)              \
1474         LD(reg,ldnum,ldpnum,prechk)                             \
1475         ST(reg,stnum,stpnum,prechk)
1476         LDST(gbr,  0x401e, 0x4017, 0x0012, 0x4013, {})
1477         LDST(vbr,  0x402e, 0x4027, 0x0022, 0x4023, CHECK_PRIVILEGED)
1478         LDST(ssr,  0x403e, 0x4037, 0x0032, 0x4033, CHECK_PRIVILEGED)
1479         LDST(spc,  0x404e, 0x4047, 0x0042, 0x4043, CHECK_PRIVILEGED)
1480         ST(sgr,  0x003a, 0x4032, CHECK_PRIVILEGED)
1481         LD(sgr,  0x403a, 0x4036, CHECK_PRIVILEGED CHECK_SH4A)
1482         LDST(dbr,  0x40fa, 0x40f6, 0x00fa, 0x40f2, CHECK_PRIVILEGED)
1483         LDST(mach, 0x400a, 0x4006, 0x000a, 0x4002, {})
1484         LDST(macl, 0x401a, 0x4016, 0x001a, 0x4012, {})
1485         LDST(pr,   0x402a, 0x4026, 0x002a, 0x4022, {})
1486         LDST(fpul, 0x405a, 0x4056, 0x005a, 0x4052, {CHECK_FPU_ENABLED})
1487     case 0x406a:                /* lds Rm,FPSCR */
1488         CHECK_FPU_ENABLED
1489         gen_helper_ld_fpscr(cpu_env, REG(B11_8));
1490         ctx->bstate = BS_STOP;
1491         return;
1492     case 0x4066:                /* lds.l @Rm+,FPSCR */
1493         CHECK_FPU_ENABLED
1494         {
1495             TCGv addr = tcg_temp_new();
1496             tcg_gen_qemu_ld_i32(addr, REG(B11_8), ctx->memidx, MO_TESL);
1497             tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
1498             gen_helper_ld_fpscr(cpu_env, addr);
1499             tcg_temp_free(addr);
1500             ctx->bstate = BS_STOP;
1501         }
1502         return;
1503     case 0x006a:                /* sts FPSCR,Rn */
1504         CHECK_FPU_ENABLED
1505         tcg_gen_andi_i32(REG(B11_8), cpu_fpscr, 0x003fffff);
1506         return;
1507     case 0x4062:                /* sts FPSCR,@-Rn */
1508         CHECK_FPU_ENABLED
1509         {
1510             TCGv addr, val;
1511             val = tcg_temp_new();
1512             tcg_gen_andi_i32(val, cpu_fpscr, 0x003fffff);
1513             addr = tcg_temp_new();
1514             tcg_gen_subi_i32(addr, REG(B11_8), 4);
1515             tcg_gen_qemu_st_i32(val, addr, ctx->memidx, MO_TEUL);
1516             tcg_gen_mov_i32(REG(B11_8), addr);
1517             tcg_temp_free(addr);
1518             tcg_temp_free(val);
1519         }
1520         return;
1521     case 0x00c3:                /* movca.l R0,@Rm */
1522         {
1523             TCGv val = tcg_temp_new();
1524             tcg_gen_qemu_ld_i32(val, REG(B11_8), ctx->memidx, MO_TEUL);
1525             gen_helper_movcal(cpu_env, REG(B11_8), val);
1526             tcg_gen_qemu_st_i32(REG(0), REG(B11_8), ctx->memidx, MO_TEUL);
1527         }
1528         ctx->has_movcal = 1;
1529         return;
1530     case 0x40a9:                /* movua.l @Rm,R0 */
1531         CHECK_SH4A
1532         /* Load non-boundary-aligned data */
1533         tcg_gen_qemu_ld_i32(REG(0), REG(B11_8), ctx->memidx,
1534                             MO_TEUL | MO_UNALN);
1535         return;
1536         break;
1537     case 0x40e9:                /* movua.l @Rm+,R0 */
1538         CHECK_SH4A
1539         /* Load non-boundary-aligned data */
1540         tcg_gen_qemu_ld_i32(REG(0), REG(B11_8), ctx->memidx,
1541                             MO_TEUL | MO_UNALN);
1542         tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
1543         return;
1544         break;
1545     case 0x0029:                /* movt Rn */
1546         tcg_gen_mov_i32(REG(B11_8), cpu_sr_t);
1547         return;
1548     case 0x0073:
1549         /* MOVCO.L
1550                LDST -> T
1551                If (T == 1) R0 -> (Rn)
1552                0 -> LDST
1553         */
1554         CHECK_SH4A
1555         {
1556             TCGLabel *label = gen_new_label();
1557             tcg_gen_mov_i32(cpu_sr_t, cpu_ldst);
1558             tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_ldst, 0, label);
1559             tcg_gen_qemu_st_i32(REG(0), REG(B11_8), ctx->memidx, MO_TEUL);
1560             gen_set_label(label);
1561             tcg_gen_movi_i32(cpu_ldst, 0);
1562             return;
1563         }
1564     case 0x0063:
1565         /* MOVLI.L @Rm,R0
1566                1 -> LDST
1567                (Rm) -> R0
1568                When interrupt/exception
1569                occurred 0 -> LDST
1570         */
1571         CHECK_SH4A
1572         tcg_gen_movi_i32(cpu_ldst, 0);
1573         tcg_gen_qemu_ld_i32(REG(0), REG(B11_8), ctx->memidx, MO_TESL);
1574         tcg_gen_movi_i32(cpu_ldst, 1);
1575         return;
1576     case 0x0093:                /* ocbi @Rn */
1577         {
1578             gen_helper_ocbi(cpu_env, REG(B11_8));
1579         }
1580         return;
1581     case 0x00a3:                /* ocbp @Rn */
1582     case 0x00b3:                /* ocbwb @Rn */
1583         /* These instructions are supposed to do nothing in case of
1584            a cache miss. Given that we only partially emulate caches
1585            it is safe to simply ignore them. */
1586         return;
1587     case 0x0083:                /* pref @Rn */
1588         return;
1589     case 0x00d3:                /* prefi @Rn */
1590         CHECK_SH4A
1591         return;
1592     case 0x00e3:                /* icbi @Rn */
1593         CHECK_SH4A
1594         return;
1595     case 0x00ab:                /* synco */
1596         CHECK_SH4A
1597         tcg_gen_mb(TCG_MO_ALL | TCG_BAR_SC);
1598         return;
1599         break;
1600     case 0x4024:                /* rotcl Rn */
1601         {
1602             TCGv tmp = tcg_temp_new();
1603             tcg_gen_mov_i32(tmp, cpu_sr_t);
1604             tcg_gen_shri_i32(cpu_sr_t, REG(B11_8), 31);
1605             tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 1);
1606             tcg_gen_or_i32(REG(B11_8), REG(B11_8), tmp);
1607             tcg_temp_free(tmp);
1608         }
1609         return;
1610     case 0x4025:                /* rotcr Rn */
1611         {
1612             TCGv tmp = tcg_temp_new();
1613             tcg_gen_shli_i32(tmp, cpu_sr_t, 31);
1614             tcg_gen_andi_i32(cpu_sr_t, REG(B11_8), 1);
1615             tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 1);
1616             tcg_gen_or_i32(REG(B11_8), REG(B11_8), tmp);
1617             tcg_temp_free(tmp);
1618         }
1619         return;
1620     case 0x4004:                /* rotl Rn */
1621         tcg_gen_rotli_i32(REG(B11_8), REG(B11_8), 1);
1622         tcg_gen_andi_i32(cpu_sr_t, REG(B11_8), 0);
1623         return;
1624     case 0x4005:                /* rotr Rn */
1625         tcg_gen_andi_i32(cpu_sr_t, REG(B11_8), 0);
1626         tcg_gen_rotri_i32(REG(B11_8), REG(B11_8), 1);
1627         return;
1628     case 0x4000:                /* shll Rn */
1629     case 0x4020:                /* shal Rn */
1630         tcg_gen_shri_i32(cpu_sr_t, REG(B11_8), 31);
1631         tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 1);
1632         return;
1633     case 0x4021:                /* shar Rn */
1634         tcg_gen_andi_i32(cpu_sr_t, REG(B11_8), 1);
1635         tcg_gen_sari_i32(REG(B11_8), REG(B11_8), 1);
1636         return;
1637     case 0x4001:                /* shlr Rn */
1638         tcg_gen_andi_i32(cpu_sr_t, REG(B11_8), 1);
1639         tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 1);
1640         return;
1641     case 0x4008:                /* shll2 Rn */
1642         tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 2);
1643         return;
1644     case 0x4018:                /* shll8 Rn */
1645         tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 8);
1646         return;
1647     case 0x4028:                /* shll16 Rn */
1648         tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 16);
1649         return;
1650     case 0x4009:                /* shlr2 Rn */
1651         tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 2);
1652         return;
1653     case 0x4019:                /* shlr8 Rn */
1654         tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 8);
1655         return;
1656     case 0x4029:                /* shlr16 Rn */
1657         tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 16);
1658         return;
1659     case 0x401b:                /* tas.b @Rn */
1660         {
1661             TCGv val = tcg_const_i32(0x80);
1662             tcg_gen_atomic_fetch_or_i32(val, REG(B11_8), val,
1663                                         ctx->memidx, MO_UB);
1664             tcg_gen_setcondi_i32(TCG_COND_EQ, cpu_sr_t, val, 0);
1665             tcg_temp_free(val);
1666         }
1667         return;
1668     case 0xf00d: /* fsts FPUL,FRn - FPSCR: Nothing */
1669         CHECK_FPU_ENABLED
1670         tcg_gen_mov_i32(FREG(B11_8), cpu_fpul);
1671         return;
1672     case 0xf01d: /* flds FRm,FPUL - FPSCR: Nothing */
1673         CHECK_FPU_ENABLED
1674         tcg_gen_mov_i32(cpu_fpul, FREG(B11_8));
1675         return;
1676     case 0xf02d: /* float FPUL,FRn/DRn - FPSCR: R[PR,Enable.I]/W[Cause,Flag] */
1677         CHECK_FPU_ENABLED
1678         if (ctx->tbflags & FPSCR_PR) {
1679             TCGv_i64 fp;
1680             if (ctx->opcode & 0x0100) {
1681                 goto do_illegal;
1682             }
1683             fp = tcg_temp_new_i64();
1684             gen_helper_float_DT(fp, cpu_env, cpu_fpul);
1685             gen_store_fpr64(ctx, fp, B11_8);
1686             tcg_temp_free_i64(fp);
1687         }
1688         else {
1689             gen_helper_float_FT(FREG(B11_8), cpu_env, cpu_fpul);
1690         }
1691         return;
1692     case 0xf03d: /* ftrc FRm/DRm,FPUL - FPSCR: R[PR,Enable.V]/W[Cause,Flag] */
1693         CHECK_FPU_ENABLED
1694         if (ctx->tbflags & FPSCR_PR) {
1695             TCGv_i64 fp;
1696             if (ctx->opcode & 0x0100) {
1697                 goto do_illegal;
1698             }
1699             fp = tcg_temp_new_i64();
1700             gen_load_fpr64(ctx, fp, B11_8);
1701             gen_helper_ftrc_DT(cpu_fpul, cpu_env, fp);
1702             tcg_temp_free_i64(fp);
1703         }
1704         else {
1705             gen_helper_ftrc_FT(cpu_fpul, cpu_env, FREG(B11_8));
1706         }
1707         return;
1708     case 0xf04d: /* fneg FRn/DRn - FPSCR: Nothing */
1709         CHECK_FPU_ENABLED
1710         tcg_gen_xori_i32(FREG(B11_8), FREG(B11_8), 0x80000000);
1711         return;
1712     case 0xf05d: /* fabs FRn/DRn - FPCSR: Nothing */
1713         CHECK_FPU_ENABLED
1714         tcg_gen_andi_i32(FREG(B11_8), FREG(B11_8), 0x7fffffff);
1715         return;
1716     case 0xf06d: /* fsqrt FRn */
1717         CHECK_FPU_ENABLED
1718         if (ctx->tbflags & FPSCR_PR) {
1719             if (ctx->opcode & 0x0100) {
1720                 goto do_illegal;
1721             }
1722             TCGv_i64 fp = tcg_temp_new_i64();
1723             gen_load_fpr64(ctx, fp, B11_8);
1724             gen_helper_fsqrt_DT(fp, cpu_env, fp);
1725             gen_store_fpr64(ctx, fp, B11_8);
1726             tcg_temp_free_i64(fp);
1727         } else {
1728             gen_helper_fsqrt_FT(FREG(B11_8), cpu_env, FREG(B11_8));
1729         }
1730         return;
1731     case 0xf07d: /* fsrra FRn */
1732         CHECK_FPU_ENABLED
1733         CHECK_FPSCR_PR_0
1734         gen_helper_fsrra_FT(FREG(B11_8), cpu_env, FREG(B11_8));
1735         break;
1736     case 0xf08d: /* fldi0 FRn - FPSCR: R[PR] */
1737         CHECK_FPU_ENABLED
1738         CHECK_FPSCR_PR_0
1739         tcg_gen_movi_i32(FREG(B11_8), 0);
1740         return;
1741     case 0xf09d: /* fldi1 FRn - FPSCR: R[PR] */
1742         CHECK_FPU_ENABLED
1743         CHECK_FPSCR_PR_0
1744         tcg_gen_movi_i32(FREG(B11_8), 0x3f800000);
1745         return;
1746     case 0xf0ad: /* fcnvsd FPUL,DRn */
1747         CHECK_FPU_ENABLED
1748         {
1749             TCGv_i64 fp = tcg_temp_new_i64();
1750             gen_helper_fcnvsd_FT_DT(fp, cpu_env, cpu_fpul);
1751             gen_store_fpr64(ctx, fp, B11_8);
1752             tcg_temp_free_i64(fp);
1753         }
1754         return;
1755     case 0xf0bd: /* fcnvds DRn,FPUL */
1756         CHECK_FPU_ENABLED
1757         {
1758             TCGv_i64 fp = tcg_temp_new_i64();
1759             gen_load_fpr64(ctx, fp, B11_8);
1760             gen_helper_fcnvds_DT_FT(cpu_fpul, cpu_env, fp);
1761             tcg_temp_free_i64(fp);
1762         }
1763         return;
1764     case 0xf0ed: /* fipr FVm,FVn */
1765         CHECK_FPU_ENABLED
1766         CHECK_FPSCR_PR_1
1767         {
1768             TCGv m = tcg_const_i32((ctx->opcode >> 8) & 3);
1769             TCGv n = tcg_const_i32((ctx->opcode >> 10) & 3);
1770             gen_helper_fipr(cpu_env, m, n);
1771             tcg_temp_free(m);
1772             tcg_temp_free(n);
1773             return;
1774         }
1775         break;
1776     case 0xf0fd: /* ftrv XMTRX,FVn */
1777         CHECK_FPU_ENABLED
1778         CHECK_FPSCR_PR_1
1779         {
1780             if ((ctx->opcode & 0x0300) != 0x0100) {
1781                 goto do_illegal;
1782             }
1783             TCGv n = tcg_const_i32((ctx->opcode >> 10) & 3);
1784             gen_helper_ftrv(cpu_env, n);
1785             tcg_temp_free(n);
1786             return;
1787         }
1788         break;
1789     }
1790 #if 0
1791     fprintf(stderr, "unknown instruction 0x%04x at pc 0x%08x\n",
1792             ctx->opcode, ctx->pc);
1793     fflush(stderr);
1794 #endif
1795  do_illegal:
1796     if (ctx->envflags & DELAY_SLOT_MASK) {
1797  do_illegal_slot:
1798         gen_save_cpu_state(ctx, true);
1799         gen_helper_raise_slot_illegal_instruction(cpu_env);
1800     } else {
1801         gen_save_cpu_state(ctx, true);
1802         gen_helper_raise_illegal_instruction(cpu_env);
1803     }
1804     ctx->bstate = BS_EXCP;
1805     return;
1806
1807  do_fpu_disabled:
1808     gen_save_cpu_state(ctx, true);
1809     if (ctx->envflags & DELAY_SLOT_MASK) {
1810         gen_helper_raise_slot_fpu_disable(cpu_env);
1811     } else {
1812         gen_helper_raise_fpu_disable(cpu_env);
1813     }
1814     ctx->bstate = BS_EXCP;
1815     return;
1816 }
1817
1818 static void decode_opc(DisasContext * ctx)
1819 {
1820     uint32_t old_flags = ctx->envflags;
1821
1822     _decode_opc(ctx);
1823
1824     if (old_flags & DELAY_SLOT_MASK) {
1825         /* go out of the delay slot */
1826         ctx->envflags &= ~DELAY_SLOT_MASK;
1827
1828         /* When in an exclusive region, we must continue to the end
1829            for conditional branches.  */
1830         if (ctx->tbflags & GUSA_EXCLUSIVE
1831             && old_flags & DELAY_SLOT_CONDITIONAL) {
1832             gen_delayed_conditional_jump(ctx);
1833             return;
1834         }
1835         /* Otherwise this is probably an invalid gUSA region.
1836            Drop the GUSA bits so the next TB doesn't see them.  */
1837         ctx->envflags &= ~GUSA_MASK;
1838
1839         tcg_gen_movi_i32(cpu_flags, ctx->envflags);
1840         ctx->bstate = BS_BRANCH;
1841         if (old_flags & DELAY_SLOT_CONDITIONAL) {
1842             gen_delayed_conditional_jump(ctx);
1843         } else {
1844             gen_jump(ctx);
1845         }
1846     }
1847 }
1848
1849 #ifdef CONFIG_USER_ONLY
1850 /* For uniprocessors, SH4 uses optimistic restartable atomic sequences.
1851    Upon an interrupt, a real kernel would simply notice magic values in
1852    the registers and reset the PC to the start of the sequence.
1853
1854    For QEMU, we cannot do this in quite the same way.  Instead, we notice
1855    the normal start of such a sequence (mov #-x,r15).  While we can handle
1856    any sequence via cpu_exec_step_atomic, we can recognize the "normal"
1857    sequences and transform them into atomic operations as seen by the host.
1858 */
1859 static int decode_gusa(DisasContext *ctx, CPUSH4State *env, int *pmax_insns)
1860 {
1861     uint16_t insns[5];
1862     int ld_adr, ld_dst, ld_mop;
1863     int op_dst, op_src, op_opc;
1864     int mv_src, mt_dst, st_src, st_mop;
1865     TCGv op_arg;
1866
1867     uint32_t pc = ctx->pc;
1868     uint32_t pc_end = ctx->tb->cs_base;
1869     int backup = sextract32(ctx->tbflags, GUSA_SHIFT, 8);
1870     int max_insns = (pc_end - pc) / 2;
1871     int i;
1872
1873     if (pc != pc_end + backup || max_insns < 2) {
1874         /* This is a malformed gUSA region.  Don't do anything special,
1875            since the interpreter is likely to get confused.  */
1876         ctx->envflags &= ~GUSA_MASK;
1877         return 0;
1878     }
1879
1880     if (ctx->tbflags & GUSA_EXCLUSIVE) {
1881         /* Regardless of single-stepping or the end of the page,
1882            we must complete execution of the gUSA region while
1883            holding the exclusive lock.  */
1884         *pmax_insns = max_insns;
1885         return 0;
1886     }
1887
1888     /* The state machine below will consume only a few insns.
1889        If there are more than that in a region, fail now.  */
1890     if (max_insns > ARRAY_SIZE(insns)) {
1891         goto fail;
1892     }
1893
1894     /* Read all of the insns for the region.  */
1895     for (i = 0; i < max_insns; ++i) {
1896         insns[i] = cpu_lduw_code(env, pc + i * 2);
1897     }
1898
1899     ld_adr = ld_dst = ld_mop = -1;
1900     mv_src = -1;
1901     op_dst = op_src = op_opc = -1;
1902     mt_dst = -1;
1903     st_src = st_mop = -1;
1904     TCGV_UNUSED(op_arg);
1905     i = 0;
1906
1907 #define NEXT_INSN \
1908     do { if (i >= max_insns) goto fail; ctx->opcode = insns[i++]; } while (0)
1909
1910     /*
1911      * Expect a load to begin the region.
1912      */
1913     NEXT_INSN;
1914     switch (ctx->opcode & 0xf00f) {
1915     case 0x6000: /* mov.b @Rm,Rn */
1916         ld_mop = MO_SB;
1917         break;
1918     case 0x6001: /* mov.w @Rm,Rn */
1919         ld_mop = MO_TESW;
1920         break;
1921     case 0x6002: /* mov.l @Rm,Rn */
1922         ld_mop = MO_TESL;
1923         break;
1924     default:
1925         goto fail;
1926     }
1927     ld_adr = B7_4;
1928     ld_dst = B11_8;
1929     if (ld_adr == ld_dst) {
1930         goto fail;
1931     }
1932     /* Unless we see a mov, any two-operand operation must use ld_dst.  */
1933     op_dst = ld_dst;
1934
1935     /*
1936      * Expect an optional register move.
1937      */
1938     NEXT_INSN;
1939     switch (ctx->opcode & 0xf00f) {
1940     case 0x6003: /* mov Rm,Rn */
1941         /* Here we want to recognize ld_dst being saved for later consumtion,
1942            or for another input register being copied so that ld_dst need not
1943            be clobbered during the operation.  */
1944         op_dst = B11_8;
1945         mv_src = B7_4;
1946         if (op_dst == ld_dst) {
1947             /* Overwriting the load output.  */
1948             goto fail;
1949         }
1950         if (mv_src != ld_dst) {
1951             /* Copying a new input; constrain op_src to match the load.  */
1952             op_src = ld_dst;
1953         }
1954         break;
1955
1956     default:
1957         /* Put back and re-examine as operation.  */
1958         --i;
1959     }
1960
1961     /*
1962      * Expect the operation.
1963      */
1964     NEXT_INSN;
1965     switch (ctx->opcode & 0xf00f) {
1966     case 0x300c: /* add Rm,Rn */
1967         op_opc = INDEX_op_add_i32;
1968         goto do_reg_op;
1969     case 0x2009: /* and Rm,Rn */
1970         op_opc = INDEX_op_and_i32;
1971         goto do_reg_op;
1972     case 0x200a: /* xor Rm,Rn */
1973         op_opc = INDEX_op_xor_i32;
1974         goto do_reg_op;
1975     case 0x200b: /* or Rm,Rn */
1976         op_opc = INDEX_op_or_i32;
1977     do_reg_op:
1978         /* The operation register should be as expected, and the
1979            other input cannot depend on the load.  */
1980         if (op_dst != B11_8) {
1981             goto fail;
1982         }
1983         if (op_src < 0) {
1984             /* Unconstrainted input.  */
1985             op_src = B7_4;
1986         } else if (op_src == B7_4) {
1987             /* Constrained input matched load.  All operations are
1988                commutative; "swap" them by "moving" the load output
1989                to the (implicit) first argument and the move source
1990                to the (explicit) second argument.  */
1991             op_src = mv_src;
1992         } else {
1993             goto fail;
1994         }
1995         op_arg = REG(op_src);
1996         break;
1997
1998     case 0x6007: /* not Rm,Rn */
1999         if (ld_dst != B7_4 || mv_src >= 0) {
2000             goto fail;
2001         }
2002         op_dst = B11_8;
2003         op_opc = INDEX_op_xor_i32;
2004         op_arg = tcg_const_i32(-1);
2005         break;
2006
2007     case 0x7000 ... 0x700f: /* add #imm,Rn */
2008         if (op_dst != B11_8 || mv_src >= 0) {
2009             goto fail;
2010         }
2011         op_opc = INDEX_op_add_i32;
2012         op_arg = tcg_const_i32(B7_0s);
2013         break;
2014
2015     case 0x3000: /* cmp/eq Rm,Rn */
2016         /* Looking for the middle of a compare-and-swap sequence,
2017            beginning with the compare.  Operands can be either order,
2018            but with only one overlapping the load.  */
2019         if ((ld_dst == B11_8) + (ld_dst == B7_4) != 1 || mv_src >= 0) {
2020             goto fail;
2021         }
2022         op_opc = INDEX_op_setcond_i32;  /* placeholder */
2023         op_src = (ld_dst == B11_8 ? B7_4 : B11_8);
2024         op_arg = REG(op_src);
2025
2026         NEXT_INSN;
2027         switch (ctx->opcode & 0xff00) {
2028         case 0x8b00: /* bf label */
2029         case 0x8f00: /* bf/s label */
2030             if (pc + (i + 1 + B7_0s) * 2 != pc_end) {
2031                 goto fail;
2032             }
2033             if ((ctx->opcode & 0xff00) == 0x8b00) { /* bf label */
2034                 break;
2035             }
2036             /* We're looking to unconditionally modify Rn with the
2037                result of the comparison, within the delay slot of
2038                the branch.  This is used by older gcc.  */
2039             NEXT_INSN;
2040             if ((ctx->opcode & 0xf0ff) == 0x0029) { /* movt Rn */
2041                 mt_dst = B11_8;
2042             } else {
2043                 goto fail;
2044             }
2045             break;
2046
2047         default:
2048             goto fail;
2049         }
2050         break;
2051
2052     case 0x2008: /* tst Rm,Rn */
2053         /* Looking for a compare-and-swap against zero.  */
2054         if (ld_dst != B11_8 || ld_dst != B7_4 || mv_src >= 0) {
2055             goto fail;
2056         }
2057         op_opc = INDEX_op_setcond_i32;
2058         op_arg = tcg_const_i32(0);
2059
2060         NEXT_INSN;
2061         if ((ctx->opcode & 0xff00) != 0x8900 /* bt label */
2062             || pc + (i + 1 + B7_0s) * 2 != pc_end) {
2063             goto fail;
2064         }
2065         break;
2066
2067     default:
2068         /* Put back and re-examine as store.  */
2069         --i;
2070     }
2071
2072     /*
2073      * Expect the store.
2074      */
2075     /* The store must be the last insn.  */
2076     if (i != max_insns - 1) {
2077         goto fail;
2078     }
2079     NEXT_INSN;
2080     switch (ctx->opcode & 0xf00f) {
2081     case 0x2000: /* mov.b Rm,@Rn */
2082         st_mop = MO_UB;
2083         break;
2084     case 0x2001: /* mov.w Rm,@Rn */
2085         st_mop = MO_UW;
2086         break;
2087     case 0x2002: /* mov.l Rm,@Rn */
2088         st_mop = MO_UL;
2089         break;
2090     default:
2091         goto fail;
2092     }
2093     /* The store must match the load.  */
2094     if (ld_adr != B11_8 || st_mop != (ld_mop & MO_SIZE)) {
2095         goto fail;
2096     }
2097     st_src = B7_4;
2098
2099 #undef NEXT_INSN
2100
2101     /*
2102      * Emit the operation.
2103      */
2104     tcg_gen_insn_start(pc, ctx->envflags);
2105     switch (op_opc) {
2106     case -1:
2107         /* No operation found.  Look for exchange pattern.  */
2108         if (st_src == ld_dst || mv_src >= 0) {
2109             goto fail;
2110         }
2111         tcg_gen_atomic_xchg_i32(REG(ld_dst), REG(ld_adr), REG(st_src),
2112                                 ctx->memidx, ld_mop);
2113         break;
2114
2115     case INDEX_op_add_i32:
2116         if (op_dst != st_src) {
2117             goto fail;
2118         }
2119         if (op_dst == ld_dst && st_mop == MO_UL) {
2120             tcg_gen_atomic_add_fetch_i32(REG(ld_dst), REG(ld_adr),
2121                                          op_arg, ctx->memidx, ld_mop);
2122         } else {
2123             tcg_gen_atomic_fetch_add_i32(REG(ld_dst), REG(ld_adr),
2124                                          op_arg, ctx->memidx, ld_mop);
2125             if (op_dst != ld_dst) {
2126                 /* Note that mop sizes < 4 cannot use add_fetch
2127                    because it won't carry into the higher bits.  */
2128                 tcg_gen_add_i32(REG(op_dst), REG(ld_dst), op_arg);
2129             }
2130         }
2131         break;
2132
2133     case INDEX_op_and_i32:
2134         if (op_dst != st_src) {
2135             goto fail;
2136         }
2137         if (op_dst == ld_dst) {
2138             tcg_gen_atomic_and_fetch_i32(REG(ld_dst), REG(ld_adr),
2139                                          op_arg, ctx->memidx, ld_mop);
2140         } else {
2141             tcg_gen_atomic_fetch_and_i32(REG(ld_dst), REG(ld_adr),
2142                                          op_arg, ctx->memidx, ld_mop);
2143             tcg_gen_and_i32(REG(op_dst), REG(ld_dst), op_arg);
2144         }
2145         break;
2146
2147     case INDEX_op_or_i32:
2148         if (op_dst != st_src) {
2149             goto fail;
2150         }
2151         if (op_dst == ld_dst) {
2152             tcg_gen_atomic_or_fetch_i32(REG(ld_dst), REG(ld_adr),
2153                                         op_arg, ctx->memidx, ld_mop);
2154         } else {
2155             tcg_gen_atomic_fetch_or_i32(REG(ld_dst), REG(ld_adr),
2156                                         op_arg, ctx->memidx, ld_mop);
2157             tcg_gen_or_i32(REG(op_dst), REG(ld_dst), op_arg);
2158         }
2159         break;
2160
2161     case INDEX_op_xor_i32:
2162         if (op_dst != st_src) {
2163             goto fail;
2164         }
2165         if (op_dst == ld_dst) {
2166             tcg_gen_atomic_xor_fetch_i32(REG(ld_dst), REG(ld_adr),
2167                                          op_arg, ctx->memidx, ld_mop);
2168         } else {
2169             tcg_gen_atomic_fetch_xor_i32(REG(ld_dst), REG(ld_adr),
2170                                          op_arg, ctx->memidx, ld_mop);
2171             tcg_gen_xor_i32(REG(op_dst), REG(ld_dst), op_arg);
2172         }
2173         break;
2174
2175     case INDEX_op_setcond_i32:
2176         if (st_src == ld_dst) {
2177             goto fail;
2178         }
2179         tcg_gen_atomic_cmpxchg_i32(REG(ld_dst), REG(ld_adr), op_arg,
2180                                    REG(st_src), ctx->memidx, ld_mop);
2181         tcg_gen_setcond_i32(TCG_COND_EQ, cpu_sr_t, REG(ld_dst), op_arg);
2182         if (mt_dst >= 0) {
2183             tcg_gen_mov_i32(REG(mt_dst), cpu_sr_t);
2184         }
2185         break;
2186
2187     default:
2188         g_assert_not_reached();
2189     }
2190
2191     /* If op_src is not a valid register, then op_arg was a constant.  */
2192     if (op_src < 0) {
2193         tcg_temp_free_i32(op_arg);
2194     }
2195
2196     /* The entire region has been translated.  */
2197     ctx->envflags &= ~GUSA_MASK;
2198     ctx->pc = pc_end;
2199     return max_insns;
2200
2201  fail:
2202     qemu_log_mask(LOG_UNIMP, "Unrecognized gUSA sequence %08x-%08x\n",
2203                   pc, pc_end);
2204
2205     /* Restart with the EXCLUSIVE bit set, within a TB run via
2206        cpu_exec_step_atomic holding the exclusive lock.  */
2207     tcg_gen_insn_start(pc, ctx->envflags);
2208     ctx->envflags |= GUSA_EXCLUSIVE;
2209     gen_save_cpu_state(ctx, false);
2210     gen_helper_exclusive(cpu_env);
2211     ctx->bstate = BS_EXCP;
2212
2213     /* We're not executing an instruction, but we must report one for the
2214        purposes of accounting within the TB.  We might as well report the
2215        entire region consumed via ctx->pc so that it's immediately available
2216        in the disassembly dump.  */
2217     ctx->pc = pc_end;
2218     return 1;
2219 }
2220 #endif
2221
2222 void gen_intermediate_code(CPUState *cs, struct TranslationBlock *tb)
2223 {
2224     CPUSH4State *env = cs->env_ptr;
2225     DisasContext ctx;
2226     target_ulong pc_start;
2227     int num_insns;
2228     int max_insns;
2229
2230     pc_start = tb->pc;
2231     ctx.pc = pc_start;
2232     ctx.tbflags = (uint32_t)tb->flags;
2233     ctx.envflags = tb->flags & TB_FLAG_ENVFLAGS_MASK;
2234     ctx.bstate = BS_NONE;
2235     ctx.memidx = (ctx.tbflags & (1u << SR_MD)) == 0 ? 1 : 0;
2236     /* We don't know if the delayed pc came from a dynamic or static branch,
2237        so assume it is a dynamic branch.  */
2238     ctx.delayed_pc = -1; /* use delayed pc from env pointer */
2239     ctx.tb = tb;
2240     ctx.singlestep_enabled = cs->singlestep_enabled;
2241     ctx.features = env->features;
2242     ctx.has_movcal = (ctx.tbflags & TB_FLAG_PENDING_MOVCA);
2243     ctx.gbank = ((ctx.tbflags & (1 << SR_MD)) &&
2244                  (ctx.tbflags & (1 << SR_RB))) * 0x10;
2245     ctx.fbank = ctx.tbflags & FPSCR_FR ? 0x10 : 0;
2246
2247     max_insns = tb_cflags(tb) & CF_COUNT_MASK;
2248     if (max_insns == 0) {
2249         max_insns = CF_COUNT_MASK;
2250     }
2251     max_insns = MIN(max_insns, TCG_MAX_INSNS);
2252
2253     /* Since the ISA is fixed-width, we can bound by the number
2254        of instructions remaining on the page.  */
2255     num_insns = -(ctx.pc | TARGET_PAGE_MASK) / 2;
2256     max_insns = MIN(max_insns, num_insns);
2257
2258     /* Single stepping means just that.  */
2259     if (ctx.singlestep_enabled || singlestep) {
2260         max_insns = 1;
2261     }
2262
2263     gen_tb_start(tb);
2264     num_insns = 0;
2265
2266 #ifdef CONFIG_USER_ONLY
2267     if (ctx.tbflags & GUSA_MASK) {
2268         num_insns = decode_gusa(&ctx, env, &max_insns);
2269     }
2270 #endif
2271
2272     while (ctx.bstate == BS_NONE
2273            && num_insns < max_insns
2274            && !tcg_op_buf_full()) {
2275         tcg_gen_insn_start(ctx.pc, ctx.envflags);
2276         num_insns++;
2277
2278         if (unlikely(cpu_breakpoint_test(cs, ctx.pc, BP_ANY))) {
2279             /* We have hit a breakpoint - make sure PC is up-to-date */
2280             gen_save_cpu_state(&ctx, true);
2281             gen_helper_debug(cpu_env);
2282             ctx.bstate = BS_EXCP;
2283             /* The address covered by the breakpoint must be included in
2284                [tb->pc, tb->pc + tb->size) in order to for it to be
2285                properly cleared -- thus we increment the PC here so that
2286                the logic setting tb->size below does the right thing.  */
2287             ctx.pc += 2;
2288             break;
2289         }
2290
2291         if (num_insns == max_insns && (tb_cflags(tb) & CF_LAST_IO)) {
2292             gen_io_start();
2293         }
2294
2295         ctx.opcode = cpu_lduw_code(env, ctx.pc);
2296         decode_opc(&ctx);
2297         ctx.pc += 2;
2298     }
2299     if (tb_cflags(tb) & CF_LAST_IO) {
2300         gen_io_end();
2301     }
2302
2303     if (ctx.tbflags & GUSA_EXCLUSIVE) {
2304         /* Ending the region of exclusivity.  Clear the bits.  */
2305         ctx.envflags &= ~GUSA_MASK;
2306     }
2307
2308     if (cs->singlestep_enabled) {
2309         gen_save_cpu_state(&ctx, true);
2310         gen_helper_debug(cpu_env);
2311     } else {
2312         switch (ctx.bstate) {
2313         case BS_STOP:
2314             gen_save_cpu_state(&ctx, true);
2315             tcg_gen_exit_tb(0);
2316             break;
2317         case BS_NONE:
2318             gen_save_cpu_state(&ctx, false);
2319             gen_goto_tb(&ctx, 0, ctx.pc);
2320             break;
2321         case BS_EXCP:
2322             /* fall through */
2323         case BS_BRANCH:
2324         default:
2325             break;
2326         }
2327     }
2328
2329     gen_tb_end(tb, num_insns);
2330
2331     tb->size = ctx.pc - pc_start;
2332     tb->icount = num_insns;
2333
2334 #ifdef DEBUG_DISAS
2335     if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)
2336         && qemu_log_in_addr_range(pc_start)) {
2337         qemu_log_lock();
2338         qemu_log("IN:\n");      /* , lookup_symbol(pc_start)); */
2339         log_target_disas(cs, pc_start, ctx.pc - pc_start);
2340         qemu_log("\n");
2341         qemu_log_unlock();
2342     }
2343 #endif
2344 }
2345
2346 void restore_state_to_opc(CPUSH4State *env, TranslationBlock *tb,
2347                           target_ulong *data)
2348 {
2349     env->pc = data[0];
2350     env->flags = data[1];
2351     /* Theoretically delayed_pc should also be restored. In practice the
2352        branch instruction is re-executed after exception, so the delayed
2353        branch target will be recomputed. */
2354 }