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