target-m68k/translate.c

   1 /*
   2  *  m68k translation
   3  *
   4  *  Copyright (c) 2005-2007 CodeSourcery
   5  *  Written by Paul Brook
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include "cpu.h"
  22 #include "disas/disas.h"
  23 #include "tcg-op.h"
  24 #include "qemu/log.h"
  25
  26 #include "helpers.h"
  27 #define GEN_HELPER 1
  28 #include "helpers.h"
  29
  30 //#define DEBUG_DISPATCH 1
  31
  32 /* Fake floating point.  */
  33 #define tcg_gen_mov_f64 tcg_gen_mov_i64
  34 #define tcg_gen_qemu_ldf64 tcg_gen_qemu_ld64
  35 #define tcg_gen_qemu_stf64 tcg_gen_qemu_st64
  36
  37 #define DEFO32(name, offset) static TCGv QREG_##name;
  38 #define DEFO64(name, offset) static TCGv_i64 QREG_##name;
  39 #define DEFF64(name, offset) static TCGv_i64 QREG_##name;
  40 #include "qregs.def"
  41 #undef DEFO32
  42 #undef DEFO64
  43 #undef DEFF64
  44
  45 static TCGv_i32 cpu_halted;
  46
  47 static TCGv_ptr cpu_env;
  48
  49 static char cpu_reg_names[3*8*3 + 5*4];
  50 static TCGv cpu_dregs[8];
  51 static TCGv cpu_aregs[8];
  52 static TCGv_i64 cpu_fregs[8];
  53 static TCGv_i64 cpu_macc[4];
  54
  55 #define DREG(insn, pos) cpu_dregs[((insn) >> (pos)) & 7]
  56 #define AREG(insn, pos) cpu_aregs[((insn) >> (pos)) & 7]
  57 #define FREG(insn, pos) cpu_fregs[((insn) >> (pos)) & 7]
  58 #define MACREG(acc) cpu_macc[acc]
  59 #define QREG_SP cpu_aregs[7]
  60
  61 static TCGv NULL_QREG;
  62 #define IS_NULL_QREG(t) (TCGV_EQUAL(t, NULL_QREG))
  63 /* Used to distinguish stores from bad addressing modes.  */
  64 static TCGv store_dummy;
  65
  66 #include "exec/gen-icount.h"
  67
  68 void m68k_tcg_init(void)
  69 {
  70     char *p;
  71     int i;
  72
  73 #define DEFO32(name,  offset) QREG_##name = tcg_global_mem_new_i32(TCG_AREG0, offsetof(CPUM68KState, offset), #name);
  74 #define DEFO64(name,  offset) QREG_##name = tcg_global_mem_new_i64(TCG_AREG0, offsetof(CPUM68KState, offset), #name);
  75 #define DEFF64(name,  offset) DEFO64(name, offset)
  76 #include "qregs.def"
  77 #undef DEFO32
  78 #undef DEFO64
  79 #undef DEFF64
  80
  81     cpu_halted = tcg_global_mem_new_i32(TCG_AREG0,
  82                                         -offsetof(M68kCPU, env) +
  83                                         offsetof(CPUState, halted), "HALTED");
  84
  85     cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
  86
  87     p = cpu_reg_names;
  88     for (i = 0; i < 8; i++) {
  89         sprintf(p, "D%d", i);
  90         cpu_dregs[i] = tcg_global_mem_new(TCG_AREG0,
  91                                           offsetof(CPUM68KState, dregs[i]), p);
  92         p += 3;
  93         sprintf(p, "A%d", i);
  94         cpu_aregs[i] = tcg_global_mem_new(TCG_AREG0,
  95                                           offsetof(CPUM68KState, aregs[i]), p);
  96         p += 3;
  97         sprintf(p, "F%d", i);
  98         cpu_fregs[i] = tcg_global_mem_new_i64(TCG_AREG0,
  99                                           offsetof(CPUM68KState, fregs[i]), p);
 100         p += 3;
 101     }
 102     for (i = 0; i < 4; i++) {
 103         sprintf(p, "ACC%d", i);
 104         cpu_macc[i] = tcg_global_mem_new_i64(TCG_AREG0,
 105                                          offsetof(CPUM68KState, macc[i]), p);
 106         p += 5;
 107     }
 108
 109     NULL_QREG = tcg_global_mem_new(TCG_AREG0, -4, "NULL");
 110     store_dummy = tcg_global_mem_new(TCG_AREG0, -8, "NULL");
 111
 112 #define GEN_HELPER 2
 113 #include "helpers.h"
 114 }
 115
 116 static inline void qemu_assert(int cond, const char *msg)
 117 {
 118     if (!cond) {
 119         fprintf (stderr, "badness: %s\n", msg);
 120         abort();
 121     }
 122 }
 123
 124 /* internal defines */
 125 typedef struct DisasContext {
 126     CPUM68KState *env;
 127     target_ulong insn_pc; /* Start of the current instruction.  */
 128     target_ulong pc;
 129     int is_jmp;
 130     int cc_op;
 131     int user;
 132     uint32_t fpcr;
 133     struct TranslationBlock *tb;
 134     int singlestep_enabled;
 135     int is_mem;
 136     TCGv_i64 mactmp;
 137     int done_mac;
 138 } DisasContext;
 139
 140 #define DISAS_JUMP_NEXT 4
 141
 142 #if defined(CONFIG_USER_ONLY)
 143 #define IS_USER(s) 1
 144 #else
 145 #define IS_USER(s) s->user
 146 #endif
 147
 148 /* XXX: move that elsewhere */
 149 /* ??? Fix exceptions.  */
 150 static void *gen_throws_exception;
 151 #define gen_last_qop NULL
 152
 153 #define OS_BYTE 0
 154 #define OS_WORD 1
 155 #define OS_LONG 2
 156 #define OS_SINGLE 4
 157 #define OS_DOUBLE 5
 158
 159 typedef void (*disas_proc)(CPUM68KState *env, DisasContext *s, uint16_t insn);
 160
 161 #ifdef DEBUG_DISPATCH
 162 #define DISAS_INSN(name)                                                \
 163     static void real_disas_##name(CPUM68KState *env, DisasContext *s,   \
 164                                   uint16_t insn);                       \
 165     static void disas_##name(CPUM68KState *env, DisasContext *s,        \
 166                              uint16_t insn)                             \
 167     {                                                                   \
 168         qemu_log("Dispatch " #name "\n");                               \
 169         real_disas_##name(s, env, insn);                                \
 170     }                                                                   \
 171     static void real_disas_##name(CPUM68KState *env, DisasContext *s,   \
 172                                   uint16_t insn)
 173 #else
 174 #define DISAS_INSN(name)                                                \
 175     static void disas_##name(CPUM68KState *env, DisasContext *s,        \
 176                              uint16_t insn)
 177 #endif
 178
 179 /* Generate a load from the specified address.  Narrow values are
 180    sign extended to full register width.  */
 181 static inline TCGv gen_load(DisasContext * s, int opsize, TCGv addr, int sign)
 182 {
 183     TCGv tmp;
 184     int index = IS_USER(s);
 185     s->is_mem = 1;
 186     tmp = tcg_temp_new_i32();
 187     switch(opsize) {
 188     case OS_BYTE:
 189         if (sign)
 190             tcg_gen_qemu_ld8s(tmp, addr, index);
 191         else
 192             tcg_gen_qemu_ld8u(tmp, addr, index);
 193         break;
 194     case OS_WORD:
 195         if (sign)
 196             tcg_gen_qemu_ld16s(tmp, addr, index);
 197         else
 198             tcg_gen_qemu_ld16u(tmp, addr, index);
 199         break;
 200     case OS_LONG:
 201     case OS_SINGLE:
 202         tcg_gen_qemu_ld32u(tmp, addr, index);
 203         break;
 204     default:
 205         qemu_assert(0, "bad load size");
 206     }
 207     gen_throws_exception = gen_last_qop;
 208     return tmp;
 209 }
 210
 211 static inline TCGv_i64 gen_load64(DisasContext * s, TCGv addr)
 212 {
 213     TCGv_i64 tmp;
 214     int index = IS_USER(s);
 215     s->is_mem = 1;
 216     tmp = tcg_temp_new_i64();
 217     tcg_gen_qemu_ldf64(tmp, addr, index);
 218     gen_throws_exception = gen_last_qop;
 219     return tmp;
 220 }
 221
 222 /* Generate a store.  */
 223 static inline void gen_store(DisasContext *s, int opsize, TCGv addr, TCGv val)
 224 {
 225     int index = IS_USER(s);
 226     s->is_mem = 1;
 227     switch(opsize) {
 228     case OS_BYTE:
 229         tcg_gen_qemu_st8(val, addr, index);
 230         break;
 231     case OS_WORD:
 232         tcg_gen_qemu_st16(val, addr, index);
 233         break;
 234     case OS_LONG:
 235     case OS_SINGLE:
 236         tcg_gen_qemu_st32(val, addr, index);
 237         break;
 238     default:
 239         qemu_assert(0, "bad store size");
 240     }
 241     gen_throws_exception = gen_last_qop;
 242 }
 243
 244 static inline void gen_store64(DisasContext *s, TCGv addr, TCGv_i64 val)
 245 {
 246     int index = IS_USER(s);
 247     s->is_mem = 1;
 248     tcg_gen_qemu_stf64(val, addr, index);
 249     gen_throws_exception = gen_last_qop;
 250 }
 251
 252 typedef enum {
 253     EA_STORE,
 254     EA_LOADU,
 255     EA_LOADS
 256 } ea_what;
 257
 258 /* Generate an unsigned load if VAL is 0 a signed load if val is -1,
 259    otherwise generate a store.  */
 260 static TCGv gen_ldst(DisasContext *s, int opsize, TCGv addr, TCGv val,
 261                      ea_what what)
 262 {
 263     if (what == EA_STORE) {
 264         gen_store(s, opsize, addr, val);
 265         return store_dummy;
 266     } else {
 267         return gen_load(s, opsize, addr, what == EA_LOADS);
 268     }
 269 }
 270
 271 /* Read a 32-bit immediate constant.  */
 272 static inline uint32_t read_im32(CPUM68KState *env, DisasContext *s)
 273 {
 274     uint32_t im;
 275     im = ((uint32_t)cpu_lduw_code(env, s->pc)) << 16;
 276     s->pc += 2;
 277     im |= cpu_lduw_code(env, s->pc);
 278     s->pc += 2;
 279     return im;
 280 }
 281
 282 /* Calculate and address index.  */
 283 static TCGv gen_addr_index(uint16_t ext, TCGv tmp)
 284 {
 285     TCGv add;
 286     int scale;
 287
 288     add = (ext & 0x8000) ? AREG(ext, 12) : DREG(ext, 12);
 289     if ((ext & 0x800) == 0) {
 290         tcg_gen_ext16s_i32(tmp, add);
 291         add = tmp;
 292     }
 293     scale = (ext >> 9) & 3;
 294     if (scale != 0) {
 295         tcg_gen_shli_i32(tmp, add, scale);
 296         add = tmp;
 297     }
 298     return add;
 299 }
 300
 301 /* Handle a base + index + displacement effective addresss.
 302    A NULL_QREG base means pc-relative.  */
 303 static TCGv gen_lea_indexed(CPUM68KState *env, DisasContext *s, int opsize,
 304                             TCGv base)
 305 {
 306     uint32_t offset;
 307     uint16_t ext;
 308     TCGv add;
 309     TCGv tmp;
 310     uint32_t bd, od;
 311
 312     offset = s->pc;
 313     ext = cpu_lduw_code(env, s->pc);
 314     s->pc += 2;
 315
 316     if ((ext & 0x800) == 0 && !m68k_feature(s->env, M68K_FEATURE_WORD_INDEX))
 317         return NULL_QREG;
 318
 319     if (ext & 0x100) {
 320         /* full extension word format */
 321         if (!m68k_feature(s->env, M68K_FEATURE_EXT_FULL))
 322             return NULL_QREG;
 323
 324         if ((ext & 0x30) > 0x10) {
 325             /* base displacement */
 326             if ((ext & 0x30) == 0x20) {
 327                 bd = (int16_t)cpu_lduw_code(env, s->pc);
 328                 s->pc += 2;
 329             } else {
 330                 bd = read_im32(env, s);
 331             }
 332         } else {
 333             bd = 0;
 334         }
 335         tmp = tcg_temp_new();
 336         if ((ext & 0x44) == 0) {
 337             /* pre-index */
 338             add = gen_addr_index(ext, tmp);
 339         } else {
 340             add = NULL_QREG;
 341         }
 342         if ((ext & 0x80) == 0) {
 343             /* base not suppressed */
 344             if (IS_NULL_QREG(base)) {
 345                 base = tcg_const_i32(offset + bd);
 346                 bd = 0;
 347             }
 348             if (!IS_NULL_QREG(add)) {
 349                 tcg_gen_add_i32(tmp, add, base);
 350                 add = tmp;
 351             } else {
 352                 add = base;
 353             }
 354         }
 355         if (!IS_NULL_QREG(add)) {
 356             if (bd != 0) {
 357                 tcg_gen_addi_i32(tmp, add, bd);
 358                 add = tmp;
 359             }
 360         } else {
 361             add = tcg_const_i32(bd);
 362         }
 363         if ((ext & 3) != 0) {
 364             /* memory indirect */
 365             base = gen_load(s, OS_LONG, add, 0);
 366             if ((ext & 0x44) == 4) {
 367                 add = gen_addr_index(ext, tmp);
 368                 tcg_gen_add_i32(tmp, add, base);
 369                 add = tmp;
 370             } else {
 371                 add = base;
 372             }
 373             if ((ext & 3) > 1) {
 374                 /* outer displacement */
 375                 if ((ext & 3) == 2) {
 376                     od = (int16_t)cpu_lduw_code(env, s->pc);
 377                     s->pc += 2;
 378                 } else {
 379                     od = read_im32(env, s);
 380                 }
 381             } else {
 382                 od = 0;
 383             }
 384             if (od != 0) {
 385                 tcg_gen_addi_i32(tmp, add, od);
 386                 add = tmp;
 387             }
 388         }
 389     } else {
 390         /* brief extension word format */
 391         tmp = tcg_temp_new();
 392         add = gen_addr_index(ext, tmp);
 393         if (!IS_NULL_QREG(base)) {
 394             tcg_gen_add_i32(tmp, add, base);
 395             if ((int8_t)ext)
 396                 tcg_gen_addi_i32(tmp, tmp, (int8_t)ext);
 397         } else {
 398             tcg_gen_addi_i32(tmp, add, offset + (int8_t)ext);
 399         }
 400         add = tmp;
 401     }
 402     return add;
 403 }
 404
 405 /* Update the CPU env CC_OP state.  */
 406 static inline void gen_flush_cc_op(DisasContext *s)
 407 {
 408     if (s->cc_op != CC_OP_DYNAMIC)
 409         tcg_gen_movi_i32(QREG_CC_OP, s->cc_op);
 410 }
 411
 412 /* Evaluate all the CC flags.  */
 413 static inline void gen_flush_flags(DisasContext *s)
 414 {
 415     if (s->cc_op == CC_OP_FLAGS)
 416         return;
 417     gen_flush_cc_op(s);
 418     gen_helper_flush_flags(cpu_env, QREG_CC_OP);
 419     s->cc_op = CC_OP_FLAGS;
 420 }
 421
 422 static void gen_logic_cc(DisasContext *s, TCGv val)
 423 {
 424     tcg_gen_mov_i32(QREG_CC_DEST, val);
 425     s->cc_op = CC_OP_LOGIC;
 426 }
 427
 428 static void gen_update_cc_add(TCGv dest, TCGv src)
 429 {
 430     tcg_gen_mov_i32(QREG_CC_DEST, dest);
 431     tcg_gen_mov_i32(QREG_CC_SRC, src);
 432 }
 433
 434 static inline int opsize_bytes(int opsize)
 435 {
 436     switch (opsize) {
 437     case OS_BYTE: return 1;
 438     case OS_WORD: return 2;
 439     case OS_LONG: return 4;
 440     case OS_SINGLE: return 4;
 441     case OS_DOUBLE: return 8;
 442     default:
 443         qemu_assert(0, "bad operand size");
 444         return 0;
 445     }
 446 }
 447
 448 /* Assign value to a register.  If the width is less than the register width
 449    only the low part of the register is set.  */
 450 static void gen_partset_reg(int opsize, TCGv reg, TCGv val)
 451 {
 452     TCGv tmp;
 453     switch (opsize) {
 454     case OS_BYTE:
 455         tcg_gen_andi_i32(reg, reg, 0xffffff00);
 456         tmp = tcg_temp_new();
 457         tcg_gen_ext8u_i32(tmp, val);
 458         tcg_gen_or_i32(reg, reg, tmp);
 459         break;
 460     case OS_WORD:
 461         tcg_gen_andi_i32(reg, reg, 0xffff0000);
 462         tmp = tcg_temp_new();
 463         tcg_gen_ext16u_i32(tmp, val);
 464         tcg_gen_or_i32(reg, reg, tmp);
 465         break;
 466     case OS_LONG:
 467     case OS_SINGLE:
 468         tcg_gen_mov_i32(reg, val);
 469         break;
 470     default:
 471         qemu_assert(0, "Bad operand size");
 472         break;
 473     }
 474 }
 475
 476 /* Sign or zero extend a value.  */
 477 static inline TCGv gen_extend(TCGv val, int opsize, int sign)
 478 {
 479     TCGv tmp;
 480
 481     switch (opsize) {
 482     case OS_BYTE:
 483         tmp = tcg_temp_new();
 484         if (sign)
 485             tcg_gen_ext8s_i32(tmp, val);
 486         else
 487             tcg_gen_ext8u_i32(tmp, val);
 488         break;
 489     case OS_WORD:
 490         tmp = tcg_temp_new();
 491         if (sign)
 492             tcg_gen_ext16s_i32(tmp, val);
 493         else
 494             tcg_gen_ext16u_i32(tmp, val);
 495         break;
 496     case OS_LONG:
 497     case OS_SINGLE:
 498         tmp = val;
 499         break;
 500     default:
 501         qemu_assert(0, "Bad operand size");
 502     }
 503     return tmp;
 504 }
 505
 506 /* Generate code for an "effective address".  Does not adjust the base
 507    register for autoincrement addressing modes.  */
 508 static TCGv gen_lea(CPUM68KState *env, DisasContext *s, uint16_t insn,
 509                     int opsize)
 510 {
 511     TCGv reg;
 512     TCGv tmp;
 513     uint16_t ext;
 514     uint32_t offset;
 515
 516     switch ((insn >> 3) & 7) {
 517     case 0: /* Data register direct.  */
 518     case 1: /* Address register direct.  */
 519         return NULL_QREG;
 520     case 2: /* Indirect register */
 521     case 3: /* Indirect postincrement.  */
 522         return AREG(insn, 0);
 523     case 4: /* Indirect predecrememnt.  */
 524         reg = AREG(insn, 0);
 525         tmp = tcg_temp_new();
 526         tcg_gen_subi_i32(tmp, reg, opsize_bytes(opsize));
 527         return tmp;
 528     case 5: /* Indirect displacement.  */
 529         reg = AREG(insn, 0);
 530         tmp = tcg_temp_new();
 531         ext = cpu_lduw_code(env, s->pc);
 532         s->pc += 2;
 533         tcg_gen_addi_i32(tmp, reg, (int16_t)ext);
 534         return tmp;
 535     case 6: /* Indirect index + displacement.  */
 536         reg = AREG(insn, 0);
 537         return gen_lea_indexed(env, s, opsize, reg);
 538     case 7: /* Other */
 539         switch (insn & 7) {
 540         case 0: /* Absolute short.  */
 541             offset = cpu_ldsw_code(env, s->pc);
 542             s->pc += 2;
 543             return tcg_const_i32(offset);
 544         case 1: /* Absolute long.  */
 545             offset = read_im32(env, s);
 546             return tcg_const_i32(offset);
 547         case 2: /* pc displacement  */
 548             offset = s->pc;
 549             offset += cpu_ldsw_code(env, s->pc);
 550             s->pc += 2;
 551             return tcg_const_i32(offset);
 552         case 3: /* pc index+displacement.  */
 553             return gen_lea_indexed(env, s, opsize, NULL_QREG);
 554         case 4: /* Immediate.  */
 555         default:
 556             return NULL_QREG;
 557         }
 558     }
 559     /* Should never happen.  */
 560     return NULL_QREG;
 561 }
 562
 563 /* Helper function for gen_ea. Reuse the computed address between the
 564    for read/write operands.  */
 565 static inline TCGv gen_ea_once(CPUM68KState *env, DisasContext *s,
 566                                uint16_t insn, int opsize, TCGv val,
 567                                TCGv *addrp, ea_what what)
 568 {
 569     TCGv tmp;
 570
 571     if (addrp && what == EA_STORE) {
 572         tmp = *addrp;
 573     } else {
 574         tmp = gen_lea(env, s, insn, opsize);
 575         if (IS_NULL_QREG(tmp))
 576             return tmp;
 577         if (addrp)
 578             *addrp = tmp;
 579     }
 580     return gen_ldst(s, opsize, tmp, val, what);
 581 }
 582
 583 /* Generate code to load/store a value from/into an EA.  If VAL > 0 this is
 584    a write otherwise it is a read (0 == sign extend, -1 == zero extend).
 585    ADDRP is non-null for readwrite operands.  */
 586 static TCGv gen_ea(CPUM68KState *env, DisasContext *s, uint16_t insn,
 587                    int opsize, TCGv val, TCGv *addrp, ea_what what)
 588 {
 589     TCGv reg;
 590     TCGv result;
 591     uint32_t offset;
 592
 593     switch ((insn >> 3) & 7) {
 594     case 0: /* Data register direct.  */
 595         reg = DREG(insn, 0);
 596         if (what == EA_STORE) {
 597             gen_partset_reg(opsize, reg, val);
 598             return store_dummy;
 599         } else {
 600             return gen_extend(reg, opsize, what == EA_LOADS);
 601         }
 602     case 1: /* Address register direct.  */
 603         reg = AREG(insn, 0);
 604         if (what == EA_STORE) {
 605             tcg_gen_mov_i32(reg, val);
 606             return store_dummy;
 607         } else {
 608             return gen_extend(reg, opsize, what == EA_LOADS);
 609         }
 610     case 2: /* Indirect register */
 611         reg = AREG(insn, 0);
 612         return gen_ldst(s, opsize, reg, val, what);
 613     case 3: /* Indirect postincrement.  */
 614         reg = AREG(insn, 0);
 615         result = gen_ldst(s, opsize, reg, val, what);
 616         /* ??? This is not exception safe.  The instruction may still
 617            fault after this point.  */
 618         if (what == EA_STORE || !addrp)
 619             tcg_gen_addi_i32(reg, reg, opsize_bytes(opsize));
 620         return result;
 621     case 4: /* Indirect predecrememnt.  */
 622         {
 623             TCGv tmp;
 624             if (addrp && what == EA_STORE) {
 625                 tmp = *addrp;
 626             } else {
 627                 tmp = gen_lea(env, s, insn, opsize);
 628                 if (IS_NULL_QREG(tmp))
 629                     return tmp;
 630                 if (addrp)
 631                     *addrp = tmp;
 632             }
 633             result = gen_ldst(s, opsize, tmp, val, what);
 634             /* ??? This is not exception safe.  The instruction may still
 635                fault after this point.  */
 636             if (what == EA_STORE || !addrp) {
 637                 reg = AREG(insn, 0);
 638                 tcg_gen_mov_i32(reg, tmp);
 639             }
 640         }
 641         return result;
 642     case 5: /* Indirect displacement.  */
 643     case 6: /* Indirect index + displacement.  */
 644         return gen_ea_once(env, s, insn, opsize, val, addrp, what);
 645     case 7: /* Other */
 646         switch (insn & 7) {
 647         case 0: /* Absolute short.  */
 648         case 1: /* Absolute long.  */
 649         case 2: /* pc displacement  */
 650         case 3: /* pc index+displacement.  */
 651             return gen_ea_once(env, s, insn, opsize, val, addrp, what);
 652         case 4: /* Immediate.  */
 653             /* Sign extend values for consistency.  */
 654             switch (opsize) {
 655             case OS_BYTE:
 656                 if (what == EA_LOADS) {
 657                     offset = cpu_ldsb_code(env, s->pc + 1);
 658                 } else {
 659                     offset = cpu_ldub_code(env, s->pc + 1);
 660                 }
 661                 s->pc += 2;
 662                 break;
 663             case OS_WORD:
 664                 if (what == EA_LOADS) {
 665                     offset = cpu_ldsw_code(env, s->pc);
 666                 } else {
 667                     offset = cpu_lduw_code(env, s->pc);
 668                 }
 669                 s->pc += 2;
 670                 break;
 671             case OS_LONG:
 672                 offset = read_im32(env, s);
 673                 break;
 674             default:
 675                 qemu_assert(0, "Bad immediate operand");
 676             }
 677             return tcg_const_i32(offset);
 678         default:
 679             return NULL_QREG;
 680         }
 681     }
 682     /* Should never happen.  */
 683     return NULL_QREG;
 684 }
 685
 686 /* This generates a conditional branch, clobbering all temporaries.  */
 687 static void gen_jmpcc(DisasContext *s, int cond, int l1)
 688 {
 689     TCGv tmp;
 690
 691     /* TODO: Optimize compare/branch pairs rather than always flushing
 692        flag state to CC_OP_FLAGS.  */
 693     gen_flush_flags(s);
 694     switch (cond) {
 695     case 0: /* T */
 696         tcg_gen_br(l1);
 697         break;
 698     case 1: /* F */
 699         break;
 700     case 2: /* HI (!C && !Z) */
 701         tmp = tcg_temp_new();
 702         tcg_gen_andi_i32(tmp, QREG_CC_DEST, CCF_C | CCF_Z);
 703         tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, l1);
 704         break;
 705     case 3: /* LS (C || Z) */
 706         tmp = tcg_temp_new();
 707         tcg_gen_andi_i32(tmp, QREG_CC_DEST, CCF_C | CCF_Z);
 708         tcg_gen_brcondi_i32(TCG_COND_NE, tmp, 0, l1);
 709         break;
 710     case 4: /* CC (!C) */
 711         tmp = tcg_temp_new();
 712         tcg_gen_andi_i32(tmp, QREG_CC_DEST, CCF_C);
 713         tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, l1);
 714         break;
 715     case 5: /* CS (C) */
 716         tmp = tcg_temp_new();
 717         tcg_gen_andi_i32(tmp, QREG_CC_DEST, CCF_C);
 718         tcg_gen_brcondi_i32(TCG_COND_NE, tmp, 0, l1);
 719         break;
 720     case 6: /* NE (!Z) */
 721         tmp = tcg_temp_new();
 722         tcg_gen_andi_i32(tmp, QREG_CC_DEST, CCF_Z);
 723         tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, l1);
 724         break;
 725     case 7: /* EQ (Z) */
 726         tmp = tcg_temp_new();
 727         tcg_gen_andi_i32(tmp, QREG_CC_DEST, CCF_Z);
 728         tcg_gen_brcondi_i32(TCG_COND_NE, tmp, 0, l1);
 729         break;
 730     case 8: /* VC (!V) */
 731         tmp = tcg_temp_new();
 732         tcg_gen_andi_i32(tmp, QREG_CC_DEST, CCF_V);
 733         tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, l1);
 734         break;
 735     case 9: /* VS (V) */
 736         tmp = tcg_temp_new();
 737         tcg_gen_andi_i32(tmp, QREG_CC_DEST, CCF_V);
 738         tcg_gen_brcondi_i32(TCG_COND_NE, tmp, 0, l1);
 739         break;
 740     case 10: /* PL (!N) */
 741         tmp = tcg_temp_new();
 742         tcg_gen_andi_i32(tmp, QREG_CC_DEST, CCF_N);
 743         tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, l1);
 744         break;
 745     case 11: /* MI (N) */
 746         tmp = tcg_temp_new();
 747         tcg_gen_andi_i32(tmp, QREG_CC_DEST, CCF_N);
 748         tcg_gen_brcondi_i32(TCG_COND_NE, tmp, 0, l1);
 749         break;
 750     case 12: /* GE (!(N ^ V)) */
 751         tmp = tcg_temp_new();
 752         assert(CCF_V == (CCF_N >> 2));
 753         tcg_gen_shri_i32(tmp, QREG_CC_DEST, 2);
 754         tcg_gen_xor_i32(tmp, tmp, QREG_CC_DEST);
 755         tcg_gen_andi_i32(tmp, tmp, CCF_V);
 756         tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, l1);
 757         break;
 758     case 13: /* LT (N ^ V) */
 759         tmp = tcg_temp_new();
 760         assert(CCF_V == (CCF_N >> 2));
 761         tcg_gen_shri_i32(tmp, QREG_CC_DEST, 2);
 762         tcg_gen_xor_i32(tmp, tmp, QREG_CC_DEST);
 763         tcg_gen_andi_i32(tmp, tmp, CCF_V);
 764         tcg_gen_brcondi_i32(TCG_COND_NE, tmp, 0, l1);
 765         break;
 766     case 14: /* GT (!(Z || (N ^ V))) */
 767         tmp = tcg_temp_new();
 768         assert(CCF_V == (CCF_N >> 2));
 769         tcg_gen_andi_i32(tmp, QREG_CC_DEST, CCF_N);
 770         tcg_gen_shri_i32(tmp, tmp, 2);
 771         tcg_gen_xor_i32(tmp, tmp, QREG_CC_DEST);
 772         tcg_gen_andi_i32(tmp, tmp, CCF_V | CCF_Z);
 773         tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, l1);
 774         break;
 775     case 15: /* LE (Z || (N ^ V)) */
 776         tmp = tcg_temp_new();
 777         assert(CCF_V == (CCF_N >> 2));
 778         tcg_gen_andi_i32(tmp, QREG_CC_DEST, CCF_N);
 779         tcg_gen_shri_i32(tmp, tmp, 2);
 780         tcg_gen_xor_i32(tmp, tmp, QREG_CC_DEST);
 781         tcg_gen_andi_i32(tmp, tmp, CCF_V | CCF_Z);
 782         tcg_gen_brcondi_i32(TCG_COND_NE, tmp, 0, l1);
 783         break;
 784     default:
 785         /* Should ever happen.  */
 786         abort();
 787     }
 788 }
 789
 790 DISAS_INSN(scc)
 791 {
 792     int l1;
 793     int cond;
 794     TCGv reg;
 795
 796     l1 = gen_new_label();
 797     cond = (insn >> 8) & 0xf;
 798     reg = DREG(insn, 0);
 799     tcg_gen_andi_i32(reg, reg, 0xffffff00);
 800     /* This is safe because we modify the reg directly, with no other values
 801        live.  */
 802     gen_jmpcc(s, cond ^ 1, l1);
 803     tcg_gen_ori_i32(reg, reg, 0xff);
 804     gen_set_label(l1);
 805 }
 806
 807 /* Force a TB lookup after an instruction that changes the CPU state.  */
 808 static void gen_lookup_tb(DisasContext *s)
 809 {
 810     gen_flush_cc_op(s);
 811     tcg_gen_movi_i32(QREG_PC, s->pc);
 812     s->is_jmp = DISAS_UPDATE;
 813 }
 814
 815 /* Generate a jump to an immediate address.  */
 816 static void gen_jmp_im(DisasContext *s, uint32_t dest)
 817 {
 818     gen_flush_cc_op(s);
 819     tcg_gen_movi_i32(QREG_PC, dest);
 820     s->is_jmp = DISAS_JUMP;
 821 }
 822
 823 /* Generate a jump to the address in qreg DEST.  */
 824 static void gen_jmp(DisasContext *s, TCGv dest)
 825 {
 826     gen_flush_cc_op(s);
 827     tcg_gen_mov_i32(QREG_PC, dest);
 828     s->is_jmp = DISAS_JUMP;
 829 }
 830
 831 static void gen_exception(DisasContext *s, uint32_t where, int nr)
 832 {
 833     gen_flush_cc_op(s);
 834     gen_jmp_im(s, where);
 835     gen_helper_raise_exception(cpu_env, tcg_const_i32(nr));
 836 }
 837
 838 static inline void gen_addr_fault(DisasContext *s)
 839 {
 840     gen_exception(s, s->insn_pc, EXCP_ADDRESS);
 841 }
 842
 843 #define SRC_EA(env, result, opsize, op_sign, addrp) do {                \
 844         result = gen_ea(env, s, insn, opsize, NULL_QREG, addrp,         \
 845                         op_sign ? EA_LOADS : EA_LOADU);                 \
 846         if (IS_NULL_QREG(result)) {                                     \
 847             gen_addr_fault(s);                                          \
 848             return;                                                     \
 849         }                                                               \
 850     } while (0)
 851
 852 #define DEST_EA(env, insn, opsize, val, addrp) do {                     \
 853         TCGv ea_result = gen_ea(env, s, insn, opsize, val, addrp, EA_STORE); \
 854         if (IS_NULL_QREG(ea_result)) {                                  \
 855             gen_addr_fault(s);                                          \
 856             return;                                                     \
 857         }                                                               \
 858     } while (0)
 859
 860 /* Generate a jump to an immediate address.  */
 861 static void gen_jmp_tb(DisasContext *s, int n, uint32_t dest)
 862 {
 863     TranslationBlock *tb;
 864
 865     tb = s->tb;
 866     if (unlikely(s->singlestep_enabled)) {
 867         gen_exception(s, dest, EXCP_DEBUG);
 868     } else if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK) ||
 869                (s->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
 870         tcg_gen_goto_tb(n);
 871         tcg_gen_movi_i32(QREG_PC, dest);
 872         tcg_gen_exit_tb((tcg_target_long)tb + n);
 873     } else {
 874         gen_jmp_im(s, dest);
 875         tcg_gen_exit_tb(0);
 876     }
 877     s->is_jmp = DISAS_TB_JUMP;
 878 }
 879
 880 DISAS_INSN(undef_mac)
 881 {
 882     gen_exception(s, s->pc - 2, EXCP_LINEA);
 883 }
 884
 885 DISAS_INSN(undef_fpu)
 886 {
 887     gen_exception(s, s->pc - 2, EXCP_LINEF);
 888 }
 889
 890 DISAS_INSN(undef)
 891 {
 892     gen_exception(s, s->pc - 2, EXCP_UNSUPPORTED);
 893     cpu_abort(env, "Illegal instruction: %04x @ %08x", insn, s->pc - 2);
 894 }
 895
 896 DISAS_INSN(mulw)
 897 {
 898     TCGv reg;
 899     TCGv tmp;
 900     TCGv src;
 901     int sign;
 902
 903     sign = (insn & 0x100) != 0;
 904     reg = DREG(insn, 9);
 905     tmp = tcg_temp_new();
 906     if (sign)
 907         tcg_gen_ext16s_i32(tmp, reg);
 908     else
 909         tcg_gen_ext16u_i32(tmp, reg);
 910     SRC_EA(env, src, OS_WORD, sign, NULL);
 911     tcg_gen_mul_i32(tmp, tmp, src);
 912     tcg_gen_mov_i32(reg, tmp);
 913     /* Unlike m68k, coldfire always clears the overflow bit.  */
 914     gen_logic_cc(s, tmp);
 915 }
 916
 917 DISAS_INSN(divw)
 918 {
 919     TCGv reg;
 920     TCGv tmp;
 921     TCGv src;
 922     int sign;
 923
 924     sign = (insn & 0x100) != 0;
 925     reg = DREG(insn, 9);
 926     if (sign) {
 927         tcg_gen_ext16s_i32(QREG_DIV1, reg);
 928     } else {
 929         tcg_gen_ext16u_i32(QREG_DIV1, reg);
 930     }
 931     SRC_EA(env, src, OS_WORD, sign, NULL);
 932     tcg_gen_mov_i32(QREG_DIV2, src);
 933     if (sign) {
 934         gen_helper_divs(cpu_env, tcg_const_i32(1));
 935     } else {
 936         gen_helper_divu(cpu_env, tcg_const_i32(1));
 937     }
 938
 939     tmp = tcg_temp_new();
 940     src = tcg_temp_new();
 941     tcg_gen_ext16u_i32(tmp, QREG_DIV1);
 942     tcg_gen_shli_i32(src, QREG_DIV2, 16);
 943     tcg_gen_or_i32(reg, tmp, src);
 944     s->cc_op = CC_OP_FLAGS;
 945 }
 946
 947 DISAS_INSN(divl)
 948 {
 949     TCGv num;
 950     TCGv den;
 951     TCGv reg;
 952     uint16_t ext;
 953
 954     ext = cpu_lduw_code(env, s->pc);
 955     s->pc += 2;
 956     if (ext & 0x87f8) {
 957         gen_exception(s, s->pc - 4, EXCP_UNSUPPORTED);
 958         return;
 959     }
 960     num = DREG(ext, 12);
 961     reg = DREG(ext, 0);
 962     tcg_gen_mov_i32(QREG_DIV1, num);
 963     SRC_EA(env, den, OS_LONG, 0, NULL);
 964     tcg_gen_mov_i32(QREG_DIV2, den);
 965     if (ext & 0x0800) {
 966         gen_helper_divs(cpu_env, tcg_const_i32(0));
 967     } else {
 968         gen_helper_divu(cpu_env, tcg_const_i32(0));
 969     }
 970     if ((ext & 7) == ((ext >> 12) & 7)) {
 971         /* div */
 972         tcg_gen_mov_i32 (reg, QREG_DIV1);
 973     } else {
 974         /* rem */
 975         tcg_gen_mov_i32 (reg, QREG_DIV2);
 976     }
 977     s->cc_op = CC_OP_FLAGS;
 978 }
 979
 980 DISAS_INSN(addsub)
 981 {
 982     TCGv reg;
 983     TCGv dest;
 984     TCGv src;
 985     TCGv tmp;
 986     TCGv addr;
 987     int add;
 988
 989     add = (insn & 0x4000) != 0;
 990     reg = DREG(insn, 9);
 991     dest = tcg_temp_new();
 992     if (insn & 0x100) {
 993         SRC_EA(env, tmp, OS_LONG, 0, &addr);
 994         src = reg;
 995     } else {
 996         tmp = reg;
 997         SRC_EA(env, src, OS_LONG, 0, NULL);
 998     }
 999     if (add) {
1000         tcg_gen_add_i32(dest, tmp, src);
1001         gen_helper_xflag_lt(QREG_CC_X, dest, src);
1002         s->cc_op = CC_OP_ADD;
1003     } else {
1004         gen_helper_xflag_lt(QREG_CC_X, tmp, src);
1005         tcg_gen_sub_i32(dest, tmp, src);
1006         s->cc_op = CC_OP_SUB;
1007     }
1008     gen_update_cc_add(dest, src);
1009     if (insn & 0x100) {
1010         DEST_EA(env, insn, OS_LONG, dest, &addr);
1011     } else {
1012         tcg_gen_mov_i32(reg, dest);
1013     }
1014 }
1015
1016
1017 /* Reverse the order of the bits in REG.  */
1018 DISAS_INSN(bitrev)
1019 {
1020     TCGv reg;
1021     reg = DREG(insn, 0);
1022     gen_helper_bitrev(reg, reg);
1023 }
1024
1025 DISAS_INSN(bitop_reg)
1026 {
1027     int opsize;
1028     int op;
1029     TCGv src1;
1030     TCGv src2;
1031     TCGv tmp;
1032     TCGv addr;
1033     TCGv dest;
1034
1035     if ((insn & 0x38) != 0)
1036         opsize = OS_BYTE;
1037     else
1038         opsize = OS_LONG;
1039     op = (insn >> 6) & 3;
1040     SRC_EA(env, src1, opsize, 0, op ? &addr: NULL);
1041     src2 = DREG(insn, 9);
1042     dest = tcg_temp_new();
1043
1044     gen_flush_flags(s);
1045     tmp = tcg_temp_new();
1046     if (opsize == OS_BYTE)
1047         tcg_gen_andi_i32(tmp, src2, 7);
1048     else
1049         tcg_gen_andi_i32(tmp, src2, 31);
1050     src2 = tmp;
1051     tmp = tcg_temp_new();
1052     tcg_gen_shr_i32(tmp, src1, src2);
1053     tcg_gen_andi_i32(tmp, tmp, 1);
1054     tcg_gen_shli_i32(tmp, tmp, 2);
1055     /* Clear CCF_Z if bit set.  */
1056     tcg_gen_ori_i32(QREG_CC_DEST, QREG_CC_DEST, CCF_Z);
1057     tcg_gen_xor_i32(QREG_CC_DEST, QREG_CC_DEST, tmp);
1058
1059     tcg_gen_shl_i32(tmp, tcg_const_i32(1), src2);
1060     switch (op) {
1061     case 1: /* bchg */
1062         tcg_gen_xor_i32(dest, src1, tmp);
1063         break;
1064     case 2: /* bclr */
1065         tcg_gen_not_i32(tmp, tmp);
1066         tcg_gen_and_i32(dest, src1, tmp);
1067         break;
1068     case 3: /* bset */
1069         tcg_gen_or_i32(dest, src1, tmp);
1070         break;
1071     default: /* btst */
1072         break;
1073     }
1074     if (op)
1075         DEST_EA(env, insn, opsize, dest, &addr);
1076 }
1077
1078 DISAS_INSN(sats)
1079 {
1080     TCGv reg;
1081     reg = DREG(insn, 0);
1082     gen_flush_flags(s);
1083     gen_helper_sats(reg, reg, QREG_CC_DEST);
1084     gen_logic_cc(s, reg);
1085 }
1086
1087 static void gen_push(DisasContext *s, TCGv val)
1088 {
1089     TCGv tmp;
1090
1091     tmp = tcg_temp_new();
1092     tcg_gen_subi_i32(tmp, QREG_SP, 4);
1093     gen_store(s, OS_LONG, tmp, val);
1094     tcg_gen_mov_i32(QREG_SP, tmp);
1095 }
1096
1097 DISAS_INSN(movem)
1098 {
1099     TCGv addr;
1100     int i;
1101     uint16_t mask;
1102     TCGv reg;
1103     TCGv tmp;
1104     int is_load;
1105
1106     mask = cpu_lduw_code(env, s->pc);
1107     s->pc += 2;
1108     tmp = gen_lea(env, s, insn, OS_LONG);
1109     if (IS_NULL_QREG(tmp)) {
1110         gen_addr_fault(s);
1111         return;
1112     }
1113     addr = tcg_temp_new();
1114     tcg_gen_mov_i32(addr, tmp);
1115     is_load = ((insn & 0x0400) != 0);
1116     for (i = 0; i < 16; i++, mask >>= 1) {
1117         if (mask & 1) {
1118             if (i < 8)
1119                 reg = DREG(i, 0);
1120             else
1121                 reg = AREG(i, 0);
1122             if (is_load) {
1123                 tmp = gen_load(s, OS_LONG, addr, 0);
1124                 tcg_gen_mov_i32(reg, tmp);
1125             } else {
1126                 gen_store(s, OS_LONG, addr, reg);
1127             }
1128             if (mask != 1)
1129                 tcg_gen_addi_i32(addr, addr, 4);
1130         }
1131     }
1132 }
1133
1134 DISAS_INSN(bitop_im)
1135 {
1136     int opsize;
1137     int op;
1138     TCGv src1;
1139     uint32_t mask;
1140     int bitnum;
1141     TCGv tmp;
1142     TCGv addr;
1143
1144     if ((insn & 0x38) != 0)
1145         opsize = OS_BYTE;
1146     else
1147         opsize = OS_LONG;
1148     op = (insn >> 6) & 3;
1149
1150     bitnum = cpu_lduw_code(env, s->pc);
1151     s->pc += 2;
1152     if (bitnum & 0xff00) {
1153         disas_undef(env, s, insn);
1154         return;
1155     }
1156
1157     SRC_EA(env, src1, opsize, 0, op ? &addr: NULL);
1158
1159     gen_flush_flags(s);
1160     if (opsize == OS_BYTE)
1161         bitnum &= 7;
1162     else
1163         bitnum &= 31;
1164     mask = 1 << bitnum;
1165
1166     tmp = tcg_temp_new();
1167     assert (CCF_Z == (1 << 2));
1168     if (bitnum > 2)
1169         tcg_gen_shri_i32(tmp, src1, bitnum - 2);
1170     else if (bitnum < 2)
1171         tcg_gen_shli_i32(tmp, src1, 2 - bitnum);
1172     else
1173         tcg_gen_mov_i32(tmp, src1);
1174     tcg_gen_andi_i32(tmp, tmp, CCF_Z);
1175     /* Clear CCF_Z if bit set.  */
1176     tcg_gen_ori_i32(QREG_CC_DEST, QREG_CC_DEST, CCF_Z);
1177     tcg_gen_xor_i32(QREG_CC_DEST, QREG_CC_DEST, tmp);
1178     if (op) {
1179         switch (op) {
1180         case 1: /* bchg */
1181             tcg_gen_xori_i32(tmp, src1, mask);
1182             break;
1183         case 2: /* bclr */
1184             tcg_gen_andi_i32(tmp, src1, ~mask);
1185             break;
1186         case 3: /* bset */
1187             tcg_gen_ori_i32(tmp, src1, mask);
1188             break;
1189         default: /* btst */
1190             break;
1191         }
1192         DEST_EA(env, insn, opsize, tmp, &addr);
1193     }
1194 }
1195
1196 DISAS_INSN(arith_im)
1197 {
1198     int op;
1199     uint32_t im;
1200     TCGv src1;
1201     TCGv dest;
1202     TCGv addr;
1203
1204     op = (insn >> 9) & 7;
1205     SRC_EA(env, src1, OS_LONG, 0, (op == 6) ? NULL : &addr);
1206     im = read_im32(env, s);
1207     dest = tcg_temp_new();
1208     switch (op) {
1209     case 0: /* ori */
1210         tcg_gen_ori_i32(dest, src1, im);
1211         gen_logic_cc(s, dest);
1212         break;
1213     case 1: /* andi */
1214         tcg_gen_andi_i32(dest, src1, im);
1215         gen_logic_cc(s, dest);
1216         break;
1217     case 2: /* subi */
1218         tcg_gen_mov_i32(dest, src1);
1219         gen_helper_xflag_lt(QREG_CC_X, dest, tcg_const_i32(im));
1220         tcg_gen_subi_i32(dest, dest, im);
1221         gen_update_cc_add(dest, tcg_const_i32(im));
1222         s->cc_op = CC_OP_SUB;
1223         break;
1224     case 3: /* addi */
1225         tcg_gen_mov_i32(dest, src1);
1226         tcg_gen_addi_i32(dest, dest, im);
1227         gen_update_cc_add(dest, tcg_const_i32(im));
1228         gen_helper_xflag_lt(QREG_CC_X, dest, tcg_const_i32(im));
1229         s->cc_op = CC_OP_ADD;
1230         break;
1231     case 5: /* eori */
1232         tcg_gen_xori_i32(dest, src1, im);
1233         gen_logic_cc(s, dest);
1234         break;
1235     case 6: /* cmpi */
1236         tcg_gen_mov_i32(dest, src1);
1237         tcg_gen_subi_i32(dest, dest, im);
1238         gen_update_cc_add(dest, tcg_const_i32(im));
1239         s->cc_op = CC_OP_SUB;
1240         break;
1241     default:
1242         abort();
1243     }
1244     if (op != 6) {
1245         DEST_EA(env, insn, OS_LONG, dest, &addr);
1246     }
1247 }
1248
1249 DISAS_INSN(byterev)
1250 {
1251     TCGv reg;
1252
1253     reg = DREG(insn, 0);
1254     tcg_gen_bswap32_i32(reg, reg);
1255 }
1256
1257 DISAS_INSN(move)
1258 {
1259     TCGv src;
1260     TCGv dest;
1261     int op;
1262     int opsize;
1263
1264     switch (insn >> 12) {
1265     case 1: /* move.b */
1266         opsize = OS_BYTE;
1267         break;
1268     case 2: /* move.l */
1269         opsize = OS_LONG;
1270         break;
1271     case 3: /* move.w */
1272         opsize = OS_WORD;
1273         break;
1274     default:
1275         abort();
1276     }
1277     SRC_EA(env, src, opsize, 1, NULL);
1278     op = (insn >> 6) & 7;
1279     if (op == 1) {
1280         /* movea */
1281         /* The value will already have been sign extended.  */
1282         dest = AREG(insn, 9);
1283         tcg_gen_mov_i32(dest, src);
1284     } else {
1285         /* normal move */
1286         uint16_t dest_ea;
1287         dest_ea = ((insn >> 9) & 7) | (op << 3);
1288         DEST_EA(env, dest_ea, opsize, src, NULL);
1289         /* This will be correct because loads sign extend.  */
1290         gen_logic_cc(s, src);
1291     }
1292 }
1293
1294 DISAS_INSN(negx)
1295 {
1296     TCGv reg;
1297
1298     gen_flush_flags(s);
1299     reg = DREG(insn, 0);
1300     gen_helper_subx_cc(reg, cpu_env, tcg_const_i32(0), reg);
1301 }
1302
1303 DISAS_INSN(lea)
1304 {
1305     TCGv reg;
1306     TCGv tmp;
1307
1308     reg = AREG(insn, 9);
1309     tmp = gen_lea(env, s, insn, OS_LONG);
1310     if (IS_NULL_QREG(tmp)) {
1311         gen_addr_fault(s);
1312         return;
1313     }
1314     tcg_gen_mov_i32(reg, tmp);
1315 }
1316
1317 DISAS_INSN(clr)
1318 {
1319     int opsize;
1320
1321     switch ((insn >> 6) & 3) {
1322     case 0: /* clr.b */
1323         opsize = OS_BYTE;
1324         break;
1325     case 1: /* clr.w */
1326         opsize = OS_WORD;
1327         break;
1328     case 2: /* clr.l */
1329         opsize = OS_LONG;
1330         break;
1331     default:
1332         abort();
1333     }
1334     DEST_EA(env, insn, opsize, tcg_const_i32(0), NULL);
1335     gen_logic_cc(s, tcg_const_i32(0));
1336 }
1337
1338 static TCGv gen_get_ccr(DisasContext *s)
1339 {
1340     TCGv dest;
1341
1342     gen_flush_flags(s);
1343     dest = tcg_temp_new();
1344     tcg_gen_shli_i32(dest, QREG_CC_X, 4);
1345     tcg_gen_or_i32(dest, dest, QREG_CC_DEST);
1346     return dest;
1347 }
1348
1349 DISAS_INSN(move_from_ccr)
1350 {
1351     TCGv reg;
1352     TCGv ccr;
1353
1354     ccr = gen_get_ccr(s);
1355     reg = DREG(insn, 0);
1356     gen_partset_reg(OS_WORD, reg, ccr);
1357 }
1358
1359 DISAS_INSN(neg)
1360 {
1361     TCGv reg;
1362     TCGv src1;
1363
1364     reg = DREG(insn, 0);
1365     src1 = tcg_temp_new();
1366     tcg_gen_mov_i32(src1, reg);
1367     tcg_gen_neg_i32(reg, src1);
1368     s->cc_op = CC_OP_SUB;
1369     gen_update_cc_add(reg, src1);
1370     gen_helper_xflag_lt(QREG_CC_X, tcg_const_i32(0), src1);
1371     s->cc_op = CC_OP_SUB;
1372 }
1373
1374 static void gen_set_sr_im(DisasContext *s, uint16_t val, int ccr_only)
1375 {
1376     tcg_gen_movi_i32(QREG_CC_DEST, val & 0xf);
1377     tcg_gen_movi_i32(QREG_CC_X, (val & 0x10) >> 4);
1378     if (!ccr_only) {
1379         gen_helper_set_sr(cpu_env, tcg_const_i32(val & 0xff00));
1380     }
1381 }
1382
1383 static void gen_set_sr(CPUM68KState *env, DisasContext *s, uint16_t insn,
1384                        int ccr_only)
1385 {
1386     TCGv tmp;
1387     TCGv reg;
1388
1389     s->cc_op = CC_OP_FLAGS;
1390     if ((insn & 0x38) == 0)
1391       {
1392         tmp = tcg_temp_new();
1393         reg = DREG(insn, 0);
1394         tcg_gen_andi_i32(QREG_CC_DEST, reg, 0xf);
1395         tcg_gen_shri_i32(tmp, reg, 4);
1396         tcg_gen_andi_i32(QREG_CC_X, tmp, 1);
1397         if (!ccr_only) {
1398             gen_helper_set_sr(cpu_env, reg);
1399         }
1400       }
1401     else if ((insn & 0x3f) == 0x3c)
1402       {
1403         uint16_t val;
1404         val = cpu_lduw_code(env, s->pc);
1405         s->pc += 2;
1406         gen_set_sr_im(s, val, ccr_only);
1407       }
1408     else
1409         disas_undef(env, s, insn);
1410 }
1411
1412 DISAS_INSN(move_to_ccr)
1413 {
1414     gen_set_sr(env, s, insn, 1);
1415 }
1416
1417 DISAS_INSN(not)
1418 {
1419     TCGv reg;
1420
1421     reg = DREG(insn, 0);
1422     tcg_gen_not_i32(reg, reg);
1423     gen_logic_cc(s, reg);
1424 }
1425
1426 DISAS_INSN(swap)
1427 {
1428     TCGv src1;
1429     TCGv src2;
1430     TCGv reg;
1431
1432     src1 = tcg_temp_new();
1433     src2 = tcg_temp_new();
1434     reg = DREG(insn, 0);
1435     tcg_gen_shli_i32(src1, reg, 16);
1436     tcg_gen_shri_i32(src2, reg, 16);
1437     tcg_gen_or_i32(reg, src1, src2);
1438     gen_logic_cc(s, reg);
1439 }
1440
1441 DISAS_INSN(pea)
1442 {
1443     TCGv tmp;
1444
1445     tmp = gen_lea(env, s, insn, OS_LONG);
1446     if (IS_NULL_QREG(tmp)) {
1447         gen_addr_fault(s);
1448         return;
1449     }
1450     gen_push(s, tmp);
1451 }
1452
1453 DISAS_INSN(ext)
1454 {
1455     int op;
1456     TCGv reg;
1457     TCGv tmp;
1458
1459     reg = DREG(insn, 0);
1460     op = (insn >> 6) & 7;
1461     tmp = tcg_temp_new();
1462     if (op == 3)
1463         tcg_gen_ext16s_i32(tmp, reg);
1464     else
1465         tcg_gen_ext8s_i32(tmp, reg);
1466     if (op == 2)
1467         gen_partset_reg(OS_WORD, reg, tmp);
1468     else
1469         tcg_gen_mov_i32(reg, tmp);
1470     gen_logic_cc(s, tmp);
1471 }
1472
1473 DISAS_INSN(tst)
1474 {
1475     int opsize;
1476     TCGv tmp;
1477
1478     switch ((insn >> 6) & 3) {
1479     case 0: /* tst.b */
1480         opsize = OS_BYTE;
1481         break;
1482     case 1: /* tst.w */
1483         opsize = OS_WORD;
1484         break;
1485     case 2: /* tst.l */
1486         opsize = OS_LONG;
1487         break;
1488     default:
1489         abort();
1490     }
1491     SRC_EA(env, tmp, opsize, 1, NULL);
1492     gen_logic_cc(s, tmp);
1493 }
1494
1495 DISAS_INSN(pulse)
1496 {
1497   /* Implemented as a NOP.  */
1498 }
1499
1500 DISAS_INSN(illegal)
1501 {
1502     gen_exception(s, s->pc - 2, EXCP_ILLEGAL);
1503 }
1504
1505 /* ??? This should be atomic.  */
1506 DISAS_INSN(tas)
1507 {
1508     TCGv dest;
1509     TCGv src1;
1510     TCGv addr;
1511
1512     dest = tcg_temp_new();
1513     SRC_EA(env, src1, OS_BYTE, 1, &addr);
1514     gen_logic_cc(s, src1);
1515     tcg_gen_ori_i32(dest, src1, 0x80);
1516     DEST_EA(env, insn, OS_BYTE, dest, &addr);
1517 }
1518
1519 DISAS_INSN(mull)
1520 {
1521     uint16_t ext;
1522     TCGv reg;
1523     TCGv src1;
1524     TCGv dest;
1525
1526     /* The upper 32 bits of the product are discarded, so
1527        muls.l and mulu.l are functionally equivalent.  */
1528     ext = cpu_lduw_code(env, s->pc);
1529     s->pc += 2;
1530     if (ext & 0x87ff) {
1531         gen_exception(s, s->pc - 4, EXCP_UNSUPPORTED);
1532         return;
1533     }
1534     reg = DREG(ext, 12);
1535     SRC_EA(env, src1, OS_LONG, 0, NULL);
1536     dest = tcg_temp_new();
1537     tcg_gen_mul_i32(dest, src1, reg);
1538     tcg_gen_mov_i32(reg, dest);
1539     /* Unlike m68k, coldfire always clears the overflow bit.  */
1540     gen_logic_cc(s, dest);
1541 }
1542
1543 DISAS_INSN(link)
1544 {
1545     int16_t offset;
1546     TCGv reg;
1547     TCGv tmp;
1548
1549     offset = cpu_ldsw_code(env, s->pc);
1550     s->pc += 2;
1551     reg = AREG(insn, 0);
1552     tmp = tcg_temp_new();
1553     tcg_gen_subi_i32(tmp, QREG_SP, 4);
1554     gen_store(s, OS_LONG, tmp, reg);
1555     if ((insn & 7) != 7)
1556         tcg_gen_mov_i32(reg, tmp);
1557     tcg_gen_addi_i32(QREG_SP, tmp, offset);
1558 }
1559
1560 DISAS_INSN(unlk)
1561 {
1562     TCGv src;
1563     TCGv reg;
1564     TCGv tmp;
1565
1566     src = tcg_temp_new();
1567     reg = AREG(insn, 0);
1568     tcg_gen_mov_i32(src, reg);
1569     tmp = gen_load(s, OS_LONG, src, 0);
1570     tcg_gen_mov_i32(reg, tmp);
1571     tcg_gen_addi_i32(QREG_SP, src, 4);
1572 }
1573
1574 DISAS_INSN(nop)
1575 {
1576 }
1577
1578 DISAS_INSN(rts)
1579 {
1580     TCGv tmp;
1581
1582     tmp = gen_load(s, OS_LONG, QREG_SP, 0);
1583     tcg_gen_addi_i32(QREG_SP, QREG_SP, 4);
1584     gen_jmp(s, tmp);
1585 }
1586
1587 DISAS_INSN(jump)
1588 {
1589     TCGv tmp;
1590
1591     /* Load the target address first to ensure correct exception
1592        behavior.  */
1593     tmp = gen_lea(env, s, insn, OS_LONG);
1594     if (IS_NULL_QREG(tmp)) {
1595         gen_addr_fault(s);
1596         return;
1597     }
1598     if ((insn & 0x40) == 0) {
1599         /* jsr */
1600         gen_push(s, tcg_const_i32(s->pc));
1601     }
1602     gen_jmp(s, tmp);
1603 }
1604
1605 DISAS_INSN(addsubq)
1606 {
1607     TCGv src1;
1608     TCGv src2;
1609     TCGv dest;
1610     int val;
1611     TCGv addr;
1612
1613     SRC_EA(env, src1, OS_LONG, 0, &addr);
1614     val = (insn >> 9) & 7;
1615     if (val == 0)
1616         val = 8;
1617     dest = tcg_temp_new();
1618     tcg_gen_mov_i32(dest, src1);
1619     if ((insn & 0x38) == 0x08) {
1620         /* Don't update condition codes if the destination is an
1621            address register.  */
1622         if (insn & 0x0100) {
1623             tcg_gen_subi_i32(dest, dest, val);
1624         } else {
1625             tcg_gen_addi_i32(dest, dest, val);
1626         }
1627     } else {
1628         src2 = tcg_const_i32(val);
1629         if (insn & 0x0100) {
1630             gen_helper_xflag_lt(QREG_CC_X, dest, src2);
1631             tcg_gen_subi_i32(dest, dest, val);
1632             s->cc_op = CC_OP_SUB;
1633         } else {
1634             tcg_gen_addi_i32(dest, dest, val);
1635             gen_helper_xflag_lt(QREG_CC_X, dest, src2);
1636             s->cc_op = CC_OP_ADD;
1637         }
1638         gen_update_cc_add(dest, src2);
1639     }
1640     DEST_EA(env, insn, OS_LONG, dest, &addr);
1641 }
1642
1643 DISAS_INSN(tpf)
1644 {
1645     switch (insn & 7) {
1646     case 2: /* One extension word.  */
1647         s->pc += 2;
1648         break;
1649     case 3: /* Two extension words.  */
1650         s->pc += 4;
1651         break;
1652     case 4: /* No extension words.  */
1653         break;
1654     default:
1655         disas_undef(env, s, insn);
1656     }
1657 }
1658
1659 DISAS_INSN(branch)
1660 {
1661     int32_t offset;
1662     uint32_t base;
1663     int op;
1664     int l1;
1665
1666     base = s->pc;
1667     op = (insn >> 8) & 0xf;
1668     offset = (int8_t)insn;
1669     if (offset == 0) {
1670         offset = cpu_ldsw_code(env, s->pc);
1671         s->pc += 2;
1672     } else if (offset == -1) {
1673         offset = read_im32(env, s);
1674     }
1675     if (op == 1) {
1676         /* bsr */
1677         gen_push(s, tcg_const_i32(s->pc));
1678     }
1679     gen_flush_cc_op(s);
1680     if (op > 1) {
1681         /* Bcc */
1682         l1 = gen_new_label();
1683         gen_jmpcc(s, ((insn >> 8) & 0xf) ^ 1, l1);
1684         gen_jmp_tb(s, 1, base + offset);
1685         gen_set_label(l1);
1686         gen_jmp_tb(s, 0, s->pc);
1687     } else {
1688         /* Unconditional branch.  */
1689         gen_jmp_tb(s, 0, base + offset);
1690     }
1691 }
1692
1693 DISAS_INSN(moveq)
1694 {
1695     uint32_t val;
1696
1697     val = (int8_t)insn;
1698     tcg_gen_movi_i32(DREG(insn, 9), val);
1699     gen_logic_cc(s, tcg_const_i32(val));
1700 }
1701
1702 DISAS_INSN(mvzs)
1703 {
1704     int opsize;
1705     TCGv src;
1706     TCGv reg;
1707
1708     if (insn & 0x40)
1709         opsize = OS_WORD;
1710     else
1711         opsize = OS_BYTE;
1712     SRC_EA(env, src, opsize, (insn & 0x80) == 0, NULL);
1713     reg = DREG(insn, 9);
1714     tcg_gen_mov_i32(reg, src);
1715     gen_logic_cc(s, src);
1716 }
1717
1718 DISAS_INSN(or)
1719 {
1720     TCGv reg;
1721     TCGv dest;
1722     TCGv src;
1723     TCGv addr;
1724
1725     reg = DREG(insn, 9);
1726     dest = tcg_temp_new();
1727     if (insn & 0x100) {
1728         SRC_EA(env, src, OS_LONG, 0, &addr);
1729         tcg_gen_or_i32(dest, src, reg);
1730         DEST_EA(env, insn, OS_LONG, dest, &addr);
1731     } else {
1732         SRC_EA(env, src, OS_LONG, 0, NULL);
1733         tcg_gen_or_i32(dest, src, reg);
1734         tcg_gen_mov_i32(reg, dest);
1735     }
1736     gen_logic_cc(s, dest);
1737 }
1738
1739 DISAS_INSN(suba)
1740 {
1741     TCGv src;
1742     TCGv reg;
1743
1744     SRC_EA(env, src, OS_LONG, 0, NULL);
1745     reg = AREG(insn, 9);
1746     tcg_gen_sub_i32(reg, reg, src);
1747 }
1748
1749 DISAS_INSN(subx)
1750 {
1751     TCGv reg;
1752     TCGv src;
1753
1754     gen_flush_flags(s);
1755     reg = DREG(insn, 9);
1756     src = DREG(insn, 0);
1757     gen_helper_subx_cc(reg, cpu_env, reg, src);
1758 }
1759
1760 DISAS_INSN(mov3q)
1761 {
1762     TCGv src;
1763     int val;
1764
1765     val = (insn >> 9) & 7;
1766     if (val == 0)
1767         val = -1;
1768     src = tcg_const_i32(val);
1769     gen_logic_cc(s, src);
1770     DEST_EA(env, insn, OS_LONG, src, NULL);
1771 }
1772
1773 DISAS_INSN(cmp)
1774 {
1775     int op;
1776     TCGv src;
1777     TCGv reg;
1778     TCGv dest;
1779     int opsize;
1780
1781     op = (insn >> 6) & 3;
1782     switch (op) {
1783     case 0: /* cmp.b */
1784         opsize = OS_BYTE;
1785         s->cc_op = CC_OP_CMPB;
1786         break;
1787     case 1: /* cmp.w */
1788         opsize = OS_WORD;
1789         s->cc_op = CC_OP_CMPW;
1790         break;
1791     case 2: /* cmp.l */
1792         opsize = OS_LONG;
1793         s->cc_op = CC_OP_SUB;
1794         break;
1795     default:
1796         abort();
1797     }
1798     SRC_EA(env, src, opsize, 1, NULL);
1799     reg = DREG(insn, 9);
1800     dest = tcg_temp_new();
1801     tcg_gen_sub_i32(dest, reg, src);
1802     gen_update_cc_add(dest, src);
1803 }
1804
1805 DISAS_INSN(cmpa)
1806 {
1807     int opsize;
1808     TCGv src;
1809     TCGv reg;
1810     TCGv dest;
1811
1812     if (insn & 0x100) {
1813         opsize = OS_LONG;
1814     } else {
1815         opsize = OS_WORD;
1816     }
1817     SRC_EA(env, src, opsize, 1, NULL);
1818     reg = AREG(insn, 9);
1819     dest = tcg_temp_new();
1820     tcg_gen_sub_i32(dest, reg, src);
1821     gen_update_cc_add(dest, src);
1822     s->cc_op = CC_OP_SUB;
1823 }
1824
1825 DISAS_INSN(eor)
1826 {
1827     TCGv src;
1828     TCGv reg;
1829     TCGv dest;
1830     TCGv addr;
1831
1832     SRC_EA(env, src, OS_LONG, 0, &addr);
1833     reg = DREG(insn, 9);
1834     dest = tcg_temp_new();
1835     tcg_gen_xor_i32(dest, src, reg);
1836     gen_logic_cc(s, dest);
1837     DEST_EA(env, insn, OS_LONG, dest, &addr);
1838 }
1839
1840 DISAS_INSN(and)
1841 {
1842     TCGv src;
1843     TCGv reg;
1844     TCGv dest;
1845     TCGv addr;
1846
1847     reg = DREG(insn, 9);
1848     dest = tcg_temp_new();
1849     if (insn & 0x100) {
1850         SRC_EA(env, src, OS_LONG, 0, &addr);
1851         tcg_gen_and_i32(dest, src, reg);
1852         DEST_EA(env, insn, OS_LONG, dest, &addr);
1853     } else {
1854         SRC_EA(env, src, OS_LONG, 0, NULL);
1855         tcg_gen_and_i32(dest, src, reg);
1856         tcg_gen_mov_i32(reg, dest);
1857     }
1858     gen_logic_cc(s, dest);
1859 }
1860
1861 DISAS_INSN(adda)
1862 {
1863     TCGv src;
1864     TCGv reg;
1865
1866     SRC_EA(env, src, OS_LONG, 0, NULL);
1867     reg = AREG(insn, 9);
1868     tcg_gen_add_i32(reg, reg, src);
1869 }
1870
1871 DISAS_INSN(addx)
1872 {
1873     TCGv reg;
1874     TCGv src;
1875
1876     gen_flush_flags(s);
1877     reg = DREG(insn, 9);
1878     src = DREG(insn, 0);
1879     gen_helper_addx_cc(reg, cpu_env, reg, src);
1880     s->cc_op = CC_OP_FLAGS;
1881 }
1882
1883 /* TODO: This could be implemented without helper functions.  */
1884 DISAS_INSN(shift_im)
1885 {
1886     TCGv reg;
1887     int tmp;
1888     TCGv shift;
1889
1890     reg = DREG(insn, 0);
1891     tmp = (insn >> 9) & 7;
1892     if (tmp == 0)
1893         tmp = 8;
1894     shift = tcg_const_i32(tmp);
1895     /* No need to flush flags becuse we know we will set C flag.  */
1896     if (insn & 0x100) {
1897         gen_helper_shl_cc(reg, cpu_env, reg, shift);
1898     } else {
1899         if (insn & 8) {
1900             gen_helper_shr_cc(reg, cpu_env, reg, shift);
1901         } else {
1902             gen_helper_sar_cc(reg, cpu_env, reg, shift);
1903         }
1904     }
1905     s->cc_op = CC_OP_SHIFT;
1906 }
1907
1908 DISAS_INSN(shift_reg)
1909 {
1910     TCGv reg;
1911     TCGv shift;
1912
1913     reg = DREG(insn, 0);
1914     shift = DREG(insn, 9);
1915     /* Shift by zero leaves C flag unmodified.   */
1916     gen_flush_flags(s);
1917     if (insn & 0x100) {
1918         gen_helper_shl_cc(reg, cpu_env, reg, shift);
1919     } else {
1920         if (insn & 8) {
1921             gen_helper_shr_cc(reg, cpu_env, reg, shift);
1922         } else {
1923             gen_helper_sar_cc(reg, cpu_env, reg, shift);
1924         }
1925     }
1926     s->cc_op = CC_OP_SHIFT;
1927 }
1928
1929 DISAS_INSN(ff1)
1930 {
1931     TCGv reg;
1932     reg = DREG(insn, 0);
1933     gen_logic_cc(s, reg);
1934     gen_helper_ff1(reg, reg);
1935 }
1936
1937 static TCGv gen_get_sr(DisasContext *s)
1938 {
1939     TCGv ccr;
1940     TCGv sr;
1941
1942     ccr = gen_get_ccr(s);
1943     sr = tcg_temp_new();
1944     tcg_gen_andi_i32(sr, QREG_SR, 0xffe0);
1945     tcg_gen_or_i32(sr, sr, ccr);
1946     return sr;
1947 }
1948
1949 DISAS_INSN(strldsr)
1950 {
1951     uint16_t ext;
1952     uint32_t addr;
1953
1954     addr = s->pc - 2;
1955     ext = cpu_lduw_code(env, s->pc);
1956     s->pc += 2;
1957     if (ext != 0x46FC) {
1958         gen_exception(s, addr, EXCP_UNSUPPORTED);
1959         return;
1960     }
1961     ext = cpu_lduw_code(env, s->pc);
1962     s->pc += 2;
1963     if (IS_USER(s) || (ext & SR_S) == 0) {
1964         gen_exception(s, addr, EXCP_PRIVILEGE);
1965         return;
1966     }
1967     gen_push(s, gen_get_sr(s));
1968     gen_set_sr_im(s, ext, 0);
1969 }
1970
1971 DISAS_INSN(move_from_sr)
1972 {
1973     TCGv reg;
1974     TCGv sr;
1975
1976     if (IS_USER(s)) {
1977         gen_exception(s, s->pc - 2, EXCP_PRIVILEGE);
1978         return;
1979     }
1980     sr = gen_get_sr(s);
1981     reg = DREG(insn, 0);
1982     gen_partset_reg(OS_WORD, reg, sr);
1983 }
1984
1985 DISAS_INSN(move_to_sr)
1986 {
1987     if (IS_USER(s)) {
1988         gen_exception(s, s->pc - 2, EXCP_PRIVILEGE);
1989         return;
1990     }
1991     gen_set_sr(env, s, insn, 0);
1992     gen_lookup_tb(s);
1993 }
1994
1995 DISAS_INSN(move_from_usp)
1996 {
1997     if (IS_USER(s)) {
1998         gen_exception(s, s->pc - 2, EXCP_PRIVILEGE);
1999         return;
2000     }
2001     /* TODO: Implement USP.  */
2002     gen_exception(s, s->pc - 2, EXCP_ILLEGAL);
2003 }
2004
2005 DISAS_INSN(move_to_usp)
2006 {
2007     if (IS_USER(s)) {
2008         gen_exception(s, s->pc - 2, EXCP_PRIVILEGE);
2009         return;
2010     }
2011     /* TODO: Implement USP.  */
2012     gen_exception(s, s->pc - 2, EXCP_ILLEGAL);
2013 }
2014
2015 DISAS_INSN(halt)
2016 {
2017     gen_exception(s, s->pc, EXCP_HALT_INSN);
2018 }
2019
2020 DISAS_INSN(stop)
2021 {
2022     uint16_t ext;
2023
2024     if (IS_USER(s)) {
2025         gen_exception(s, s->pc - 2, EXCP_PRIVILEGE);
2026         return;
2027     }
2028
2029     ext = cpu_lduw_code(env, s->pc);
2030     s->pc += 2;
2031
2032     gen_set_sr_im(s, ext, 0);
2033     tcg_gen_movi_i32(cpu_halted, 1);
2034     gen_exception(s, s->pc, EXCP_HLT);
2035 }
2036
2037 DISAS_INSN(rte)
2038 {
2039     if (IS_USER(s)) {
2040         gen_exception(s, s->pc - 2, EXCP_PRIVILEGE);
2041         return;
2042     }
2043     gen_exception(s, s->pc - 2, EXCP_RTE);
2044 }
2045
2046 DISAS_INSN(movec)
2047 {
2048     uint16_t ext;
2049     TCGv reg;
2050
2051     if (IS_USER(s)) {
2052         gen_exception(s, s->pc - 2, EXCP_PRIVILEGE);
2053         return;
2054     }
2055
2056     ext = cpu_lduw_code(env, s->pc);
2057     s->pc += 2;
2058
2059     if (ext & 0x8000) {
2060         reg = AREG(ext, 12);
2061     } else {
2062         reg = DREG(ext, 12);
2063     }
2064     gen_helper_movec(cpu_env, tcg_const_i32(ext & 0xfff), reg);
2065     gen_lookup_tb(s);
2066 }
2067
2068 DISAS_INSN(intouch)
2069 {
2070     if (IS_USER(s)) {
2071         gen_exception(s, s->pc - 2, EXCP_PRIVILEGE);
2072         return;
2073     }
2074     /* ICache fetch.  Implement as no-op.  */
2075 }
2076
2077 DISAS_INSN(cpushl)
2078 {
2079     if (IS_USER(s)) {
2080         gen_exception(s, s->pc - 2, EXCP_PRIVILEGE);
2081         return;
2082     }
2083     /* Cache push/invalidate.  Implement as no-op.  */
2084 }
2085
2086 DISAS_INSN(wddata)
2087 {
2088     gen_exception(s, s->pc - 2, EXCP_PRIVILEGE);
2089 }
2090
2091 DISAS_INSN(wdebug)
2092 {
2093     if (IS_USER(s)) {
2094         gen_exception(s, s->pc - 2, EXCP_PRIVILEGE);
2095         return;
2096     }
2097     /* TODO: Implement wdebug.  */
2098     qemu_assert(0, "WDEBUG not implemented");
2099 }
2100
2101 DISAS_INSN(trap)
2102 {
2103     gen_exception(s, s->pc - 2, EXCP_TRAP0 + (insn & 0xf));
2104 }
2105
2106 /* ??? FP exceptions are not implemented.  Most exceptions are deferred until
2107    immediately before the next FP instruction is executed.  */
2108 DISAS_INSN(fpu)
2109 {
2110     uint16_t ext;
2111     int32_t offset;
2112     int opmode;
2113     TCGv_i64 src;
2114     TCGv_i64 dest;
2115     TCGv_i64 res;
2116     TCGv tmp32;
2117     int round;
2118     int set_dest;
2119     int opsize;
2120
2121     ext = cpu_lduw_code(env, s->pc);
2122     s->pc += 2;
2123     opmode = ext & 0x7f;
2124     switch ((ext >> 13) & 7) {
2125     case 0: case 2:
2126         break;
2127     case 1:
2128         goto undef;
2129     case 3: /* fmove out */
2130         src = FREG(ext, 7);
2131         tmp32 = tcg_temp_new_i32();
2132         /* fmove */
2133         /* ??? TODO: Proper behavior on overflow.  */
2134         switch ((ext >> 10) & 7) {
2135         case 0:
2136             opsize = OS_LONG;
2137             gen_helper_f64_to_i32(tmp32, cpu_env, src);
2138             break;
2139         case 1:
2140             opsize = OS_SINGLE;
2141             gen_helper_f64_to_f32(tmp32, cpu_env, src);
2142             break;
2143         case 4:
2144             opsize = OS_WORD;
2145             gen_helper_f64_to_i32(tmp32, cpu_env, src);
2146             break;
2147         case 5: /* OS_DOUBLE */
2148             tcg_gen_mov_i32(tmp32, AREG(insn, 0));
2149             switch ((insn >> 3) & 7) {
2150             case 2:
2151             case 3:
2152                 break;
2153             case 4:
2154                 tcg_gen_addi_i32(tmp32, tmp32, -8);
2155                 break;
2156             case 5:
2157                 offset = cpu_ldsw_code(env, s->pc);
2158                 s->pc += 2;
2159                 tcg_gen_addi_i32(tmp32, tmp32, offset);
2160                 break;
2161             default:
2162                 goto undef;
2163             }
2164             gen_store64(s, tmp32, src);
2165             switch ((insn >> 3) & 7) {
2166             case 3:
2167                 tcg_gen_addi_i32(tmp32, tmp32, 8);
2168                 tcg_gen_mov_i32(AREG(insn, 0), tmp32);
2169                 break;
2170             case 4:
2171                 tcg_gen_mov_i32(AREG(insn, 0), tmp32);
2172                 break;
2173             }
2174             tcg_temp_free_i32(tmp32);
2175             return;
2176         case 6:
2177             opsize = OS_BYTE;
2178             gen_helper_f64_to_i32(tmp32, cpu_env, src);
2179             break;
2180         default:
2181             goto undef;
2182         }
2183         DEST_EA(env, insn, opsize, tmp32, NULL);
2184         tcg_temp_free_i32(tmp32);
2185         return;
2186     case 4: /* fmove to control register.  */
2187         switch ((ext >> 10) & 7) {
2188         case 4: /* FPCR */
2189             /* Not implemented.  Ignore writes.  */
2190             break;
2191         case 1: /* FPIAR */
2192         case 2: /* FPSR */
2193         default:
2194             cpu_abort(NULL, "Unimplemented: fmove to control %d",
2195                       (ext >> 10) & 7);
2196         }
2197         break;
2198     case 5: /* fmove from control register.  */
2199         switch ((ext >> 10) & 7) {
2200         case 4: /* FPCR */
2201             /* Not implemented.  Always return zero.  */
2202             tmp32 = tcg_const_i32(0);
2203             break;
2204         case 1: /* FPIAR */
2205         case 2: /* FPSR */
2206         default:
2207             cpu_abort(NULL, "Unimplemented: fmove from control %d",
2208                       (ext >> 10) & 7);
2209             goto undef;
2210         }
2211         DEST_EA(env, insn, OS_LONG, tmp32, NULL);
2212         break;
2213     case 6: /* fmovem */
2214     case 7:
2215         {
2216             TCGv addr;
2217             uint16_t mask;
2218             int i;
2219             if ((ext & 0x1f00) != 0x1000 || (ext & 0xff) == 0)
2220                 goto undef;
2221             tmp32 = gen_lea(env, s, insn, OS_LONG);
2222             if (IS_NULL_QREG(tmp32)) {
2223                 gen_addr_fault(s);
2224                 return;
2225             }
2226             addr = tcg_temp_new_i32();
2227             tcg_gen_mov_i32(addr, tmp32);
2228             mask = 0x80;
2229             for (i = 0; i < 8; i++) {
2230                 if (ext & mask) {
2231                     s->is_mem = 1;
2232                     dest = FREG(i, 0);
2233                     if (ext & (1 << 13)) {
2234                         /* store */
2235                         tcg_gen_qemu_stf64(dest, addr, IS_USER(s));
2236                     } else {
2237                         /* load */
2238                         tcg_gen_qemu_ldf64(dest, addr, IS_USER(s));
2239                     }
2240                     if (ext & (mask - 1))
2241                         tcg_gen_addi_i32(addr, addr, 8);
2242                 }
2243                 mask >>= 1;
2244             }
2245             tcg_temp_free_i32(addr);
2246         }
2247         return;
2248     }
2249     if (ext & (1 << 14)) {
2250         /* Source effective address.  */
2251         switch ((ext >> 10) & 7) {
2252         case 0: opsize = OS_LONG; break;
2253         case 1: opsize = OS_SINGLE; break;
2254         case 4: opsize = OS_WORD; break;
2255         case 5: opsize = OS_DOUBLE; break;
2256         case 6: opsize = OS_BYTE; break;
2257         default:
2258             goto undef;
2259         }
2260         if (opsize == OS_DOUBLE) {
2261             tmp32 = tcg_temp_new_i32();
2262             tcg_gen_mov_i32(tmp32, AREG(insn, 0));
2263             switch ((insn >> 3) & 7) {
2264             case 2:
2265             case 3:
2266                 break;
2267             case 4:
2268                 tcg_gen_addi_i32(tmp32, tmp32, -8);
2269                 break;
2270             case 5:
2271                 offset = cpu_ldsw_code(env, s->pc);
2272                 s->pc += 2;
2273                 tcg_gen_addi_i32(tmp32, tmp32, offset);
2274                 break;
2275             case 7:
2276                 offset = cpu_ldsw_code(env, s->pc);
2277                 offset += s->pc - 2;
2278                 s->pc += 2;
2279                 tcg_gen_addi_i32(tmp32, tmp32, offset);
2280                 break;
2281             default:
2282                 goto undef;
2283             }
2284             src = gen_load64(s, tmp32);
2285             switch ((insn >> 3) & 7) {
2286             case 3:
2287                 tcg_gen_addi_i32(tmp32, tmp32, 8);
2288                 tcg_gen_mov_i32(AREG(insn, 0), tmp32);
2289                 break;
2290             case 4:
2291                 tcg_gen_mov_i32(AREG(insn, 0), tmp32);
2292                 break;
2293             }
2294             tcg_temp_free_i32(tmp32);
2295         } else {
2296             SRC_EA(env, tmp32, opsize, 1, NULL);
2297             src = tcg_temp_new_i64();
2298             switch (opsize) {
2299             case OS_LONG:
2300             case OS_WORD:
2301             case OS_BYTE:
2302                 gen_helper_i32_to_f64(src, cpu_env, tmp32);
2303                 break;
2304             case OS_SINGLE:
2305                 gen_helper_f32_to_f64(src, cpu_env, tmp32);
2306                 break;
2307             }
2308         }
2309     } else {
2310         /* Source register.  */
2311         src = FREG(ext, 10);
2312     }
2313     dest = FREG(ext, 7);
2314     res = tcg_temp_new_i64();
2315     if (opmode != 0x3a)
2316         tcg_gen_mov_f64(res, dest);
2317     round = 1;
2318     set_dest = 1;
2319     switch (opmode) {
2320     case 0: case 0x40: case 0x44: /* fmove */
2321         tcg_gen_mov_f64(res, src);
2322         break;
2323     case 1: /* fint */
2324         gen_helper_iround_f64(res, cpu_env, src);
2325         round = 0;
2326         break;
2327     case 3: /* fintrz */
2328         gen_helper_itrunc_f64(res, cpu_env, src);
2329         round = 0;
2330         break;
2331     case 4: case 0x41: case 0x45: /* fsqrt */
2332         gen_helper_sqrt_f64(res, cpu_env, src);
2333         break;
2334     case 0x18: case 0x58: case 0x5c: /* fabs */
2335         gen_helper_abs_f64(res, src);
2336         break;
2337     case 0x1a: case 0x5a: case 0x5e: /* fneg */
2338         gen_helper_chs_f64(res, src);
2339         break;
2340     case 0x20: case 0x60: case 0x64: /* fdiv */
2341         gen_helper_div_f64(res, cpu_env, res, src);
2342         break;
2343     case 0x22: case 0x62: case 0x66: /* fadd */
2344         gen_helper_add_f64(res, cpu_env, res, src);
2345         break;
2346     case 0x23: case 0x63: case 0x67: /* fmul */
2347         gen_helper_mul_f64(res, cpu_env, res, src);
2348         break;
2349     case 0x28: case 0x68: case 0x6c: /* fsub */
2350         gen_helper_sub_f64(res, cpu_env, res, src);
2351         break;
2352     case 0x38: /* fcmp */
2353         gen_helper_sub_cmp_f64(res, cpu_env, res, src);
2354         set_dest = 0;
2355         round = 0;
2356         break;
2357     case 0x3a: /* ftst */
2358         tcg_gen_mov_f64(res, src);
2359         set_dest = 0;
2360         round = 0;
2361         break;
2362     default:
2363         goto undef;
2364     }
2365     if (ext & (1 << 14)) {
2366         tcg_temp_free_i64(src);
2367     }
2368     if (round) {
2369         if (opmode & 0x40) {
2370             if ((opmode & 0x4) != 0)
2371                 round = 0;
2372         } else if ((s->fpcr & M68K_FPCR_PREC) == 0) {
2373             round = 0;
2374         }
2375     }
2376     if (round) {
2377         TCGv tmp = tcg_temp_new_i32();
2378         gen_helper_f64_to_f32(tmp, cpu_env, res);
2379         gen_helper_f32_to_f64(res, cpu_env, tmp);
2380         tcg_temp_free_i32(tmp);
2381     }
2382     tcg_gen_mov_f64(QREG_FP_RESULT, res);
2383     if (set_dest) {
2384         tcg_gen_mov_f64(dest, res);
2385     }
2386     tcg_temp_free_i64(res);
2387     return;
2388 undef:
2389     /* FIXME: Is this right for offset addressing modes?  */
2390     s->pc -= 2;
2391     disas_undef_fpu(env, s, insn);
2392 }
2393
2394 DISAS_INSN(fbcc)
2395 {
2396     uint32_t offset;
2397     uint32_t addr;
2398     TCGv flag;
2399     int l1;
2400
2401     addr = s->pc;
2402     offset = cpu_ldsw_code(env, s->pc);
2403     s->pc += 2;
2404     if (insn & (1 << 6)) {
2405         offset = (offset << 16) | cpu_lduw_code(env, s->pc);
2406         s->pc += 2;
2407     }
2408
2409     l1 = gen_new_label();
2410     /* TODO: Raise BSUN exception.  */
2411     flag = tcg_temp_new();
2412     gen_helper_compare_f64(flag, cpu_env, QREG_FP_RESULT);
2413     /* Jump to l1 if condition is true.  */
2414     switch (insn & 0xf) {
2415     case 0: /* f */
2416         break;
2417     case 1: /* eq (=0) */
2418         tcg_gen_brcond_i32(TCG_COND_EQ, flag, tcg_const_i32(0), l1);
2419         break;
2420     case 2: /* ogt (=1) */
2421         tcg_gen_brcond_i32(TCG_COND_EQ, flag, tcg_const_i32(1), l1);
2422         break;
2423     case 3: /* oge (=0 or =1) */
2424         tcg_gen_brcond_i32(TCG_COND_LEU, flag, tcg_const_i32(1), l1);
2425         break;
2426     case 4: /* olt (=-1) */
2427         tcg_gen_brcond_i32(TCG_COND_LT, flag, tcg_const_i32(0), l1);
2428         break;
2429     case 5: /* ole (=-1 or =0) */
2430         tcg_gen_brcond_i32(TCG_COND_LE, flag, tcg_const_i32(0), l1);
2431         break;
2432     case 6: /* ogl (=-1 or =1) */
2433         tcg_gen_andi_i32(flag, flag, 1);
2434         tcg_gen_brcond_i32(TCG_COND_NE, flag, tcg_const_i32(0), l1);
2435         break;
2436     case 7: /* or (=2) */
2437         tcg_gen_brcond_i32(TCG_COND_EQ, flag, tcg_const_i32(2), l1);
2438         break;
2439     case 8: /* un (<2) */
2440         tcg_gen_brcond_i32(TCG_COND_LT, flag, tcg_const_i32(2), l1);
2441         break;
2442     case 9: /* ueq (=0 or =2) */
2443         tcg_gen_andi_i32(flag, flag, 1);
2444         tcg_gen_brcond_i32(TCG_COND_EQ, flag, tcg_const_i32(0), l1);
2445         break;
2446     case 10: /* ugt (>0) */
2447         tcg_gen_brcond_i32(TCG_COND_GT, flag, tcg_const_i32(0), l1);
2448         break;
2449     case 11: /* uge (>=0) */
2450         tcg_gen_brcond_i32(TCG_COND_GE, flag, tcg_const_i32(0), l1);
2451         break;
2452     case 12: /* ult (=-1 or =2) */
2453         tcg_gen_brcond_i32(TCG_COND_GEU, flag, tcg_const_i32(2), l1);
2454         break;
2455     case 13: /* ule (!=1) */
2456         tcg_gen_brcond_i32(TCG_COND_NE, flag, tcg_const_i32(1), l1);
2457         break;
2458     case 14: /* ne (!=0) */
2459         tcg_gen_brcond_i32(TCG_COND_NE, flag, tcg_const_i32(0), l1);
2460         break;
2461     case 15: /* t */
2462         tcg_gen_br(l1);
2463         break;
2464     }
2465     gen_jmp_tb(s, 0, s->pc);
2466     gen_set_label(l1);
2467     gen_jmp_tb(s, 1, addr + offset);
2468 }
2469
2470 DISAS_INSN(frestore)
2471 {
2472     /* TODO: Implement frestore.  */
2473     qemu_assert(0, "FRESTORE not implemented");
2474 }
2475
2476 DISAS_INSN(fsave)
2477 {
2478     /* TODO: Implement fsave.  */
2479     qemu_assert(0, "FSAVE not implemented");
2480 }
2481
2482 static inline TCGv gen_mac_extract_word(DisasContext *s, TCGv val, int upper)
2483 {
2484     TCGv tmp = tcg_temp_new();
2485     if (s->env->macsr & MACSR_FI) {
2486         if (upper)
2487             tcg_gen_andi_i32(tmp, val, 0xffff0000);
2488         else
2489             tcg_gen_shli_i32(tmp, val, 16);
2490     } else if (s->env->macsr & MACSR_SU) {
2491         if (upper)
2492             tcg_gen_sari_i32(tmp, val, 16);
2493         else
2494             tcg_gen_ext16s_i32(tmp, val);
2495     } else {
2496         if (upper)
2497             tcg_gen_shri_i32(tmp, val, 16);
2498         else
2499             tcg_gen_ext16u_i32(tmp, val);
2500     }
2501     return tmp;
2502 }
2503
2504 static void gen_mac_clear_flags(void)
2505 {
2506     tcg_gen_andi_i32(QREG_MACSR, QREG_MACSR,
2507                      ~(MACSR_V | MACSR_Z | MACSR_N | MACSR_EV));
2508 }
2509
2510 DISAS_INSN(mac)
2511 {
2512     TCGv rx;
2513     TCGv ry;
2514     uint16_t ext;
2515     int acc;
2516     TCGv tmp;
2517     TCGv addr;
2518     TCGv loadval;
2519     int dual;
2520     TCGv saved_flags;
2521
2522     if (!s->done_mac) {
2523         s->mactmp = tcg_temp_new_i64();
2524         s->done_mac = 1;
2525     }
2526
2527     ext = cpu_lduw_code(env, s->pc);
2528     s->pc += 2;
2529
2530     acc = ((insn >> 7) & 1) | ((ext >> 3) & 2);
2531     dual = ((insn & 0x30) != 0 && (ext & 3) != 0);
2532     if (dual && !m68k_feature(s->env, M68K_FEATURE_CF_EMAC_B)) {
2533         disas_undef(env, s, insn);
2534         return;
2535     }
2536     if (insn & 0x30) {
2537         /* MAC with load.  */
2538         tmp = gen_lea(env, s, insn, OS_LONG);
2539         addr = tcg_temp_new();
2540         tcg_gen_and_i32(addr, tmp, QREG_MAC_MASK);
2541         /* Load the value now to ensure correct exception behavior.
2542            Perform writeback after reading the MAC inputs.  */
2543         loadval = gen_load(s, OS_LONG, addr, 0);
2544
2545         acc ^= 1;
2546         rx = (ext & 0x8000) ? AREG(ext, 12) : DREG(insn, 12);
2547         ry = (ext & 8) ? AREG(ext, 0) : DREG(ext, 0);
2548     } else {
2549         loadval = addr = NULL_QREG;
2550         rx = (insn & 0x40) ? AREG(insn, 9) : DREG(insn, 9);
2551         ry = (insn & 8) ? AREG(insn, 0) : DREG(insn, 0);
2552     }
2553
2554     gen_mac_clear_flags();
2555 #if 0
2556     l1 = -1;
2557     /* Disabled because conditional branches clobber temporary vars.  */
2558     if ((s->env->macsr & MACSR_OMC) != 0 && !dual) {
2559         /* Skip the multiply if we know we will ignore it.  */
2560         l1 = gen_new_label();
2561         tmp = tcg_temp_new();
2562         tcg_gen_andi_i32(tmp, QREG_MACSR, 1 << (acc + 8));
2563         gen_op_jmp_nz32(tmp, l1);
2564     }
2565 #endif
2566
2567     if ((ext & 0x0800) == 0) {
2568         /* Word.  */
2569         rx = gen_mac_extract_word(s, rx, (ext & 0x80) != 0);
2570         ry = gen_mac_extract_word(s, ry, (ext & 0x40) != 0);
2571     }
2572     if (s->env->macsr & MACSR_FI) {
2573         gen_helper_macmulf(s->mactmp, cpu_env, rx, ry);
2574     } else {
2575         if (s->env->macsr & MACSR_SU)
2576             gen_helper_macmuls(s->mactmp, cpu_env, rx, ry);
2577         else
2578             gen_helper_macmulu(s->mactmp, cpu_env, rx, ry);
2579         switch ((ext >> 9) & 3) {
2580         case 1:
2581             tcg_gen_shli_i64(s->mactmp, s->mactmp, 1);
2582             break;
2583         case 3:
2584             tcg_gen_shri_i64(s->mactmp, s->mactmp, 1);
2585             break;
2586         }
2587     }
2588
2589     if (dual) {
2590         /* Save the overflow flag from the multiply.  */
2591         saved_flags = tcg_temp_new();
2592         tcg_gen_mov_i32(saved_flags, QREG_MACSR);
2593     } else {
2594         saved_flags = NULL_QREG;
2595     }
2596
2597 #if 0
2598     /* Disabled because conditional branches clobber temporary vars.  */
2599     if ((s->env->macsr & MACSR_OMC) != 0 && dual) {
2600         /* Skip the accumulate if the value is already saturated.  */
2601         l1 = gen_new_label();
2602         tmp = tcg_temp_new();
2603         gen_op_and32(tmp, QREG_MACSR, tcg_const_i32(MACSR_PAV0 << acc));
2604         gen_op_jmp_nz32(tmp, l1);
2605     }
2606 #endif
2607
2608     if (insn & 0x100)
2609         tcg_gen_sub_i64(MACREG(acc), MACREG(acc), s->mactmp);
2610     else
2611         tcg_gen_add_i64(MACREG(acc), MACREG(acc), s->mactmp);
2612
2613     if (s->env->macsr & MACSR_FI)
2614         gen_helper_macsatf(cpu_env, tcg_const_i32(acc));
2615     else if (s->env->macsr & MACSR_SU)
2616         gen_helper_macsats(cpu_env, tcg_const_i32(acc));
2617     else
2618         gen_helper_macsatu(cpu_env, tcg_const_i32(acc));
2619
2620 #if 0
2621     /* Disabled because conditional branches clobber temporary vars.  */
2622     if (l1 != -1)
2623         gen_set_label(l1);
2624 #endif
2625
2626     if (dual) {
2627         /* Dual accumulate variant.  */
2628         acc = (ext >> 2) & 3;
2629         /* Restore the overflow flag from the multiplier.  */
2630         tcg_gen_mov_i32(QREG_MACSR, saved_flags);
2631 #if 0
2632         /* Disabled because conditional branches clobber temporary vars.  */
2633         if ((s->env->macsr & MACSR_OMC) != 0) {
2634             /* Skip the accumulate if the value is already saturated.  */
2635             l1 = gen_new_label();
2636             tmp = tcg_temp_new();
2637             gen_op_and32(tmp, QREG_MACSR, tcg_const_i32(MACSR_PAV0 << acc));
2638             gen_op_jmp_nz32(tmp, l1);
2639         }
2640 #endif
2641         if (ext & 2)
2642             tcg_gen_sub_i64(MACREG(acc), MACREG(acc), s->mactmp);
2643         else
2644             tcg_gen_add_i64(MACREG(acc), MACREG(acc), s->mactmp);
2645         if (s->env->macsr & MACSR_FI)
2646             gen_helper_macsatf(cpu_env, tcg_const_i32(acc));
2647         else if (s->env->macsr & MACSR_SU)
2648             gen_helper_macsats(cpu_env, tcg_const_i32(acc));
2649         else
2650             gen_helper_macsatu(cpu_env, tcg_const_i32(acc));
2651 #if 0
2652         /* Disabled because conditional branches clobber temporary vars.  */
2653         if (l1 != -1)
2654             gen_set_label(l1);
2655 #endif
2656     }
2657     gen_helper_mac_set_flags(cpu_env, tcg_const_i32(acc));
2658
2659     if (insn & 0x30) {
2660         TCGv rw;
2661         rw = (insn & 0x40) ? AREG(insn, 9) : DREG(insn, 9);
2662         tcg_gen_mov_i32(rw, loadval);
2663         /* FIXME: Should address writeback happen with the masked or
2664            unmasked value?  */
2665         switch ((insn >> 3) & 7) {
2666         case 3: /* Post-increment.  */
2667             tcg_gen_addi_i32(AREG(insn, 0), addr, 4);
2668             break;
2669         case 4: /* Pre-decrement.  */
2670             tcg_gen_mov_i32(AREG(insn, 0), addr);
2671         }
2672     }
2673 }
2674
2675 DISAS_INSN(from_mac)
2676 {
2677     TCGv rx;
2678     TCGv_i64 acc;
2679     int accnum;
2680
2681     rx = (insn & 8) ? AREG(insn, 0) : DREG(insn, 0);
2682     accnum = (insn >> 9) & 3;
2683     acc = MACREG(accnum);
2684     if (s->env->macsr & MACSR_FI) {
2685         gen_helper_get_macf(rx, cpu_env, acc);
2686     } else if ((s->env->macsr & MACSR_OMC) == 0) {
2687         tcg_gen_trunc_i64_i32(rx, acc);
2688     } else if (s->env->macsr & MACSR_SU) {
2689         gen_helper_get_macs(rx, acc);
2690     } else {
2691         gen_helper_get_macu(rx, acc);
2692     }
2693     if (insn & 0x40) {
2694         tcg_gen_movi_i64(acc, 0);
2695         tcg_gen_andi_i32(QREG_MACSR, QREG_MACSR, ~(MACSR_PAV0 << accnum));
2696     }
2697 }
2698
2699 DISAS_INSN(move_mac)
2700 {
2701     /* FIXME: This can be done without a helper.  */
2702     int src;
2703     TCGv dest;
2704     src = insn & 3;
2705     dest = tcg_const_i32((insn >> 9) & 3);
2706     gen_helper_mac_move(cpu_env, dest, tcg_const_i32(src));
2707     gen_mac_clear_flags();
2708     gen_helper_mac_set_flags(cpu_env, dest);
2709 }
2710
2711 DISAS_INSN(from_macsr)
2712 {
2713     TCGv reg;
2714
2715     reg = (insn & 8) ? AREG(insn, 0) : DREG(insn, 0);
2716     tcg_gen_mov_i32(reg, QREG_MACSR);
2717 }
2718
2719 DISAS_INSN(from_mask)
2720 {
2721     TCGv reg;
2722     reg = (insn & 8) ? AREG(insn, 0) : DREG(insn, 0);
2723     tcg_gen_mov_i32(reg, QREG_MAC_MASK);
2724 }
2725
2726 DISAS_INSN(from_mext)
2727 {
2728     TCGv reg;
2729     TCGv acc;
2730     reg = (insn & 8) ? AREG(insn, 0) : DREG(insn, 0);
2731     acc = tcg_const_i32((insn & 0x400) ? 2 : 0);
2732     if (s->env->macsr & MACSR_FI)
2733         gen_helper_get_mac_extf(reg, cpu_env, acc);
2734     else
2735         gen_helper_get_mac_exti(reg, cpu_env, acc);
2736 }
2737
2738 DISAS_INSN(macsr_to_ccr)
2739 {
2740     tcg_gen_movi_i32(QREG_CC_X, 0);
2741     tcg_gen_andi_i32(QREG_CC_DEST, QREG_MACSR, 0xf);
2742     s->cc_op = CC_OP_FLAGS;
2743 }
2744
2745 DISAS_INSN(to_mac)
2746 {
2747     TCGv_i64 acc;
2748     TCGv val;
2749     int accnum;
2750     accnum = (insn >> 9) & 3;
2751     acc = MACREG(accnum);
2752     SRC_EA(env, val, OS_LONG, 0, NULL);
2753     if (s->env->macsr & MACSR_FI) {
2754         tcg_gen_ext_i32_i64(acc, val);
2755         tcg_gen_shli_i64(acc, acc, 8);
2756     } else if (s->env->macsr & MACSR_SU) {
2757         tcg_gen_ext_i32_i64(acc, val);
2758     } else {
2759         tcg_gen_extu_i32_i64(acc, val);
2760     }
2761     tcg_gen_andi_i32(QREG_MACSR, QREG_MACSR, ~(MACSR_PAV0 << accnum));
2762     gen_mac_clear_flags();
2763     gen_helper_mac_set_flags(cpu_env, tcg_const_i32(accnum));
2764 }
2765
2766 DISAS_INSN(to_macsr)
2767 {
2768     TCGv val;
2769     SRC_EA(env, val, OS_LONG, 0, NULL);
2770     gen_helper_set_macsr(cpu_env, val);
2771     gen_lookup_tb(s);
2772 }
2773
2774 DISAS_INSN(to_mask)
2775 {
2776     TCGv val;
2777     SRC_EA(env, val, OS_LONG, 0, NULL);
2778     tcg_gen_ori_i32(QREG_MAC_MASK, val, 0xffff0000);
2779 }
2780
2781 DISAS_INSN(to_mext)
2782 {
2783     TCGv val;
2784     TCGv acc;
2785     SRC_EA(env, val, OS_LONG, 0, NULL);
2786     acc = tcg_const_i32((insn & 0x400) ? 2 : 0);
2787     if (s->env->macsr & MACSR_FI)
2788         gen_helper_set_mac_extf(cpu_env, val, acc);
2789     else if (s->env->macsr & MACSR_SU)
2790         gen_helper_set_mac_exts(cpu_env, val, acc);
2791     else
2792         gen_helper_set_mac_extu(cpu_env, val, acc);
2793 }
2794
2795 static disas_proc opcode_table[65536];
2796
2797 static void
2798 register_opcode (disas_proc proc, uint16_t opcode, uint16_t mask)
2799 {
2800   int i;
2801   int from;
2802   int to;
2803
2804   /* Sanity check.  All set bits must be included in the mask.  */
2805   if (opcode & ~mask) {
2806       fprintf(stderr,
2807               "qemu internal error: bogus opcode definition %04x/%04x\n",
2808               opcode, mask);
2809       abort();
2810   }
2811   /* This could probably be cleverer.  For now just optimize the case where
2812      the top bits are known.  */
2813   /* Find the first zero bit in the mask.  */
2814   i = 0x8000;
2815   while ((i & mask) != 0)
2816       i >>= 1;
2817   /* Iterate over all combinations of this and lower bits.  */
2818   if (i == 0)
2819       i = 1;
2820   else
2821       i <<= 1;
2822   from = opcode & ~(i - 1);
2823   to = from + i;
2824   for (i = from; i < to; i++) {
2825       if ((i & mask) == opcode)
2826           opcode_table[i] = proc;
2827   }
2828 }
2829
2830 /* Register m68k opcode handlers.  Order is important.
2831    Later insn override earlier ones.  */
2832 void register_m68k_insns (CPUM68KState *env)
2833 {
2834 #define INSN(name, opcode, mask, feature) do { \
2835     if (m68k_feature(env, M68K_FEATURE_##feature)) \
2836         register_opcode(disas_##name, 0x##opcode, 0x##mask); \
2837     } while(0)
2838     INSN(undef,     0000, 0000, CF_ISA_A);
2839     INSN(arith_im,  0080, fff8, CF_ISA_A);
2840     INSN(bitrev,    00c0, fff8, CF_ISA_APLUSC);
2841     INSN(bitop_reg, 0100, f1c0, CF_ISA_A);
2842     INSN(bitop_reg, 0140, f1c0, CF_ISA_A);
2843     INSN(bitop_reg, 0180, f1c0, CF_ISA_A);
2844     INSN(bitop_reg, 01c0, f1c0, CF_ISA_A);
2845     INSN(arith_im,  0280, fff8, CF_ISA_A);
2846     INSN(byterev,   02c0, fff8, CF_ISA_APLUSC);
2847     INSN(arith_im,  0480, fff8, CF_ISA_A);
2848     INSN(ff1,       04c0, fff8, CF_ISA_APLUSC);
2849     INSN(arith_im,  0680, fff8, CF_ISA_A);
2850     INSN(bitop_im,  0800, ffc0, CF_ISA_A);
2851     INSN(bitop_im,  0840, ffc0, CF_ISA_A);
2852     INSN(bitop_im,  0880, ffc0, CF_ISA_A);
2853     INSN(bitop_im,  08c0, ffc0, CF_ISA_A);
2854     INSN(arith_im,  0a80, fff8, CF_ISA_A);
2855     INSN(arith_im,  0c00, ff38, CF_ISA_A);
2856     INSN(move,      1000, f000, CF_ISA_A);
2857     INSN(move,      2000, f000, CF_ISA_A);
2858     INSN(move,      3000, f000, CF_ISA_A);
2859     INSN(strldsr,   40e7, ffff, CF_ISA_APLUSC);
2860     INSN(negx,      4080, fff8, CF_ISA_A);
2861     INSN(move_from_sr, 40c0, fff8, CF_ISA_A);
2862     INSN(lea,       41c0, f1c0, CF_ISA_A);
2863     INSN(clr,       4200, ff00, CF_ISA_A);
2864     INSN(undef,     42c0, ffc0, CF_ISA_A);
2865     INSN(move_from_ccr, 42c0, fff8, CF_ISA_A);
2866     INSN(neg,       4480, fff8, CF_ISA_A);
2867     INSN(move_to_ccr, 44c0, ffc0, CF_ISA_A);
2868     INSN(not,       4680, fff8, CF_ISA_A);
2869     INSN(move_to_sr, 46c0, ffc0, CF_ISA_A);
2870     INSN(pea,       4840, ffc0, CF_ISA_A);
2871     INSN(swap,      4840, fff8, CF_ISA_A);
2872     INSN(movem,     48c0, fbc0, CF_ISA_A);
2873     INSN(ext,       4880, fff8, CF_ISA_A);
2874     INSN(ext,       48c0, fff8, CF_ISA_A);
2875     INSN(ext,       49c0, fff8, CF_ISA_A);
2876     INSN(tst,       4a00, ff00, CF_ISA_A);
2877     INSN(tas,       4ac0, ffc0, CF_ISA_B);
2878     INSN(halt,      4ac8, ffff, CF_ISA_A);
2879     INSN(pulse,     4acc, ffff, CF_ISA_A);
2880     INSN(illegal,   4afc, ffff, CF_ISA_A);
2881     INSN(mull,      4c00, ffc0, CF_ISA_A);
2882     INSN(divl,      4c40, ffc0, CF_ISA_A);
2883     INSN(sats,      4c80, fff8, CF_ISA_B);
2884     INSN(trap,      4e40, fff0, CF_ISA_A);
2885     INSN(link,      4e50, fff8, CF_ISA_A);
2886     INSN(unlk,      4e58, fff8, CF_ISA_A);
2887     INSN(move_to_usp, 4e60, fff8, USP);
2888     INSN(move_from_usp, 4e68, fff8, USP);
2889     INSN(nop,       4e71, ffff, CF_ISA_A);
2890     INSN(stop,      4e72, ffff, CF_ISA_A);
2891     INSN(rte,       4e73, ffff, CF_ISA_A);
2892     INSN(rts,       4e75, ffff, CF_ISA_A);
2893     INSN(movec,     4e7b, ffff, CF_ISA_A);
2894     INSN(jump,      4e80, ffc0, CF_ISA_A);
2895     INSN(jump,      4ec0, ffc0, CF_ISA_A);
2896     INSN(addsubq,   5180, f1c0, CF_ISA_A);
2897     INSN(scc,       50c0, f0f8, CF_ISA_A);
2898     INSN(addsubq,   5080, f1c0, CF_ISA_A);
2899     INSN(tpf,       51f8, fff8, CF_ISA_A);
2900
2901     /* Branch instructions.  */
2902     INSN(branch,    6000, f000, CF_ISA_A);
2903     /* Disable long branch instructions, then add back the ones we want.  */
2904     INSN(undef,     60ff, f0ff, CF_ISA_A); /* All long branches.  */
2905     INSN(branch,    60ff, f0ff, CF_ISA_B);
2906     INSN(undef,     60ff, ffff, CF_ISA_B); /* bra.l */
2907     INSN(branch,    60ff, ffff, BRAL);
2908
2909     INSN(moveq,     7000, f100, CF_ISA_A);
2910     INSN(mvzs,      7100, f100, CF_ISA_B);
2911     INSN(or,        8000, f000, CF_ISA_A);
2912     INSN(divw,      80c0, f0c0, CF_ISA_A);
2913     INSN(addsub,    9000, f000, CF_ISA_A);
2914     INSN(subx,      9180, f1f8, CF_ISA_A);
2915     INSN(suba,      91c0, f1c0, CF_ISA_A);
2916
2917     INSN(undef_mac, a000, f000, CF_ISA_A);
2918     INSN(mac,       a000, f100, CF_EMAC);
2919     INSN(from_mac,  a180, f9b0, CF_EMAC);
2920     INSN(move_mac,  a110, f9fc, CF_EMAC);
2921     INSN(from_macsr,a980, f9f0, CF_EMAC);
2922     INSN(from_mask, ad80, fff0, CF_EMAC);
2923     INSN(from_mext, ab80, fbf0, CF_EMAC);
2924     INSN(macsr_to_ccr, a9c0, ffff, CF_EMAC);
2925     INSN(to_mac,    a100, f9c0, CF_EMAC);
2926     INSN(to_macsr,  a900, ffc0, CF_EMAC);
2927     INSN(to_mext,   ab00, fbc0, CF_EMAC);
2928     INSN(to_mask,   ad00, ffc0, CF_EMAC);
2929
2930     INSN(mov3q,     a140, f1c0, CF_ISA_B);
2931     INSN(cmp,       b000, f1c0, CF_ISA_B); /* cmp.b */
2932     INSN(cmp,       b040, f1c0, CF_ISA_B); /* cmp.w */
2933     INSN(cmpa,      b0c0, f1c0, CF_ISA_B); /* cmpa.w */
2934     INSN(cmp,       b080, f1c0, CF_ISA_A);
2935     INSN(cmpa,      b1c0, f1c0, CF_ISA_A);
2936     INSN(eor,       b180, f1c0, CF_ISA_A);
2937     INSN(and,       c000, f000, CF_ISA_A);
2938     INSN(mulw,      c0c0, f0c0, CF_ISA_A);
2939     INSN(addsub,    d000, f000, CF_ISA_A);
2940     INSN(addx,      d180, f1f8, CF_ISA_A);
2941     INSN(adda,      d1c0, f1c0, CF_ISA_A);
2942     INSN(shift_im,  e080, f0f0, CF_ISA_A);
2943     INSN(shift_reg, e0a0, f0f0, CF_ISA_A);
2944     INSN(undef_fpu, f000, f000, CF_ISA_A);
2945     INSN(fpu,       f200, ffc0, CF_FPU);
2946     INSN(fbcc,      f280, ffc0, CF_FPU);
2947     INSN(frestore,  f340, ffc0, CF_FPU);
2948     INSN(fsave,     f340, ffc0, CF_FPU);
2949     INSN(intouch,   f340, ffc0, CF_ISA_A);
2950     INSN(cpushl,    f428, ff38, CF_ISA_A);
2951     INSN(wddata,    fb00, ff00, CF_ISA_A);
2952     INSN(wdebug,    fbc0, ffc0, CF_ISA_A);
2953 #undef INSN
2954 }
2955
2956 /* ??? Some of this implementation is not exception safe.  We should always
2957    write back the result to memory before setting the condition codes.  */
2958 static void disas_m68k_insn(CPUM68KState * env, DisasContext *s)
2959 {
2960     uint16_t insn;
2961
2962     if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP | CPU_LOG_TB_OP_OPT))) {
2963         tcg_gen_debug_insn_start(s->pc);
2964     }
2965
2966     insn = cpu_lduw_code(env, s->pc);
2967     s->pc += 2;
2968
2969     opcode_table[insn](env, s, insn);
2970 }
2971
2972 /* generate intermediate code for basic block 'tb'.  */
2973 static inline void
2974 gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
2975                                int search_pc)
2976 {
2977     DisasContext dc1, *dc = &dc1;
2978     uint16_t *gen_opc_end;
2979     CPUBreakpoint *bp;
2980     int j, lj;
2981     target_ulong pc_start;
2982     int pc_offset;
2983     int num_insns;
2984     int max_insns;
2985
2986     /* generate intermediate code */
2987     pc_start = tb->pc;
2988
2989     dc->tb = tb;
2990
2991     gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
2992
2993     dc->env = env;
2994     dc->is_jmp = DISAS_NEXT;
2995     dc->pc = pc_start;
2996     dc->cc_op = CC_OP_DYNAMIC;
2997     dc->singlestep_enabled = env->singlestep_enabled;
2998     dc->fpcr = env->fpcr;
2999     dc->user = (env->sr & SR_S) == 0;
3000     dc->is_mem = 0;
3001     dc->done_mac = 0;
3002     lj = -1;
3003     num_insns = 0;
3004     max_insns = tb->cflags & CF_COUNT_MASK;
3005     if (max_insns == 0)
3006         max_insns = CF_COUNT_MASK;
3007
3008     gen_tb_start();
3009     do {
3010         pc_offset = dc->pc - pc_start;
3011         gen_throws_exception = NULL;
3012         if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
3013             QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
3014                 if (bp->pc == dc->pc) {
3015                     gen_exception(dc, dc->pc, EXCP_DEBUG);
3016                     dc->is_jmp = DISAS_JUMP;
3017                     break;
3018                 }
3019             }
3020             if (dc->is_jmp)
3021                 break;
3022         }
3023         if (search_pc) {
3024             j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
3025             if (lj < j) {
3026                 lj++;
3027                 while (lj < j)
3028                     tcg_ctx.gen_opc_instr_start[lj++] = 0;
3029             }
3030             tcg_ctx.gen_opc_pc[lj] = dc->pc;
3031             tcg_ctx.gen_opc_instr_start[lj] = 1;
3032             tcg_ctx.gen_opc_icount[lj] = num_insns;
3033         }
3034         if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))
3035             gen_io_start();
3036         dc->insn_pc = dc->pc;
3037         disas_m68k_insn(env, dc);
3038         num_insns++;
3039     } while (!dc->is_jmp && tcg_ctx.gen_opc_ptr < gen_opc_end &&
3040              !env->singlestep_enabled &&
3041              !singlestep &&
3042              (pc_offset) < (TARGET_PAGE_SIZE - 32) &&
3043              num_insns < max_insns);
3044
3045     if (tb->cflags & CF_LAST_IO)
3046         gen_io_end();
3047     if (unlikely(env->singlestep_enabled)) {
3048         /* Make sure the pc is updated, and raise a debug exception.  */
3049         if (!dc->is_jmp) {
3050             gen_flush_cc_op(dc);
3051             tcg_gen_movi_i32(QREG_PC, dc->pc);
3052         }
3053         gen_helper_raise_exception(cpu_env, tcg_const_i32(EXCP_DEBUG));
3054     } else {
3055         switch(dc->is_jmp) {
3056         case DISAS_NEXT:
3057             gen_flush_cc_op(dc);
3058             gen_jmp_tb(dc, 0, dc->pc);
3059             break;
3060         default:
3061         case DISAS_JUMP:
3062         case DISAS_UPDATE:
3063             gen_flush_cc_op(dc);
3064             /* indicate that the hash table must be used to find the next TB */
3065             tcg_gen_exit_tb(0);
3066             break;
3067         case DISAS_TB_JUMP:
3068             /* nothing more to generate */
3069             break;
3070         }
3071     }
3072     gen_tb_end(tb, num_insns);
3073     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
3074
3075 #ifdef DEBUG_DISAS
3076     if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
3077         qemu_log("----------------\n");
3078         qemu_log("IN: %s\n", lookup_symbol(pc_start));
3079         log_target_disas(env, pc_start, dc->pc - pc_start, 0);
3080         qemu_log("\n");
3081     }
3082 #endif
3083     if (search_pc) {
3084         j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
3085         lj++;
3086         while (lj <= j)
3087             tcg_ctx.gen_opc_instr_start[lj++] = 0;
3088     } else {
3089         tb->size = dc->pc - pc_start;
3090         tb->icount = num_insns;
3091     }
3092
3093     //optimize_flags();
3094     //expand_target_qops();
3095 }
3096
3097 void gen_intermediate_code(CPUM68KState *env, TranslationBlock *tb)
3098 {
3099     gen_intermediate_code_internal(env, tb, 0);
3100 }
3101
3102 void gen_intermediate_code_pc(CPUM68KState *env, TranslationBlock *tb)
3103 {
3104     gen_intermediate_code_internal(env, tb, 1);
3105 }
3106
3107 void cpu_dump_state(CPUM68KState *env, FILE *f, fprintf_function cpu_fprintf,
3108                     int flags)
3109 {
3110     int i;
3111     uint16_t sr;
3112     CPU_DoubleU u;
3113     for (i = 0; i < 8; i++)
3114       {
3115         u.d = env->fregs[i];
3116         cpu_fprintf (f, "D%d = %08x   A%d = %08x   F%d = %08x%08x (%12g)\n",
3117                      i, env->dregs[i], i, env->aregs[i],
3118                      i, u.l.upper, u.l.lower, *(double *)&u.d);
3119       }
3120     cpu_fprintf (f, "PC = %08x   ", env->pc);
3121     sr = env->sr;
3122     cpu_fprintf (f, "SR = %04x %c%c%c%c%c ", sr, (sr & 0x10) ? 'X' : '-',
3123                  (sr & CCF_N) ? 'N' : '-', (sr & CCF_Z) ? 'Z' : '-',
3124                  (sr & CCF_V) ? 'V' : '-', (sr & CCF_C) ? 'C' : '-');
3125     cpu_fprintf (f, "FPRESULT = %12g\n", *(double *)&env->fp_result);
3126 }
3127
3128 void restore_state_to_opc(CPUM68KState *env, TranslationBlock *tb, int pc_pos)
3129 {
3130     env->pc = tcg_ctx.gen_opc_pc[pc_pos];
3131 }