sim/m32c/m32c.opc

   1 /* m32c.opc --- semantics for m32c opcodes.                     -*- mode: c -*-
   2
   3 Copyright (C) 2005-2023 Free Software Foundation, Inc.
   4 Contributed by Red Hat, Inc.
   5
   6 This file is part of the GNU simulators.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 /* This must come before any other includes.  */
  22 #include "defs.h"
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26
  27 #include "ansidecl.h"
  28 #include "cpu.h"
  29 #include "mem.h"
  30 #include "misc.h"
  31 #include "int.h"
  32
  33 #define tprintf if (trace) printf
  34
  35 static unsigned char
  36 getbyte (void)
  37 {
  38   int tsave = trace;
  39   unsigned char b;
  40
  41   if (trace == 1)
  42     trace = 0;
  43   b = mem_get_pc ();
  44   regs.r_pc ++;
  45   trace = tsave;
  46   return b;
  47 }
  48
  49 #define M32C_ONLY() /* FIXME: add something here */
  50
  51 #define GETBYTE() (op[opi++] = getbyte())
  52
  53 #define UNSUPPORTED() unsupported("unsupported", m32c_opcode_pc)
  54 #define NOTYET() unsupported("unimplemented", m32c_opcode_pc)
  55
  56 static void
  57 unsupported (char *tag, int orig_pc)
  58 {
  59   int i;
  60   printf("%s opcode at %08x\n", tag, orig_pc);
  61   regs.r_pc = orig_pc;
  62   for (i=0; i<2; i++)
  63     {
  64       int b = mem_get_pc();
  65       printf(" %s", bits(b>>4, 4));
  66       printf(" %s", bits(b, 4));
  67       regs.r_pc ++;
  68     }
  69   printf("\n");
  70   regs.r_pc = orig_pc;
  71   for (i=0; i<6; i++)
  72     {
  73       printf(" %02x", mem_get_pc ());
  74       regs.r_pc ++;
  75     }
  76   printf("\n");
  77   exit(1);
  78 }
  79
  80 static int
  81 IMM(int bytes)
  82 {
  83   int rv = 0;
  84   switch (bytes)
  85     {
  86     case 1:
  87       rv = mem_get_qi (get_reg(pc));
  88       break;
  89     case 2:
  90       rv = mem_get_hi (get_reg(pc));
  91       break;
  92     case 3:
  93       rv = mem_get_psi (get_reg(pc));
  94       break;
  95     case 4:
  96       rv = mem_get_si (get_reg(pc));
  97       break;
  98     }
  99   regs.r_pc += bytes;
 100   return rv;
 101 }
 102
 103 #define IMM4() (immm >= 8 ? 7 - immm : immm + 1)
 104
 105 #define NO_PREFIX() PREFIX(0,0,0)
 106
 107 /* Indicate which sorts of prefixes are allowed for the current
 108    opcode.  */
 109 static void
 110 prefix (int src_allowed, int dest_allowed, int index_bytewidth)
 111 {
 112   /* At the moment, we don't do anything with this information.  We
 113      just wanted to get the information entered in some
 114      machine-readable form while we were going through all the
 115      opcodes.  */
 116 }
 117
 118 #define MATH_OP(dc,s,c,op) \
 119 { \
 120   int ma, mb; \
 121   ma = get_src(dc); \
 122   mb = s & b2mask[dc.bytes]; \
 123   ll = (long long)ma op (long long)mb op c; \
 124   tprintf("0x%x " #op " 0x%x " #op " 0x%x = 0x%llx\n", ma, mb, c, ll); \
 125   ma = sign_ext (ma, dc.bytes * 8); \
 126   mb = sign_ext (s, dc.bytes * 8); \
 127   v = ma op mb op c; \
 128   tprintf("%d " #op " %d " #op " %d = %d\n", ma, mb, c, v); \
 129   set_oszc (v, dc.bytes, (1 op 1) ? (ll > b2mask[dc.bytes]) : (ll >= 0)); \
 130   put_dest (dc, v); \
 131 }
 132
 133 #define LOGIC_OP(dc,s,op) \
 134 { \
 135   int ma, mb; \
 136   ma = get_src(dc); \
 137   mb = s & b2mask[dc.bytes]; \
 138   v = ma op mb; \
 139   tprintf("0x%x " #op " 0x%x = 0x%x\n", ma, mb, v); \
 140   set_sz (v, dc.bytes); \
 141   put_dest (dc, v); \
 142 }
 143
 144 #define BIT_OP(dc,bit,expr)                                             \
 145   b = get_bit2 (dc, bitindex == -1 ? bit : bitindex);                   \
 146   v = expr;                                                             \
 147   tprintf ("b=%d, bit=%d, carry=%d, %s = %d\n",                         \
 148            b,  bitindex == -1 ? bit : bitindex, carry, #expr, v);       \
 149   put_bit2 (dc,  bitindex == -1 ? bit : bitindex, v);
 150
 151 #define BIT_OPC(dc,bit,expr)                                            \
 152   b = get_bit2 (dc,  bitindex == -1 ? bit : bitindex);                  \
 153   v = expr;                                                             \
 154   tprintf ("b=%d, bit=%d, carry=%d, %s = %d\n",                         \
 155            b,  bitindex == -1 ? bit : bitindex, carry, #expr, v);       \
 156   set_c (v);
 157
 158 #define carry (FLAG_C ? 1 : 0)
 159
 160 static void
 161 cmp (int d, int s, int bytes)
 162 {
 163   int a, b, f=0;
 164   a = d - s;
 165   b = sign_ext (d, bytes*8) - sign_ext (s, bytes*8);
 166   tprintf ("cmp: %x - %x = %08x, %x - %x = %d\n",
 167            d, s, a,
 168            sign_ext(d,bytes*8), sign_ext(s,bytes*8), b);
 169
 170   if (b == 0)
 171     f |= FLAGBIT_Z;
 172   if (b & b2signbit[bytes])
 173     f |= FLAGBIT_S;
 174   if ((d & b2mask[bytes]) >= (s & b2mask[bytes]))
 175     f |= FLAGBIT_C;
 176   if (b < b2minsigned[bytes] || b > b2maxsigned[bytes])
 177     f |= FLAGBIT_O;
 178
 179   set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_O | FLAGBIT_C, f);
 180 }
 181
 182 static void
 183 dadd_op (int ddd, int dd, int sss, int ss, int imm, int add, int cy, int w)
 184 {
 185   srcdest sc, dc;
 186   int a, b=0, res;
 187
 188   prefix (0, 0, 0);
 189
 190   if (!imm)
 191     {
 192       sc = decode_src23 (sss, ss, w+1);
 193       b = get_src (sc);
 194     }
 195   dc = decode_dest23 (ddd, dd, w+1);
 196   a = get_src (dc);
 197   if (imm)
 198     b = IMM(w+1);
 199
 200   a = bcd2int(a, w);
 201   b = bcd2int(b, w);
 202
 203   tprintf("decimal: %d %s %d", a, add?"+":"-", b);
 204   if (cy)
 205     tprintf(" c=%d", carry);
 206
 207   if (add)
 208     {
 209       res = a + b;
 210       if (cy)
 211         res += carry;
 212       cy = res > (w ? 9999 : 99);
 213     }
 214   else
 215     {
 216       res = a - b;
 217       if (cy)
 218         res -= (1-carry);
 219       cy = res >= 0;
 220       if (res < 0)
 221         res += w ? 10000 : 100;
 222     }
 223
 224   res = int2bcd (res, w);
 225   tprintf(" = %x\n", res);
 226
 227   set_szc (res, w+1, cy);
 228
 229   put_dest (dc, res);
 230 }
 231 #define DADDV(A,C) dadd_op(ddd, dd, sss, ss, 0, A, C, w)
 232 #define DADDI(A,C) dadd_op(ddd, dd, 0, 0, 1, A, C, w)
 233
 234 static void
 235 div_op (int sss, int ss, int u, int x, int bytes)
 236 {
 237   srcdest sc;
 238   int s, v, a, b;
 239
 240   if (sss == -1)
 241     s = IMM(bytes);
 242   else
 243     {
 244       sc = decode_dest23 (sss, ss, bytes);
 245       s = get_src (sc);
 246     }
 247
 248   v = get_reg (bytes > 1 ? r2r0 : r0);
 249
 250   if (!u)
 251     {
 252       /* FIXME? do we sign extend a0/a1 to .L?  Docs say zero extend.  */
 253       s = sign_ext (s, bytes*8);
 254       v = sign_ext (v, bytes*8);
 255     }
 256
 257   if (s == 0)
 258     {
 259       set_flags (FLAGBIT_O, FLAGBIT_O);
 260       return;
 261     }
 262
 263   if (u)
 264     {
 265       a = (unsigned int)v / (unsigned int)s;
 266       b = (unsigned int)v % (unsigned int)s;
 267     }
 268   else
 269     {
 270       a = v / s;
 271       b = v % s;
 272     }
 273   if (x)
 274     {
 275       if ((s > 0 && b < 0)
 276           || (s < 0 && b > 0))
 277         {
 278           a --;
 279           b += s;
 280         }
 281     }
 282   tprintf ("%d / %d = %d rem %d\n", v, s, a, b);
 283   if ((!u && (a > b2maxsigned[bytes]
 284               || a < b2minsigned[bytes]))
 285       || (u && (a > b2mask[bytes])))
 286     set_flags (FLAGBIT_O, FLAGBIT_O);
 287   else
 288     set_flags (FLAGBIT_O, 0);
 289
 290   switch (bytes)
 291     {
 292     case 1:
 293       put_reg (r0l, a);
 294       put_reg (r0h, b);
 295       break;
 296     case 2:
 297       put_reg (r0, a);
 298       put_reg (r2, b);
 299       break;
 300     case 4:
 301       put_reg (r2r0, a);
 302       break;
 303     }
 304 }
 305
 306 static void
 307 index_op (int sss, int ss, int do_s, int do_d, int scale, int w)
 308 {
 309   srcdest sc = decode_src23 (sss, ss, w+1);
 310   int v = get_src (sc) * scale;
 311   tprintf("%d = %d * %d, %d %d\n", v, get_src(sc), scale, do_s, do_d);
 312   decode_index (do_s * v, do_d * v);
 313 }
 314 #define INDEXOP(scale,do_s,do_d)                                \
 315   index_op (sss, ss, do_s, do_d, scale, w); goto next_opcode
 316
 317 static void
 318 rot_op (srcdest sd, int rotc, int count)
 319 {
 320   int mask = (sd.bytes == 2) ? 0xffff : 0xff;
 321   int msb = (sd.bytes == 2) ? 0x8000 : 0x80;
 322   int v = get_src (sd);
 323   int c = carry, ct;
 324
 325   tprintf("%s %x by %d\n", rotc ? "rotc" : "rot", v, count);
 326   tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
 327   while (count > 0)
 328     {
 329       ct = (v & msb) ? 1 : 0;
 330       v <<= 1;
 331       v |= rotc ? c : ct;
 332       v &= mask;
 333       c = ct;
 334       tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
 335       count --;
 336     }
 337   while (count < 0)
 338     {
 339       ct = v & 1;
 340       v >>= 1;
 341       v |= (rotc ? c : ct) * msb;
 342       c = ct;
 343       tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
 344       count ++;
 345     }
 346   put_dest (sd, v);
 347   set_szc (v, sd.bytes, c);
 348 }
 349
 350 static void
 351 shift_op (srcdest sd, int arith, int count, int setc)
 352 {
 353   int mask = (sd.bytes == 2) ? 0xffff : 0xff;
 354   int msb = (sd.bytes == 2) ? 0x8000 : 0x80;
 355   int v = get_src (sd);
 356   int c = 0;
 357   int o = 0;
 358
 359   if (sd.bytes == 4)
 360     {
 361       mask = 0xffffffffU;
 362       msb = 0x80000000U;
 363     }
 364
 365   tprintf("%s %x by %d\n", arith ? "sha" : "shl", v, count);
 366   tprintf (": %s %d %d\n", bits(v, 8*sd.bytes), c, o);
 367   while (count > 0)
 368     {
 369       c = (v & msb) ? 1 : 0;
 370       v <<= 1;
 371       v &= mask;
 372       if (c != ((v & msb) ? 1 : 0))
 373         o = 1;
 374       tprintf (": %s %d %d\n", bits(v, 8*sd.bytes), c, o);
 375       count --;
 376     }
 377   while (count < 0)
 378     {
 379       c = v & 1;
 380       if (arith)
 381         v = (v & msb) | (v >> 1);
 382       else
 383         v = (v >> 1) & (msb - 1);
 384       tprintf (": %s %d %d\n", bits(v, 8*sd.bytes), c, o);
 385       count ++;
 386     }
 387   put_dest (sd, v);
 388   set_sz (v, sd.bytes);
 389   if (setc)
 390     set_c (c);
 391   set_flags (FLAGBIT_O, o ? FLAGBIT_O : 0);
 392 }
 393
 394 static int pcs[16];
 395 static int ipcs = 0;
 396
 397 int
 398 decode_m32c (void)
 399 {
 400   unsigned char op[40];
 401   int opi;
 402   int v, a, b;
 403   long long ll;
 404   srcdest sc, dc;
 405   int imm;
 406   int bitindex = -1;
 407   int t0, t1=0, t2, t3=0;
 408   int ta0, ta1, dif;
 409
 410   step_result = M32C_MAKE_STEPPED ();
 411
 412   decode_indirect (0, 0);
 413   decode_index (0, 0);
 414
 415 next_opcode:
 416   opi = 0;
 417   m32c_opcode_pc = get_reg (pc);
 418
 419   tprintf("trace: decode pc = %06x\n", m32c_opcode_pc);
 420
 421   if (m32c_opcode_pc == 0)
 422     {
 423       int i;
 424       printf("Abort: PC is zero, here from:\n");
 425       for (i=0; i<4; i++)
 426         printf("  0x%06x\n", pcs[(ipcs+15-i)%16]);
 427       return M32C_MAKE_HIT_BREAK ();
 428     }
 429   pcs[ipcs++] = m32c_opcode_pc;
 430   ipcs %= 16;
 431
 432   /** VARY sss 000 001 010 011 100 */
 433   /** VARY ddd 000 001 010 011 100 */
 434
 435   /** 0000 1001                         indirect dest */
 436
 437   decode_indirect (0, 1);
 438   goto next_opcode;
 439
 440   /** 0100 0001                         indirect src */
 441
 442   decode_indirect (1, 0);
 443   goto next_opcode;
 444
 445   /** 0100 1001                         indirect src and dest */
 446
 447   decode_indirect (1, 1);
 448   goto next_opcode;
 449
 450   /** 1010 ddd w dd01 1111              ABS.size dest */
 451
 452   prefix (0, 1, 0);
 453   dc = decode_dest23 (ddd, dd, w+1);
 454   v = sign_ext (get_src (dc), w?16:8);
 455   a = v<0 ? -v : v;
 456   tprintf("abs(%d) = %d\n", v, a);
 457   set_osz(a, w+1);
 458   put_dest (dc, a);
 459
 460   /** 0000 0001 1000 ddd w dd10 1110    ADC.size #IMM,dest */
 461
 462   prefix (0, 0, 0);
 463   dc = decode_dest23 (ddd, dd, w+1);
 464   imm = IMM (w+1);
 465   MATH_OP (dc, imm, carry, +);
 466
 467   /** 0000 0001 1sss ddd w dd ss 0100   ADC.size src,dest */
 468
 469   prefix (0, 0, 0);
 470   sc = decode_src23 (sss, ss, w+1);
 471   dc = decode_dest23 (ddd, dd, w+1);
 472   b = get_src (sc);
 473   MATH_OP (dc, b, carry, +);
 474
 475   /** 1011 ddd w dd01 1110              ADCF.size dest */
 476
 477   prefix (0, 1, 0);
 478   dc = decode_dest23 (ddd, dd, w+1);
 479   MATH_OP (dc, 0, carry, +);
 480
 481   /** 1000 ddd w dd10 1110              ADD.size:G #IMM,dest */
 482
 483   prefix (0, 1, 0);
 484   dc = decode_dest23(ddd, dd, w+1);
 485   imm = IMM(w+1);
 486   MATH_OP (dc, imm, 0, +);
 487
 488   /** 1000 ddd0 dd11 0001               ADD.L:G #IMM,dest */
 489
 490   prefix (0, 1, 0);
 491   dc = decode_dest23(ddd, dd, 4);
 492   imm = IMM(4);
 493   MATH_OP (dc, imm, 0, +);
 494
 495   /** 111L ddd w dd11 immm              ADD.size:Q #IMM,dest */
 496
 497   prefix (0, 1, 0);
 498   dc = decode_dest23(ddd, dd, L ? 4 : (w+1));
 499   imm = sign_ext (immm, 4);
 500   MATH_OP (dc, imm, 0, +);
 501
 502   /** 00dd 011w                         ADD.size:S #IMM,dest */
 503
 504   prefix (0, 1, 0);
 505   dc = decode_dest2(dd, w+1);
 506   imm = IMM (w+1);
 507   MATH_OP (dc, imm, 0, +);
 508
 509   /** 10i0 110d                         ADD.L:S #IMM,A0/A1 */
 510
 511   prefix (0, 0, 0);
 512   dc = reg_sd (d ? a1 : a0);
 513   imm = i ? 2 : 1;
 514   MATH_OP (dc, imm, 0, +);
 515
 516   /** 1sss ddd w dd ss 1000             ADD.size:G src,dest */
 517
 518   prefix (1, 1, 0);
 519   sc = decode_src23(sss, ss, w+1);
 520   dc = decode_dest23(ddd, dd, w+1);
 521   b = get_src (sc);
 522   MATH_OP (dc, b, 0, +);
 523
 524   /** 1sss ddd1 dd ss 0010              ADD.L:G src,dest */
 525
 526   prefix (1, 1, 0);
 527   sc = decode_src23(sss, ss, 4);
 528   dc = decode_dest23(ddd, dd, 4);
 529   b = get_src (sc);
 530   MATH_OP (dc, b, 0, +);
 531
 532   /** 1011 0110 0001 0011               ADD.L:G #IMM16,SP */
 533
 534   prefix (0, 0, 0);
 535   dc = reg_sd (sp);
 536   b = sign_ext (IMM(2), 16);
 537   MATH_OP (dc, b, 0, +);
 538
 539   /** 01ii 001i                         ADD.L:Q #IMM3,SP */
 540
 541   prefix (0, 0, 0);
 542   dc = reg_sd (sp);
 543   b = ii * 2 + i + 1;
 544   MATH_OP (dc, b, 0, +);
 545
 546   /** 1011 0110 0000 0011               ADD.L:S #IMM8,SP */
 547
 548   prefix (0, 0, 0);
 549   dc = reg_sd (sp);
 550   b = sign_ext (IMM(1), 8);
 551   MATH_OP (dc, b, 0, +);
 552
 553   /** 1000 ddd0 dd01 0001               ADDX #IMM,dest */
 554
 555   prefix (0, 1, 0);
 556   dc = decode_dest23(ddd, dd, 4);
 557   imm = sign_ext (IMM(1), 8);
 558   MATH_OP (dc, imm, 0, +);
 559
 560   /** 1sss ddd0 dd ss 0010              ADDX src,dest */
 561
 562   prefix (1, 1, 0);
 563   sc = decode_src23(sss, ss, 1);
 564   dc = decode_dest23(ddd, dd, 4);
 565   b = sign_ext (get_src (sc), 8);
 566   MATH_OP (dc, b, 0, +);
 567
 568   /** 1111 ddd w dd01 immm              ADJNZ.size #IMM,dest,label */
 569
 570   prefix (0, 0, 0);
 571   dc = decode_dest23 (ddd, dd, w+1);
 572   v = get_src (dc);
 573   imm = sign_ext(immm, 4);
 574   tprintf("%d + %d = %d\n", v, imm, v+imm);
 575   v += imm;
 576   put_dest (dc, v);
 577   a = sign_ext (IMM(1), 8);
 578   if ((v & (w ? 0xffff : 0xff)) != 0)
 579     {
 580       tprintf("jmp: %x + 2 + %d = ", get_reg (pc), a);
 581       put_reg (pc, m32c_opcode_pc + 2 + a);
 582       tprintf("%x\n", get_reg (pc));
 583     }
 584
 585   /** 1000 ddd w dd11 1111              AND.size:G #IMM,dest */
 586
 587   prefix (0, 1, 0);
 588   dc = decode_dest23(ddd, dd, w+1);
 589   imm = IMM(w+1);
 590   LOGIC_OP (dc, imm, &);
 591
 592   /** 01dd 110w                         AND.size:S #IMM,dest */
 593
 594   prefix (0, 1, 0);
 595   dc = decode_dest2(dd, w+1);
 596   imm = IMM (w+1);
 597   LOGIC_OP (dc, imm, &);
 598
 599   /** 1sss ddd w dd ss 1101             AND.size:G src,dest */
 600
 601   prefix (1, 1, 0);
 602   sc = decode_src23(sss, ss, w+1);
 603   dc = decode_dest23(ddd, dd, w+1);
 604   b = get_src (sc);
 605   LOGIC_OP (dc, b, &);
 606
 607   /** 0000 0001 1101 sss0 ss00 1bit     BAND src */
 608
 609   sc = decode_src23 (sss, ss, 1);
 610   BIT_OPC (sc, bit, b & carry);
 611
 612   /** 1101 ddd0 dd11 0bit               BCLR dest */
 613
 614   dc = decode_dest23 (ddd, dd, 1);
 615   BIT_OP (dc, bit, 0);
 616
 617   /** 1100 ddd w dd10 1110              BITINDEX.size src */
 618
 619   prefix (0, 0, 0);
 620   dc = decode_dest23 (ddd, dd, w+1);
 621   bitindex = get_src (dc);
 622   tprintf ("bitindex set to %d\n", bitindex);
 623   goto next_opcode;
 624
 625   /** 1101 ddd0 dd01 0bit               BMcnd dest */
 626
 627   prefix (0, 0, 0);
 628   dc = decode_dest23 (ddd, dd, 1);
 629   if (condition_true (IMM (1)))
 630     put_bit2 (dc, bit, 1);
 631   else
 632     put_bit2 (dc, bit, 0);
 633
 634   /** 1101 1001 0c10 1cnd               BMcnd C */
 635
 636   prefix (0, 0, 0);
 637   if (condition_true (c * 8 + cnd))
 638     set_c (1);
 639   else
 640     set_c (0);
 641
 642   /** 0000 0001 1101 sss0 ss01 1bit     BNAND src */
 643
 644   prefix (0, 0, 0);
 645   sc = decode_src23 (sss, ss, 1);
 646   BIT_OPC (sc, bit, (!b) & carry);
 647
 648   /** 0000 0001 1101 sss0 ss11 0bit     BNOR src */
 649
 650   prefix (0, 0, 0);
 651   sc = decode_src23 (sss, ss, 1);
 652   BIT_OPC (sc, bit, (!b) | carry);
 653
 654   /** 1101 ddd0 dd01 1bit               BNOT dest */
 655
 656   prefix (0, 0, 0);
 657   dc = decode_dest23 (ddd, dd, 1);
 658   BIT_OP (dc, bit, !b);
 659
 660   /** 0000 0001 1101 sss0 ss00 0bit     BNTST src */
 661
 662   prefix (0, 0, 0);
 663   sc = decode_dest23 (sss, ss, 1);
 664   b = get_bit2 (sc, bit);
 665   set_zc (!b, !b);
 666
 667   /** 0000 0001 1101 sss0 ss11 1bit     BNXOR src */
 668
 669   prefix (0, 0, 0);
 670   sc = decode_src23 (sss, ss, 1);
 671   BIT_OPC (sc, bit, !b ^ carry);
 672
 673   /** 0000 0001 1101 sss0 ss10 0bit     BOR src */
 674
 675   prefix (0, 0, 0);
 676   sc = decode_src23 (sss, ss, 1);
 677   BIT_OPC (sc, bit, b | carry);
 678
 679   /** 0000 0000                         BRK */
 680
 681   /* We report the break to our caller with the PC still pointing at the
 682      breakpoint instruction.  */
 683   put_reg (pc, m32c_opcode_pc);
 684   if (verbose)
 685     printf("[break]\n");
 686   if (in_gdb || (regs.r_intbl == 0 && regs.r_intbh == 0))
 687     return M32C_MAKE_HIT_BREAK ();
 688   if (mem_get_qi (0xFFFFE7) == 0xff)
 689     trigger_based_interrupt (0);
 690   else
 691     trigger_fixed_interrupt (0xFFFFE4);
 692
 693   /** 1111 1110                         GBRK */
 694
 695   /* This alternate break, which is not part of the chip's opcode set,
 696    is here in case you need to debug a program that itself uses the
 697    chip's BRK opcode.  You'll need to modify your copy of GDB to use
 698    this opcode instead of the real BRK.  */
 699
 700   /* GDB Break. */
 701   /* We report the break to our caller with the PC still pointing at the
 702      breakpoint instruction.  */
 703   put_reg (pc, m32c_opcode_pc);
 704   if (verbose)
 705     printf("[gdb break]\n");
 706   return M32C_MAKE_HIT_BREAK ();
 707
 708   /** 0000 1000                         BRK2 */
 709
 710   if (verbose)
 711     printf("[break2]\n");
 712   if (in_gdb)
 713     return M32C_MAKE_HIT_BREAK ();
 714   if (mem_get_qi (0xFFFFE7) == 0xff)
 715     trigger_based_interrupt (0);
 716   else
 717     trigger_fixed_interrupt (0xFFFFE4);
 718
 719   /** 1101 ddd0 dd11 1bit               BSET dest */
 720
 721   dc = decode_dest23 (ddd, dd, 1);
 722   BIT_OP (dc, bit, 1);
 723
 724   /** 1101 sss0 ss00 0bit               BTST:G src */
 725
 726   prefix (0, 0, 0);
 727   sc = decode_src23 (sss, ss, 1);
 728   b = get_bit2 (sc, bit);
 729   set_zc (!b, b);
 730
 731   /** 00bb 101b                         BTST:S src */
 732
 733   sc = decode_src23 (3, 3, 1); /* bit,base:19 */
 734   b = get_bit2 (sc, bb*2 + b);
 735   set_zc (!b, b);
 736
 737   /** 1101 ddd0 dd10 0bit               BTSTC dest */
 738
 739   prefix (0, 0, 0);
 740   sc = decode_dest23 (ddd, dd, 1);
 741   b = get_bit2 (sc, bit);
 742   set_zc (!b, b);
 743   put_bit2 (sc, bit, 0);
 744
 745   /** 1101 ddd0 dd10 1bit               BTSTS dest */
 746
 747   prefix (0, 0, 0);
 748   sc = decode_dest23 (ddd, dd, 1);
 749   b = get_bit2 (sc, bit);
 750   set_zc (!b, b);
 751   put_bit2 (sc, bit, 1);
 752
 753   /** 0000 0001 1101 sss0 ss10 1bit     BXOR src */
 754
 755   prefix (0, 0, 0);
 756   sc = decode_src23 (sss, ss, 1);
 757   BIT_OPC (sc, bit, b ^ carry);
 758
 759   /** 0000 0001 1000 ddd w dd11 1110    CLIP.size #IMM1,#IMM2,dest */
 760
 761   prefix (0, 0, 0);
 762   dc = decode_dest23 (ddd, dd, w+1);
 763   a = sign_ext (IMM(w+1), w*8+8);
 764   b = sign_ext (IMM(w+1), w*8+8);
 765   v = sign_ext (get_src (dc), w*8+8);
 766   tprintf("clip %d <= %d <= %d : ", a, v, b);
 767   if (a > v)
 768     v = a;
 769   if (v > b)
 770     v = b;
 771   tprintf("%d\n", v);
 772   put_dest (dc, v);
 773
 774   /** 1001 ddd w dd10 1110              CMP.size:G #IMM,dest */
 775
 776   prefix (0, 1, 0);
 777   dc = decode_dest23 (ddd, dd, w+1);
 778   v = get_src (dc);
 779   imm = IMM(w+1);
 780   cmp (v, imm, w+1);
 781
 782   /** 1010 ddd0 dd11 0001               CMP.L:G #IMM32,dest */
 783
 784   prefix (0, 1, 0);
 785   dc = decode_dest23 (ddd, dd, 4);
 786   v = get_src (dc);
 787   imm = IMM(4);
 788   cmp (v, imm, 4);
 789
 790   /** 1110 ddd w dd01 immm              CMP.size:Q #IMM,dest */
 791
 792   prefix (0, 1, 0);
 793   dc = decode_dest23 (ddd, dd, w+1);
 794   v = get_src (dc);
 795   immm = sign_ext (immm, 4);
 796   cmp (v, immm, w+1);
 797
 798   /** 01dd 011w                         CMP.size:S #IMM,dest */
 799
 800   prefix (0, 1, 0);
 801   dc = decode_dest2 (dd, w+1);
 802   v = get_src (dc);
 803   imm = sign_ext (IMM(w+1),w*8+8);
 804   cmp (v, imm, w+1);
 805
 806   /** 1sss ddd w dd ss 0110             CMP.size:G src,dest */
 807
 808   prefix (1, 1, 0);
 809   sc = decode_src23 (sss, ss, w+1);
 810   dc = decode_dest23 (ddd, dd, w+1);
 811   a = get_src (dc);
 812   b = get_src (sc);
 813   cmp (a, b, w+1);
 814
 815   /** 1sss ddd1 dd ss 0001              CMP.L:G src,dest */
 816
 817   prefix (1, 1, 0);
 818   sc = decode_src23 (sss, ss, 4);
 819   dc = decode_dest23 (ddd, dd, 4);
 820   a = get_src (dc);
 821   b = get_src (sc);
 822   cmp (a, b, 4);
 823
 824   /** 01dd 000w                         CMP.size:S src,R0/R0L */
 825
 826   prefix (0, 1, 0);
 827   dc = decode_dest2 (dd, w+1);
 828   a = get_reg (w ? r0 : r0l);
 829   b = get_src (dc);
 830   cmp (a, b, w+1);
 831
 832   /** 1010 ddd0 dd01 0001               CMPX #IMM,dest */
 833
 834   prefix (0, 1, 0);
 835   dc = decode_dest23 (ddd, dd, 4);
 836   v = get_src (dc);
 837   imm = sign_ext (IMM(1), 8);
 838   cmp (v, imm, 4);
 839
 840   /** 0000 0001 1000 ddd w dd00 1110    DADC.size #IMM,dest */
 841
 842   DADDI(1,1);
 843
 844   /** 0000 0001 1sss ddd w dd ss 1000   DADC.size src,dest */
 845
 846   DADDV(1,1);
 847
 848   /** 0000 0001 1000 ddd w dd01 1110    DADD.size #IMM,dest */
 849
 850   DADDI(1,0);
 851
 852   /** 0000 0001 1sss ddd w dd ss 0000   DADD.size src,dest */
 853
 854   DADDV(1,0);
 855
 856   /** 1011 ddd w dd00 1110              DEC.size dest */
 857
 858   prefix (0, 1, 0);
 859   dc = decode_dest23 (ddd, dd, w+1);
 860   a = get_src (dc);
 861   v = a-1;
 862   tprintf ("%x -- = %x\n", a, v);
 863   set_sz (v, w+1);
 864   put_dest (dc, v);
 865
 866   /** 1011 0000 010w 0011               DIV.size #IMM */
 867
 868   prefix (0, 0, 0);
 869   div_op (-1, 0, 0, 0, w+1);
 870
 871   /** 1000 sss w ss01 1110              DIV.size src */
 872
 873   prefix (0, 1, 0);
 874   div_op (sss, ss, 0, 0, w+1);
 875
 876   /** 0000 0001 1010 sss1 ss01 1111     DIV.L src */
 877
 878   M32C_ONLY();
 879   prefix (0, 0, 0);
 880   div_op (sss, ss, 0, 0, 4);
 881
 882   /** 1011 0000 000w 0011               DIVU.size #IMM */
 883
 884   prefix (0, 0, 0);
 885   div_op (-1, 0, 1, 0, w+1);
 886
 887   /** 1000 sss w ss00 1110              DIVU.size src */
 888
 889   prefix (0, 1, 0);
 890   div_op (sss, ss, 1, 0, w+1);
 891
 892   /** 0000 0001 1010 sss1 ss00 1111     DIVU.L src */
 893
 894   M32C_ONLY();
 895   prefix (0, 0, 0);
 896   div_op (sss, ss, 1, 0, 4);
 897
 898   /** 1011 0010 010w 0011               DIVX.size #IMM */
 899
 900   prefix (0, 0, 0);
 901   div_op (-1, 0, 0, 1, w+1);
 902
 903   /** 1001 sss w ss01 1110              DIVX.size src */
 904
 905   prefix (0, 1, 0);
 906   div_op (sss, ss, 0, 1, w+1);
 907
 908   /** 0000 0001 1010 sss1 ss10 1111     DIVX.L src */
 909
 910   M32C_ONLY();
 911   prefix (0, 0, 0);
 912   div_op (sss, ss, 0, 1, 4);
 913
 914   /** 0000 0001 1001 ddd w dd00 1110    DSBB.size #IMM,dest */
 915
 916   DADDI(0,1);
 917
 918   /** 0000 0001 1sss ddd w dd ss 1010   DSBB.size src,dest */
 919
 920   DADDV(0,1);
 921
 922   /** 0000 0001 1001 ddd w dd01 1110    DSUB.size #IMM,dest */
 923
 924   DADDI(0,0);
 925
 926   /** 0000 0001 1sss ddd w dd ss 0010   DSUB.size src,dest */
 927
 928   DADDV(0,0);
 929
 930   /** 1110 1100                         ENTER #IMM */
 931
 932   imm = IMM(1);
 933   put_reg (sp, get_reg (sp) - 4);
 934   mem_put_si (get_reg (sp), get_reg (fb));
 935   put_reg (fb, get_reg (sp));
 936   put_reg (sp, get_reg (sp) - imm);
 937
 938   /** 1111 1100                         EXITD */
 939
 940   put_reg (sp, get_reg (fb));
 941   put_reg (fb, mem_get_si (get_reg (sp)));
 942   put_reg (sp, get_reg (sp) + 4);
 943   put_reg (pc, mem_get_si (get_reg (sp)));
 944   put_reg (sp, get_reg (sp) + 4);
 945
 946   /** 1100 ddd w dd01 1110              EXTS.size dest */
 947
 948   prefix (0, 0, 0);
 949   dc = decode_dest23 (ddd, dd, w+1);
 950   v = sign_ext (get_src (dc), (w+1)*8);
 951   dc = widen_sd (dc);
 952   put_dest (dc, v);
 953   set_sz (v, (w+1)*2);
 954
 955   /** 0000 0001 1sss ddd0 dd ss 0111    EXTS.B src,dest */
 956
 957   prefix (0, 0, 0);
 958   sc = decode_src23 (sss, ss, 1);
 959   dc = decode_dest23 (ddd, dd, 2);
 960   v = sign_ext (get_src (sc), 8);
 961   put_dest (dc, v);
 962   set_sz (v, 16);
 963
 964   /** 0000 0001 1sss ddd0 dd ss 1011    EXTZ src,dest */
 965
 966   prefix (0, 0, 0);
 967   sc = decode_src23 (sss, ss, 1);
 968   dc = decode_dest23 (ddd, dd, 2);
 969   v = get_src (sc);
 970   put_dest (dc, v);
 971   set_sz (v, 16);
 972
 973   /** 1101 0011 1110 1dst               FCLR dest */
 974
 975   set_flags (1 << dst, 0);
 976
 977   /** 1001 1111                         FREIT */
 978
 979   NOTYET();
 980
 981   /** 1101 0001 1110 1dst               FSET dest */
 982
 983   set_flags (1 << dst, 1 << dst);
 984
 985   /** 1010 ddd w dd00 1110              INC.size dest */
 986
 987   prefix (0, 1, 0);
 988   dc = decode_dest23 (ddd, dd, w+1);
 989   a = get_src (dc);
 990   v = a+1;
 991   tprintf ("%x ++ = %x\n", a, v);
 992   set_sz (v, w+1);
 993   put_dest (dc, v);
 994
 995   /** 1000 sss0 ss0w 0011               INDEXB.size src */
 996   INDEXOP(1, 1, 1);
 997   /** 1010 sss0 ss0w 0011               INDEXBD.size src */
 998   INDEXOP(1, 0, 1);
 999   /** 1100 sss0 ss0w 0011               INDEXBS.size src */
1000   INDEXOP(1, 1, 0);
1001   /** 1001 sss0 ss1w 0011               INDEXL.size src */
1002   INDEXOP(4, 1, 1);
1003   /** 1011 sss0 ss1w 0011               INDEXLD.size src */
1004   INDEXOP(4, 0, 1);
1005   /** 1001 sss0 ss0w 0011               INDEXLS.size src */
1006   INDEXOP(4, 1, 0);
1007   /** 1000 sss0 ss1w 0011               INDEXW.size src */
1008   INDEXOP(2, 1, 1);
1009   /** 1010 sss0 ss1w 0011               INDEXWD.size src */
1010   INDEXOP(2, 0, 1);
1011   /** 1100 sss0 ss1w 0011               INDEXWS.size src */
1012   INDEXOP(2, 1, 0);
1013
1014   /** 1011 1110 vector00                        INT #IMM */
1015
1016   prefix (0, 0, 0);
1017   trigger_based_interrupt (vector);
1018
1019   /** 1011 1111                         INTO */
1020
1021   prefix (0, 0, 0);
1022   if (FLAG_O)
1023     trigger_fixed_interrupt (0xffffe0);
1024
1025   /** 1ccc 101c                         Jcnd label */
1026
1027   prefix (0, 0, 0);
1028   v = sign_ext (IMM(1), 8);
1029   if (condition_true (ccc*2+c))
1030     put_reg (pc, m32c_opcode_pc + 1 + v);
1031
1032   /** 01dd 101d                         JMP.S label */
1033
1034   prefix (0, 0, 0);
1035   put_reg (pc, m32c_opcode_pc + (dd*2+d) + 2);
1036
1037   /** 1011 1011                         JMP.B label */
1038
1039   prefix (0, 0, 0);
1040   imm = sign_ext (IMM(1), 8);
1041   if (imm == -1)
1042     {
1043       if (verbose)
1044         printf("[jmp-to-self detected as exit]\n");
1045       return M32C_MAKE_HIT_BREAK ();
1046     }
1047   put_reg (pc, m32c_opcode_pc + 1 + imm);
1048
1049   /** 1100 1110                         JMP.W label */
1050
1051   prefix (0, 0, 0);
1052   imm = sign_ext (IMM(2), 16);
1053   put_reg (pc, m32c_opcode_pc + 1 + imm);
1054
1055   /** 1100 1100                         JMP.A label */
1056
1057   prefix (0, 0, 0);
1058   imm = IMM(3);
1059   put_reg (pc, imm);
1060
1061   /** 1100 sss1 ss00 1111               JMPI.W src */
1062
1063   prefix (0, 0, 0);
1064   sc = decode_src23 (sss, ss, 2);
1065   a = get_src (sc);
1066   a = sign_ext (a, 16);
1067   put_reg (pc, m32c_opcode_pc + a);
1068
1069   /** 1000 sss0 ss00 0001               JMPI.A src */
1070
1071   prefix (0, 0, 0);
1072   sc = decode_src23 (sss, ss, 3);
1073   a = get_src (sc);
1074   put_reg (pc, a);
1075
1076   /** 1101 1100                         JMPS #IMM8 */
1077
1078   prefix (0, 0, 0);
1079   imm = IMM(1);
1080   a = 0xff0000 + mem_get_hi (0xfffe00 - imm * 2);
1081   put_reg (pc, a);
1082
1083   /** 1100 1111                         JSR.W label */
1084
1085   prefix (0, 0, 0);
1086   imm = sign_ext (IMM(2), 16);
1087   put_reg (sp, get_reg (sp) - 4);
1088   mem_put_si (get_reg (sp), get_reg (pc));
1089   put_reg (pc, m32c_opcode_pc + imm + 1);
1090
1091   /** 1100 1101                         JSR.A label */
1092
1093   prefix (0, 0, 0);
1094   imm = IMM(3);
1095   put_reg (sp, get_reg (sp) - 4);
1096   mem_put_si (get_reg (sp), get_reg (pc));
1097   put_reg (pc, imm);
1098
1099   /** 1100 sss1 ss01 1111               JSRI.W src */
1100
1101   prefix (0, 0, 0);
1102   sc = decode_src23 (sss, ss, 2);
1103   a = get_src (sc);
1104   a = sign_ext (a, 16);
1105   put_reg (sp, get_reg (sp) - 4);
1106   mem_put_si (get_reg (sp), get_reg (pc));
1107   put_reg (pc, m32c_opcode_pc + a);
1108
1109   /** 1001 sss0 ss00 0001               JSRI.A src */
1110
1111   prefix (0, 0, 0);
1112   sc = decode_src23 (sss, ss, 3);
1113   a = get_src (sc);
1114   put_reg (sp, get_reg (sp) - 4);
1115   mem_put_si (get_reg (sp), get_reg (pc));
1116   put_reg (pc, a);
1117
1118   /** 1101 1101                         JSRS #IMM8 */
1119
1120   prefix (0, 0, 0);
1121   imm = IMM(1);
1122   a = 0xff0000 + mem_get_hi (0xfffe00 - imm * 2);
1123   put_reg (sp, get_reg (sp) - 4);
1124   mem_put_si (get_reg (sp), get_reg (pc));
1125   put_reg (pc, a);
1126
1127   /** 1101 0101 1010 1dst               LDC #IMM16,dest */
1128
1129   imm = IMM(2);
1130   dc = decode_cr_b (dst, CR_B_DCT0);
1131   put_dest (dc, imm);
1132
1133   /** 1101 0101 0010 1dst               LDC #IMM24,dest */
1134
1135   imm = IMM(3);
1136   dc = decode_cr_b (dst, CR_B_INTB);
1137   put_dest (dc, imm);
1138
1139   /** 1101 0101 0110 1dst               LDC #IMM24,dest */
1140
1141   imm = IMM(3);
1142   dc = decode_cr_b (dst, CR_B_DMA0);
1143   put_dest (dc, imm);
1144
1145   /** 0000 0001 1101 sss1 ss00 1dst     LDC src,dest */
1146
1147   prefix (0, 0, 0);
1148   sc = decode_src23 (sss, ss, 2);
1149   dc = decode_cr_b (dst, CR_B_DCT0);
1150   a = get_src (sc);
1151   put_dest (dc, a);
1152
1153   /** 1101 sss1 ss00 0dst               LDC src,dest */
1154
1155   prefix (0, 0, 0);
1156   sc = decode_src23 (sss, ss, 3);
1157   dc = decode_cr_b (dst, CR_B_INTB);
1158   a = get_src (sc);
1159   put_dest (dc, a);
1160
1161   /** 0000 0001 1101 sss1 ss00 0dst     LDC src,dest */
1162
1163   prefix (0, 0, 0);
1164   sc = decode_src23 (sss, ss, 3);
1165   dc = decode_cr_b (dst, CR_B_DMA0);
1166   a = get_src (sc);
1167   put_dest (dc, a);
1168
1169   /** 1011 0110 1100 0011               LDCTX */
1170
1171   NOTYET();
1172
1173   /** 1101 0101 1110 1imm               LDIPL #IMM */
1174
1175   set_flags (0x7000, imm*0x1000);
1176
1177   /** 0000 0001 1000 ddd w dd11 1111    MAX.size #IMM,dest */
1178
1179   prefix (0, 0, 0);
1180   w++;
1181   dc = decode_dest23 (ddd, dd, w);
1182   imm = sign_ext (IMM(w), w*8);
1183   a = sign_ext (get_src (dc), w*8);
1184   tprintf ("max %d %d\n", imm, a);
1185   if (imm > a)
1186     put_dest (dc, imm);
1187
1188   /** 0000 0001 1sss ddd w dd ss 1101   MAX.size src,dest */
1189
1190   prefix (0, 0, 0);
1191   w++;
1192   sc = decode_src23 (sss, ss, w);
1193   dc = decode_dest23 (ddd, dd, w);
1194   b = sign_ext (get_src (sc), w*8);
1195   a = sign_ext (get_src (dc), w*8);
1196   tprintf ("max %d %d\n", b, a);
1197   if (b > a)
1198     put_dest (dc, b);
1199
1200   /** 0000 0001 1000 ddd w dd10 1111    MIN.size #IMM,dest */
1201
1202   prefix (0, 0, 0);
1203   w++;
1204   dc = decode_dest23 (ddd, dd, w);
1205   imm = sign_ext (IMM(w), w*8);
1206   a = sign_ext (get_src (dc), w*8);
1207   tprintf ("min %d %d\n", imm, a);
1208   if (imm < a)
1209     put_dest (dc, imm);
1210
1211   /** 0000 0001 1sss ddd w dd ss 1100   MIN.size src,dest */
1212
1213   prefix (0, 0, 0);
1214   w++;
1215   sc = decode_src23 (sss, ss, w);
1216   dc = decode_dest23 (ddd, dd, w);
1217   b = sign_ext (get_src (sc), w*8);
1218   a = sign_ext (get_src (dc), w*8);
1219   tprintf ("min %d %d\n", b, a);
1220   if (b < a)
1221     put_dest (dc, b);
1222
1223   /** 1001 ddd w dd10 1111              MOV.size:G #IMM,dest */
1224
1225   dc = decode_dest23 (ddd, dd, w+1);
1226   imm = IMM(w+1);
1227   v = imm;
1228   tprintf("%x = %x\n", v, v);
1229   set_sz(v, w+1);
1230   put_dest (dc, v);
1231
1232   /** 1011 ddd0 dd11 0001               MOV.L:G #IMM,dest */
1233
1234   dc = decode_dest23 (ddd, dd, 4);
1235   imm = IMM(4);
1236   v = imm;
1237   tprintf("%x = %x\n", v, v);
1238   set_sz(v, 4);
1239   put_dest (dc, v);
1240
1241   /** 1111 ddd w dd10 immm              MOV.size:Q #IMM4,dest */
1242
1243   dc = decode_dest23 (ddd, dd, w+1);
1244   imm = sign_ext (immm, 4);
1245   v = imm;
1246   tprintf("%x = %d\n", v, v);
1247   set_sz(v, w+1);
1248   put_dest (dc, v);
1249
1250   /** 00dd 010w                         MOV.size:S #IMM,dest */
1251
1252   prefix (0, 1, 0);
1253   dc = decode_dest2 (dd, w+1);
1254   imm = IMM(w+1);
1255   put_dest (dc, imm);
1256   set_sz (imm, w+1);
1257
1258   /** 10w1 110d                         MOV.size:S #IMM,a0/a1 */
1259
1260   imm = IMM(w ? 3 : 2);
1261   put_reg (d ? a1 : a0, imm);
1262   set_sz (imm & addr_mask, w+1);
1263
1264   /** 00dd 001w                         MOV.size:Z #0,dest */
1265
1266   prefix (0, 1, 0);
1267   dc = decode_dest2 (dd, w+1);
1268   put_dest (dc, 0);
1269   set_sz (0, w+1);
1270
1271   /** 1sss ddd w dd ss 1011             MOV.size:G src,dest */
1272
1273   prefix (1, 1, 0);
1274   sc = decode_src23 (sss, ss, w+1);
1275   dc = decode_dest23 (ddd, dd, w+1);
1276   v = get_src (sc);
1277   put_dest (dc, v);
1278   set_sz (v, w+1);
1279
1280   /** 1sss ddd1 dd ss 0011              MOV.L:G src,dest */
1281
1282   prefix (1, 1, 0);
1283   sc = decode_src23 (sss, ss, 4);
1284   dc = decode_dest23 (ddd, dd, 4);
1285   v = get_src (sc);
1286   put_dest (dc, v);
1287   set_sz (v, 4);
1288
1289   /** VARY SS 01 10 11 */
1290   /** 00SS 100w                         MOV.size:S src,R0L/R0 */
1291
1292   prefix (0, 1, 0);
1293   sc = decode_dest2 (SS, w+1);
1294   v = get_src (sc);
1295   put_reg (w ? r0 : r0l, v);
1296   set_sz (v, w+1);
1297
1298   /** 01ss 111w                         MOV.size:S src,R1L/R1 */
1299
1300   prefix (0, 1, 0);
1301   sc = decode_dest2 (ss, w+1);
1302   v = get_src (sc);
1303   put_reg (w ? r1 : r1l, v);
1304   set_sz (v, w+1);
1305
1306   /** VARY DD 01 10 11 */
1307   /** 00DD 000w                         MOV.size:S R0L/R0,dest */
1308
1309   prefix (0, 1, 0);
1310   dc = decode_dest2 (DD, w+1);
1311   v = get_reg (w ? r0 : r0l);
1312   put_dest (dc, v);
1313   set_sz (v, w+1);
1314
1315   /** 01ss 100d                         MOV.L:S src,A0/A1 */
1316
1317   prefix (0, 1, 0);
1318   sc = decode_dest2 (ss, 4);
1319   v = get_src (sc);
1320   put_reg (d ? a1 : a0, v);
1321   set_sz (v, 4);
1322
1323   /** 1011 ddd w dd00 1111              MOV.size:G dsp:8[SP], dest */
1324
1325   prefix (0, 0, 0);
1326   imm = IMM(1);
1327   dc = decode_dest23 (ddd, dd, w+1);
1328   a = get_reg (sp) + sign_ext (imm, 8);
1329   a &= addr_mask;
1330   if (w)
1331     v = mem_get_hi (a);
1332   else
1333     v = mem_get_qi (a);
1334   put_dest (dc, v);
1335   set_sz (v, w+1);
1336
1337   /** 1010 sss w ss00 1111              MOV.size:G src,dsp:8[SP] */
1338
1339   prefix (0, 0, 0);
1340   sc = decode_dest23 (sss, ss, w+1);
1341   imm = IMM(1);
1342   a = get_reg (sp) + sign_ext (imm, 8);
1343   a &= addr_mask;
1344   v = get_src (sc);
1345   if (w)
1346     mem_put_hi (a, v);
1347   else
1348     mem_put_qi (a, v);
1349   set_sz (v, w+1);
1350
1351   /** 1101 sss1 ss01 1dst               MOVA src,dest */
1352
1353   {
1354   static reg_id map[8] = { r2r0, r3r1, a0, a1 };
1355   prefix (0, 0, 0);
1356   sc = decode_src23 (sss, ss, 1);
1357   if (!sc.mem || !map[dst])
1358     UNSUPPORTED();
1359   put_reg (map[dst], sc.u.addr);
1360   }
1361
1362   /** 0000 0001 1011 ddd0 dd hl 1110    MOVdir R0L,dest */
1363
1364   prefix (0, 0, 0);
1365   dc = decode_dest23 (ddd, dd, 1);
1366   a = get_src (dc);
1367   b = get_reg (r0l);
1368   switch (hl)
1369     {
1370     case 0: a = (a & 0xf0) | (b & 0x0f); break;
1371     case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break;
1372     case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break;
1373     case 3: a = (a & 0x0f) | (b & 0xf0); break;
1374     }
1375   put_dest (dc, a);
1376
1377   /** 0000 0001 1010 sss0 ss hl 1110    MOVdir src,R0L */
1378
1379   prefix (0, 0, 0);
1380   sc = decode_dest23 (sss, ss, 1);
1381   a = get_reg (r0l);
1382   b = get_src (dc);
1383   switch (hl)
1384     {
1385     case 0: a = (a & 0xf0) | (b & 0x0f); break;
1386     case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break;
1387     case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break;
1388     case 3: a = (a & 0x0f) | (b & 0xf0); break;
1389     }
1390   put_reg (r0l, a);
1391
1392   /** 1011 ddd0 dd01 0001               MOVX #IMM,dest */
1393
1394   prefix (0, 1, 0);
1395   dc = decode_dest23 (ddd, dd, 4);
1396   imm = sign_ext (IMM(1), 8);
1397   put_dest (dc, imm);
1398   set_sz (imm, 1);
1399
1400   /** 1000 ddd w dd01 1111              MUL.size #IMM,dest */
1401
1402   prefix (0, 1, 0);
1403   w ++;
1404   dc = decode_dest23 (ddd, dd, w);
1405   v = sign_ext (get_src (dc), w*8);
1406   imm = sign_ext (IMM(w), w*8);
1407   tprintf("%d * %d = %d\n", v, imm, v*imm);
1408   v *= imm;
1409   dc = widen_sd (dc);
1410   put_dest (dc, v);
1411
1412   /** 1sss ddd w dd ss 1100             MUL.size src,dest */
1413
1414   prefix (1, 1, 0);
1415   w ++;
1416   sc = decode_src23 (sss, ss, w);
1417   dc = decode_dest23 (ddd, dd, w);
1418   a = sign_ext (get_src (sc), w*8);
1419   b = sign_ext (get_src (dc), w*8);
1420   tprintf("%d * %d = %d\n", a, b, a*b);
1421   v = a * b;
1422   dc = widen_sd (dc);
1423   put_dest (dc, v);
1424
1425   /** 0000 0001 1000 sss1 ss01 1111     MUL.L src,R2R0 */
1426
1427   M32C_ONLY();
1428   prefix (0, 0, 0);
1429   sc = decode_src23 (sss, ss, 4);
1430   a = sign_ext (get_src (sc), 32);
1431   b = sign_ext (get_reg (r2r0), 32);
1432   ll = (long long)a * (long long)b;
1433   tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll);
1434   if (ll < b2minsigned[4] || ll > b2maxsigned[4])
1435     set_flags (FLAGBIT_O, FLAGBIT_O);
1436   else
1437     set_flags (FLAGBIT_O, 0);
1438   put_reg (r2r0, (int)ll);
1439
1440   /** 1100 sss1 ss11 1110               MULEX src */
1441
1442   prefix (0, 1, 0);
1443   sc = decode_dest23 (sss, ss, 2);
1444   a = sign_ext (get_src (sc), 16);
1445   b = sign_ext (get_reg (r2r0), 32);
1446   ll = (long long)a * (long long)b;
1447   tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll);
1448   put_reg (r2r0, (int)ll);
1449   put_reg (r1, (int)(ll >> 32));
1450
1451   /** 1000 ddd w dd00 1111              MULU.size #IMM,dest */
1452
1453   prefix (0, 1, 0);
1454   w ++;
1455   dc = decode_dest23 (ddd, dd, w);
1456   v = get_src (dc);
1457   imm = IMM(w);
1458   tprintf("%d * %d = %d\n", v, imm, v*imm);
1459   v *= imm;
1460   dc = widen_sd (dc);
1461   put_dest (dc, v);
1462
1463   /** 1sss ddd w dd ss 0100             MULU.size src,dest */
1464
1465   prefix (1, 1, 0);
1466   w ++;
1467   sc = decode_src23 (sss, ss, w);
1468   dc = decode_dest23 (ddd, dd, w);
1469   a = get_src (sc);
1470   b = get_src (dc);
1471   tprintf("%d * %d = %d\n", a, b, a*b);
1472   v = a * b;
1473   dc = widen_sd (dc);
1474   put_dest (dc, v);
1475
1476   /** 0000 0001 1000 sss1 ss00 1111     MULU.L src,R2R0 */
1477
1478   M32C_ONLY();
1479   prefix (0, 0, 0);
1480   sc = decode_src23 (sss, ss, 4);
1481   a = get_src (sc);
1482   b = get_reg (r2r0);
1483   ll = (long long)a * (long long)b;
1484   tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll);
1485   if (ll < b2minsigned[4] || ll > b2maxsigned[4])
1486     set_flags (FLAGBIT_O, FLAGBIT_O);
1487   else
1488     set_flags (FLAGBIT_O, 0);
1489   put_reg (r2r0, (int)ll);
1490
1491   /** 1010 ddd w dd10 1111              NEG.size dest */
1492
1493   prefix (0, 1, 0);
1494   dc = decode_dest23 (ddd, dd, w+1);
1495   a = sign_ext (get_src (dc), (w+1)*8);
1496   v = -a;
1497   tprintf("%d * -1 = %d\n", a, v);
1498   set_oszc(v, w+1, v==0);
1499   put_dest (dc, v);
1500
1501   /** 1101 1110                         NOP */
1502
1503   tprintf("nop\n");
1504
1505   /** 1010 ddd w dd01 1110              NOT.size dest */
1506
1507   prefix (0, 1, 0);
1508   dc = decode_dest23 (ddd, dd, w+1);
1509   a = get_src (dc);
1510   v = ~a;
1511   tprintf("~ %x = %x\n", a, v);
1512   set_sz(v, w+1);
1513   put_dest (dc, v);
1514
1515   /** 1000 ddd w dd10 1111              OR.size:G #IMM,dest */
1516
1517   prefix (0, 1, 0);
1518   dc = decode_dest23(ddd, dd, w+1);
1519   imm = IMM(w+1);
1520   LOGIC_OP (dc, imm, |);
1521
1522   /** 01dd 010w                         OR.size:S #IMM,dest */
1523
1524   prefix (0, 1, 0);
1525   dc = decode_dest2(dd, w+1);
1526   imm = IMM (w+1);
1527   LOGIC_OP (dc, imm, |);
1528
1529   /** 1sss ddd w dd ss 0101             OR.size:G src,dest */
1530
1531   prefix (1, 1, 0);
1532   sc = decode_src23(sss, ss, w+1);
1533   dc = decode_dest23(ddd, dd, w+1);
1534   b = get_src (sc);
1535   LOGIC_OP (dc, b, |);
1536
1537   /** 1011 ddd w dd10 1111              POP.size dest */
1538
1539   prefix (0, 1, 0);
1540   dc = decode_dest23 (ddd, dd, w+1);
1541   if (w)
1542     a = mem_get_hi (get_reg (sp));
1543   else
1544     a = mem_get_qi (get_reg (sp));
1545   put_reg (sp, get_reg (sp) + 2);
1546   tprintf("pop%s: %x\n", w ? "hi" : "qi", a);
1547   put_dest (dc, a);
1548
1549   /** 1101 0011 1010 1dst               POPC dest */
1550
1551   prefix (0, 0, 0);
1552   dc = decode_cr_b (dst, CR_B_DCT0);
1553   a = mem_get_hi (get_reg (sp));
1554   put_reg (sp, get_reg (sp) + 2);
1555   tprintf("pophi: %x\n", a);
1556   put_dest (dc, a);
1557
1558   /** 1101 0011 0010 1dst               POPC dest */
1559
1560   prefix (0, 0, 0);
1561   dc = decode_cr_b (dst, CR_B_INTB);
1562   a = mem_get_si (get_reg (sp));
1563   put_reg (sp, get_reg (sp) + 4);
1564   tprintf("popsi: %x\n", a);
1565   put_dest (dc, a);
1566
1567   /** 1000 1110                         POPM dest */
1568
1569   {
1570   static int map[] = { r0, r1, r2, r3, a0, a1, sb, fb };
1571   prefix (0, 0, 0);
1572   imm = IMM(1);
1573   tprintf("popm: %x\n", imm);
1574   for (a=0; a<4; a++)
1575     if (imm & (1<<a))
1576       {
1577         v = mem_get_hi (get_reg (sp));
1578         put_reg (map[a], v);
1579         put_reg (sp, get_reg (sp) + 2);
1580       }
1581   for (; a<8; a++)
1582     if (imm & (1<<a))
1583       {
1584         v = mem_get_si (get_reg (sp));
1585         put_reg (map[a], v);
1586         put_reg (sp, get_reg (sp) + 4);
1587       }
1588   }
1589
1590   /** 1010 111w                         PUSH.size #IMM */
1591
1592   {
1593   int a;
1594   prefix (0, 0, 0);
1595   imm = IMM(w+1);
1596   tprintf("push%s: %x\n", w ? "hi" : "qi", imm);
1597   a = get_reg (sp) - 2;
1598   if (w)
1599     mem_put_hi (a, imm);
1600   else
1601     mem_put_qi (a, imm);
1602   put_reg (sp, a);
1603   }
1604
1605   /** 1100 sss w ss00 1110              PUSH.size src */
1606
1607   prefix (0, 1, 0);
1608   sc = decode_dest23 (sss, ss, w+1);
1609   a = get_src (sc);
1610   put_reg (sp, get_reg (sp) - 2);
1611   if (w)
1612     mem_put_hi (get_reg (sp), a);
1613   else
1614     mem_put_qi (get_reg (sp), a);
1615   tprintf("push%s: %x\n", w ? "hi" : "qi", a);
1616
1617   /** 1011 0110 0101 0011               PUSH.L #IMM32 */
1618
1619   imm = IMM(4);
1620   put_reg (sp, get_reg (sp) - 4);
1621   mem_put_si (get_reg (sp), imm);
1622
1623   /** 1010 sss0 ss00 0001               PUSH.L src */
1624
1625   prefix (0, 1, 0);
1626   sc = decode_dest23 (sss, ss, 4);
1627   a = get_src (sc);
1628   put_reg (sp, get_reg (sp) - 4);
1629   mem_put_si (get_reg (sp), a);
1630
1631   /** 1011 0sa0 ss00 0001               PUSHA src */
1632
1633   prefix (0, 0, 0);
1634   sc = decode_dest23 (sa, ss, 1);
1635   put_reg (sp, get_reg (sp) - 4);
1636   mem_put_hi (get_reg (sp), sc.u.addr);
1637   tprintf("pushsi: %x\n", sc.u.addr);
1638
1639   /** 1101 0001 1010 1src               PUSHC src */
1640
1641   prefix (0, 0, 0);
1642   sc = decode_cr_b (src, CR_B_DCT0);
1643   a = get_src (sc);
1644   put_reg (sp, get_reg (sp) - 2);
1645   mem_put_hi (get_reg (sp), a);
1646   tprintf("pushhi: %x\n", a);
1647
1648   /** 1101 0001 0010 1src               PUSHC src */
1649
1650   prefix (0, 0, 0);
1651   sc = decode_cr_b (src, CR_B_INTB);
1652   a = get_src (sc);
1653   put_reg (sp, get_reg (sp) - 4);
1654   mem_put_si (get_reg (sp), a);
1655   tprintf("pushsi: %x\n", a);
1656
1657   /** 1000 1111                         PUSHM src */
1658
1659   {
1660   static int map[] = { fb, sb, a1, a0, r3, r2, r1, r0 };
1661   imm = IMM(1);
1662   tprintf("pushm: %x\n", imm);
1663   for (a=0; a<4; a++)
1664     if (imm & (1<<a))
1665       {
1666         put_reg (sp, get_reg (sp) - 4);
1667         v = get_reg (map[a]);
1668         mem_put_si (get_reg (sp), v);
1669       }
1670   for (; a<8; a++)
1671     if (imm & (1<<a))
1672       {
1673         put_reg (sp, get_reg (sp) - 2);
1674         v = get_reg (map[a]);
1675         mem_put_hi (get_reg (sp), v);
1676       }
1677   }
1678
1679   /** 1001 1110                         REIT */
1680
1681   a = get_reg (sp);
1682   put_reg (pc, mem_get_si (a));
1683   a += 4;
1684   put_reg (flags, mem_get_hi (a));
1685   a += 2;
1686   put_reg (sp, a);
1687
1688   /** 1011 1000 010w 0011               RMPA.size */
1689
1690   {
1691   int count = get_reg (r3);
1692   int list1 = get_reg (a0);
1693   int list2 = get_reg (a1);
1694   long long sum = get_reg_ll (r3r1r2r0) & 0xffffff;
1695
1696   while (count)
1697     {
1698       if (w)
1699         {
1700           a = sign_ext (mem_get_hi (list1), 16);
1701           b = sign_ext (mem_get_hi (list2), 16);
1702         }
1703       else
1704         {
1705           a = sign_ext (mem_get_qi (list1), 8);
1706           b = sign_ext (mem_get_qi (list2), 8);
1707         }
1708       tprintf("%lld + %d * %d = ", sum, a, b);
1709       sum += a * b;
1710       tprintf("%lld\n", sum);
1711       list1 += w ? 2 : 1;
1712       list2 += w ? 2 : 1;
1713       count --;
1714     }
1715   put_reg (r3, count);
1716   put_reg (a0, list1);
1717   put_reg (a1, list2);
1718   put_reg (r2r0, (int)(sum & 0xffffffffU));
1719   put_reg (r1, (int)(sum >> 32));
1720   }
1721
1722   /** 1011 ddd w dd10 1110              ROLC.size dest */
1723
1724   prefix (0, 1, 0);
1725   dc = decode_dest23 (ddd, dd, w+1);
1726   rot_op (dc, 1, 1);
1727
1728   /** 1010 ddd w dd10 1110              RORC.size dest */
1729
1730   prefix (0, 1, 0);
1731   dc = decode_dest23 (ddd, dd, w+1);
1732   rot_op (dc, 1, -1);
1733
1734   /** 1110 ddd w dd10 immm              ROT.size #IMM, dest */
1735
1736   prefix (0, 1, 0);
1737   dc = decode_dest23 (ddd, dd, w+1);
1738   rot_op (dc, IMM4(), -1);
1739
1740   /** 1010 ddd w dd11 1111              ROT.size R1H,dest */
1741
1742   prefix (0, 1, 0);
1743   dc = decode_dest23 (ddd, dd, w+1);
1744   a = sign_ext (get_reg (r1h), 8);
1745   rot_op (dc, a, -1);
1746
1747   /** 1101 1111                         RTS */
1748
1749   put_reg (pc, mem_get_si (get_reg (sp)));
1750   put_reg (sp, get_reg (sp) + 4);
1751
1752   /** 0000 0001 1001 ddd w dd10 1110    SBB.size #IMM, dest */
1753
1754   prefix (0, 0, 0);
1755   dc = decode_dest23 (ddd, dd, w+1);
1756   imm = IMM (w+1);
1757   MATH_OP (dc, imm, !carry, -);
1758
1759   /** 0000 0001 1sss ddd w dd ss 0110   SBB.size src,dest */
1760
1761   prefix (0, 0, 0);
1762   sc = decode_src23 (sss, ss, w+1);
1763   dc = decode_dest23 (ddd, dd, w+1);
1764   MATH_OP (dc, get_src (sc), !carry, -);
1765
1766   /** 1101 ddd1 dd11 cond               SCcond dest */
1767
1768   prefix (0, 1, 0);
1769   dc = decode_dest23 (ddd, dd, 2);
1770   if (condition_true (cond))
1771     put_dest (dc, 1);
1772   else
1773     put_dest (dc, 0);
1774
1775   /** 1011 1000 110w 0011               SCMPU.size */
1776
1777   ta0 = get_reg (a0);
1778   ta1 = get_reg (a1);
1779
1780   for (;;)
1781     {
1782       t0 = mem_get_qi (ta0);
1783       t2 = mem_get_qi (ta1);
1784       if (w)
1785         {
1786           t1 = mem_get_qi (ta0 + 1);
1787           t3 = mem_get_qi (ta1 + 1);
1788         }
1789       dif = t0 - t2;
1790       if (dif == 0 && t0 != 0 && w)
1791         dif = t1 - t3;
1792       set_oszc (dif, 1, dif > 0);
1793
1794       ta0 += w ? 2 : 1;
1795       ta1 += w ? 2 : 1;
1796
1797       if (t0 == 0 || t0 != t2)
1798         break;
1799       if (w && (t1 == 0 || t1 != t3))
1800         break;
1801     }
1802
1803   /** 1111 ddd w dd00 immm              SHA.size #IMM,dest */
1804
1805   prefix (0, 1, 0);
1806   dc = decode_dest23 (ddd, dd, w+1);
1807   shift_op (dc, 1, IMM4(), 1);
1808
1809   /** 1010 ddd0 dd10 0001               SHA.L #IMM,dest */
1810
1811   prefix (0, 1, 0);
1812   dc = decode_dest23 (ddd, dd, 4);
1813   imm = sign_ext (IMM(1), 8);
1814   shift_op (dc, 1, imm, 1);
1815
1816   /** 1011 ddd w dd11 1110              SHA.size R1H,dest */
1817
1818   prefix (0, 1, 0);
1819   dc = decode_dest23 (ddd, dd, w+1);
1820   a = sign_ext (get_reg (r1h), 8);
1821   shift_op (dc, 1, a, 1);
1822
1823   /** 1100 ddd0 dd01 0001               SHA.L   R1H,dest */
1824
1825   prefix (0, 1, 0);
1826   dc = decode_dest23 (ddd, dd, 4);
1827   a = sign_ext (get_reg (r1h), 8);
1828   shift_op (dc, 1, a, 1);
1829
1830   /** 1100 ddd0 dd10 0001               SHANC.L #IMM,dest */
1831
1832   M32C_ONLY();
1833   prefix (0, 1, 0);
1834   dc = decode_dest23 (ddd, dd, 4);
1835   imm = sign_ext (IMM(1), 8);
1836   shift_op (dc, 1, imm, 0);
1837
1838   /** 1110 ddd w dd00 immm              SHL.size #IMM, dest */
1839
1840   prefix (0, 1, 0);
1841   dc = decode_dest23 (ddd, dd, w+1);
1842   shift_op (dc, 0, IMM4(), 1);
1843
1844   /** 1001 ddd0 dd10 0001               SHL.L #IMM, dest */
1845
1846   prefix (0, 1, 0);
1847   dc = decode_dest23 (ddd, dd, 4);
1848   imm = sign_ext (IMM(1), 8);
1849   shift_op (dc, 0, imm, 1);
1850
1851   /** 1010 ddd w dd11 1110              SHL.size R1H,dest */
1852
1853   prefix (0, 1, 0);
1854   dc = decode_dest23 (ddd, dd, w+1);
1855   a = sign_ext (get_reg (r1h), 8);
1856   shift_op (dc, 0, a, 1);
1857
1858   /** 1100 ddd0 dd00 0001               SHL.L R1H,dest */
1859
1860   prefix (0, 1, 0);
1861   dc = decode_dest23 (ddd, dd, 4);
1862   a = sign_ext (get_reg (r1h), 8);
1863   shift_op (dc, 0, a, 1);
1864
1865   /** 1000 ddd0 dd10 0001               SHLNC.L #IMM,dest */
1866
1867   M32C_ONLY();
1868   prefix (0, 1, 0);
1869   dc = decode_dest23 (ddd, dd, 4);
1870   imm = sign_ext (IMM(1), 8);
1871   shift_op (dc, 0, imm, 0);
1872
1873   /** 1011 0010 100w 0011               SIN.size */
1874
1875   v = get_reg (a0);
1876   a = get_reg (a1);
1877   b = get_reg (r3);
1878   if (b) for (;b;)
1879     {
1880       if (w)
1881         mem_put_hi(a, mem_get_hi (v));
1882       else
1883         mem_put_qi(a, mem_get_qi (v));
1884       a += w ? 2 : 1;
1885       b --;
1886     }
1887   put_reg (a0, v);
1888   put_reg (a1, a);
1889   put_reg (r3, b);
1890
1891   /** 1011 0110 100w 0011               SMOVB.size */
1892
1893   v = get_reg (a0);
1894   a = get_reg (a1);
1895   b = get_reg (r3);
1896   if (b) for (;b;)
1897     {
1898       if (w)
1899         mem_put_hi(a, mem_get_hi (v));
1900       else
1901         mem_put_qi(a, mem_get_qi (v));
1902       v -= w ? 2 : 1;
1903       a -= w ? 2 : 1;
1904       b --;
1905     }
1906   put_reg (a0, v);
1907   put_reg (a1, a);
1908   put_reg (r3, b);
1909
1910   /** 1011 0000 100w 0011               SMOVF.size */
1911
1912   v = get_reg (a0);
1913   a = get_reg (a1);
1914   b = get_reg (r3);
1915   if (b) for (;b;)
1916     {
1917       if (w)
1918         mem_put_hi(a, mem_get_hi (v));
1919       else
1920         mem_put_qi(a, mem_get_qi (v));
1921       v += w ? 2 : 1;
1922       a += w ? 2 : 1;
1923       b --;
1924     }
1925   put_reg (a0, v);
1926   put_reg (a1, a);
1927   put_reg (r3, b);
1928
1929   /** 1011 1000 100w 0011               SMOVU.size */
1930
1931   v = get_reg (a0);
1932   a = get_reg (a1);
1933   do
1934     {
1935       if (w)
1936         mem_put_hi(a, (t0 = mem_get_hi (v)));
1937       else
1938         mem_put_qi(a, (t0 = mem_get_qi (v)));
1939       v += w ? 2 : 1;
1940       a += w ? 2 : 1;
1941       if (t0 == 0
1942           || (w && ((t0 & 0xff) == 0 || (t0 & 0xff00) == 0)))
1943         break;
1944     } while (1);
1945   put_reg (a0, v);
1946   put_reg (a1, a);
1947
1948   /** 1011 0100 100w 0011               SOUT.size */
1949
1950   v = get_reg (a0);
1951   a = get_reg (a1);
1952   b = get_reg (r3);
1953   for (;b;)
1954     {
1955       if (w)
1956         mem_put_hi(a, mem_get_hi (v));
1957       else
1958         mem_put_qi(a, mem_get_qi (v));
1959       v += w ? 2 : 1;
1960       b --;
1961     }
1962   put_reg (a0, v);
1963   put_reg (a1, a);
1964   put_reg (r3, b);
1965
1966   /** 1011 1000 000w 0011               SSTR.size */
1967
1968   a = get_reg (a1);
1969   b = get_reg (r3);
1970   v = get_reg (w ? r0 : r0l);
1971   for (;b;)
1972     {
1973       if (w)
1974         mem_put_hi(a, v);
1975       else
1976         mem_put_qi(a, v);
1977       a += w ? 2 : 1;
1978       b --;
1979     }
1980   put_reg (a1, a);
1981   put_reg (r3, b);
1982
1983   /** 0000 0001 1101 ddd1 dd01 0src     STC src,dest */
1984
1985   prefix (0, 0, 0);
1986   dc = decode_dest23 (ddd, dd, 4);
1987   sc = decode_cr_b (src, CR_B_DMA0);
1988   a = get_src (sc);
1989   put_dest (dc, a);
1990
1991   /** 0000 0001 1101 ddd1 dd01 1src     STC src,dest */
1992
1993   prefix (0, 0, 0);
1994   dc = decode_dest23 (ddd, dd, 2);
1995   sc = decode_cr_b (src, CR_B_DCT0);
1996   a = get_src (sc);
1997   put_dest (dc, a);
1998
1999   /** 1101 ddd1 dd01 0src               STC src,dest */
2000
2001   prefix (0, 0, 0);
2002   dc = decode_dest23 (ddd, dd, 4);
2003   sc = decode_cr_b (src, CR_B_INTB);
2004   a = get_src (sc);
2005   put_dest (dc, a);
2006
2007   /** 1011 0110 1101 0011               STCX abs16,abs24 */
2008
2009   NOTYET();
2010
2011   /** 1001 ddd w dd01 1111              STNZ.size #IMM,dest */
2012
2013   prefix (0, 1, 0);
2014   dc = decode_dest23 (ddd, dd, w+1);
2015   imm = IMM(w+1);
2016   if (! FLAG_Z)
2017     put_dest (dc, imm);
2018
2019   /** 1001 ddd w dd00 1111              STZ.size #IMM,dest */
2020
2021   prefix (0, 1, 0);
2022   dc = decode_dest23 (ddd, dd, w+1);
2023   imm = IMM(w+1);
2024   if (FLAG_Z)
2025     put_dest (dc, imm);
2026
2027   /** 1001 ddd w dd11 1111              STZX.size #IMM1,#IMM2,dest */
2028
2029   prefix (0, 1, 0);
2030   dc = decode_dest23 (ddd, dd, w+1);
2031   a = IMM(w+1);
2032   b = IMM(w+1);
2033   if (FLAG_Z)
2034     put_dest (dc, a);
2035   else
2036     put_dest (dc, b);
2037
2038   /** 1000 ddd w dd11 1110              SUB.size:G #IMM,dest */
2039
2040   prefix (0, 1, 0);
2041   dc = decode_dest23(ddd, dd, w+1);
2042   imm = IMM(w+1);
2043   MATH_OP (dc, imm, 0, -);
2044
2045   /** 1001 ddd0 dd11 0001               SUB.L:G #IMM,dest */
2046
2047   prefix (0, 1, 0);
2048   dc = decode_dest23(ddd, dd, 4);
2049   imm = IMM(4);
2050   MATH_OP (dc, imm, 0, -);
2051
2052   /** 00dd 111w                         SUB.size:S #IMM,dest */
2053
2054   prefix (0, 1, 0);
2055   dc = decode_dest2(dd, w+1);
2056   imm = IMM (w+1);
2057   MATH_OP (dc, imm, 0, -);
2058
2059   /** 1sss ddd w dd ss 1010             SUB.size:G src,dest */
2060
2061   prefix (1, 1, 0);
2062   sc = decode_src23(sss, ss, w+1);
2063   dc = decode_dest23(ddd, dd, w+1);
2064   b = get_src (sc);
2065   MATH_OP (dc, b, 0, -);
2066
2067   /** 1sss ddd1 dd ss 0000              SUB.L:G src,dest */
2068
2069   prefix (1, 1, 0);
2070   sc = decode_src23(sss, ss, 4);
2071   dc = decode_dest23(ddd, dd, 4);
2072   b = get_src (sc);
2073   MATH_OP (dc, b, 0, -);
2074
2075   /** 1001 ddd0 dd01 0001               SUBX #IMM,dest */
2076
2077   prefix (0, 1, 0);
2078   dc = decode_dest23(ddd, dd, 4);
2079   imm = sign_ext (IMM(1), 8);
2080   MATH_OP (dc, imm, 0, -);
2081
2082   /** 1sss ddd0 dd ss 0000              SUBX src,dest */
2083
2084   prefix (1, 1, 0);
2085   sc = decode_src23(sss, ss, 1);
2086   dc = decode_dest23(ddd, dd, 4);
2087   b = sign_ext (get_src (sc), 8);
2088   MATH_OP (dc, b, 0, -);
2089
2090   /** 1001 ddd w dd11 1110              TST.size:G #IMM,dest */
2091
2092   prefix (0, 0, 0);
2093   dc = decode_dest23 (ddd, dd, w+1);
2094   imm = IMM(w+1);
2095   a = get_src (dc);
2096   v = a & imm;
2097   set_sz (v, w+1);
2098
2099   /** 00dd 110w                         TST.size:S #IMM,dest */
2100
2101   prefix (0, 0, 0);
2102   dc = decode_dest2 (dd, w+1);
2103   imm = IMM(w+1);
2104   a = get_src (dc);
2105   v = a & imm;
2106   set_sz (v, w+1);
2107
2108   /** 0000 0001 1sss ddd w dd ss 1001   TST.size:G src,dest */
2109
2110   prefix (0, 0, 0);
2111   sc = decode_src23 (sss, ss, w+1);
2112   dc = decode_dest23 (ddd, dd, w+1);
2113   b = get_src (sc);
2114   a = get_src (dc);
2115   v = a & b;
2116   set_sz (v, w+1);
2117
2118   /** 1111 1111                         UND */
2119
2120   trigger_fixed_interrupt (0xffffdc);
2121
2122   /** 1011 0010 0000 0011               WAIT */
2123
2124   ;
2125
2126   /** 1101 ddd w dd00 1src              XCHG.size src,dest */
2127
2128   dc = decode_dest23 (ddd, dd, w+1);
2129   sc = decode_src3 (src, w+1);
2130   a = get_src (dc);
2131   b = get_src (sc);
2132   put_dest (dc, b);
2133   put_dest (sc, a);
2134
2135   /** 1001 ddd w dd00 1110              XOR.size #IMM,dest */
2136
2137   prefix (0, 1, 0);
2138   dc = decode_dest23(ddd, dd, w+1);
2139   imm = IMM(w+1);
2140   LOGIC_OP (dc, imm, ^);
2141
2142   /** 1sss ddd w dd ss 1001             XOR.size src,dest */
2143
2144   prefix (1, 1, 0);
2145   sc = decode_src23(sss, ss, w+1);
2146   dc = decode_dest23(ddd, dd, w+1);
2147   b = get_src (sc);
2148   LOGIC_OP (dc, b, ^);
2149
2150 /** */
2151
2152   return step_result;
2153 }