sim/m32c/m32c.opc

   1 /* m32c.opc --- semantics for m32c opcodes.                     -*- mode: c -*-
   2
   3 Copyright (C) 2005-2024 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 101bit                       BTST:S src */
 732
 733   sc = decode_src23 (3, 3, 1); /* bit,base:19 */
 734   bit = get_bit2 (sc, bb*2 + bit);
 735   set_zc (!bit, bit);
 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 1flg               LDIPL #IMM */
1174
1175   set_flags (0x7000, flg*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   prefix (0, 0, 0);
1593   imm = IMM(w+1);
1594   tprintf("push%s: %x\n", w ? "hi" : "qi", imm);
1595   a = get_reg (sp) - 2;
1596   if (w)
1597     mem_put_hi (a, imm);
1598   else
1599     mem_put_qi (a, imm);
1600   put_reg (sp, a);
1601
1602   /** 1100 sss w ss00 1110              PUSH.size src */
1603
1604   prefix (0, 1, 0);
1605   sc = decode_dest23 (sss, ss, w+1);
1606   a = get_src (sc);
1607   put_reg (sp, get_reg (sp) - 2);
1608   if (w)
1609     mem_put_hi (get_reg (sp), a);
1610   else
1611     mem_put_qi (get_reg (sp), a);
1612   tprintf("push%s: %x\n", w ? "hi" : "qi", a);
1613
1614   /** 1011 0110 0101 0011               PUSH.L #IMM32 */
1615
1616   imm = IMM(4);
1617   put_reg (sp, get_reg (sp) - 4);
1618   mem_put_si (get_reg (sp), imm);
1619
1620   /** 1010 sss0 ss00 0001               PUSH.L src */
1621
1622   prefix (0, 1, 0);
1623   sc = decode_dest23 (sss, ss, 4);
1624   a = get_src (sc);
1625   put_reg (sp, get_reg (sp) - 4);
1626   mem_put_si (get_reg (sp), a);
1627
1628   /** 1011 0sa0 ss00 0001               PUSHA src */
1629
1630   prefix (0, 0, 0);
1631   sc = decode_dest23 (sa, ss, 1);
1632   put_reg (sp, get_reg (sp) - 4);
1633   mem_put_hi (get_reg (sp), sc.u.addr);
1634   tprintf("pushsi: %x\n", sc.u.addr);
1635
1636   /** 1101 0001 1010 1src               PUSHC src */
1637
1638   prefix (0, 0, 0);
1639   sc = decode_cr_b (src, CR_B_DCT0);
1640   a = get_src (sc);
1641   put_reg (sp, get_reg (sp) - 2);
1642   mem_put_hi (get_reg (sp), a);
1643   tprintf("pushhi: %x\n", a);
1644
1645   /** 1101 0001 0010 1src               PUSHC src */
1646
1647   prefix (0, 0, 0);
1648   sc = decode_cr_b (src, CR_B_INTB);
1649   a = get_src (sc);
1650   put_reg (sp, get_reg (sp) - 4);
1651   mem_put_si (get_reg (sp), a);
1652   tprintf("pushsi: %x\n", a);
1653
1654   /** 1000 1111                         PUSHM src */
1655
1656   {
1657   static int map[] = { fb, sb, a1, a0, r3, r2, r1, r0 };
1658   imm = IMM(1);
1659   tprintf("pushm: %x\n", imm);
1660   for (a=0; a<4; a++)
1661     if (imm & (1<<a))
1662       {
1663         put_reg (sp, get_reg (sp) - 4);
1664         v = get_reg (map[a]);
1665         mem_put_si (get_reg (sp), v);
1666       }
1667   for (; a<8; a++)
1668     if (imm & (1<<a))
1669       {
1670         put_reg (sp, get_reg (sp) - 2);
1671         v = get_reg (map[a]);
1672         mem_put_hi (get_reg (sp), v);
1673       }
1674   }
1675
1676   /** 1001 1110                         REIT */
1677
1678   a = get_reg (sp);
1679   put_reg (pc, mem_get_si (a));
1680   a += 4;
1681   put_reg (flags, mem_get_hi (a));
1682   a += 2;
1683   put_reg (sp, a);
1684
1685   /** 1011 1000 010w 0011               RMPA.size */
1686
1687   {
1688   int count = get_reg (r3);
1689   int list1 = get_reg (a0);
1690   int list2 = get_reg (a1);
1691   long long sum = get_reg_ll (r3r1r2r0) & 0xffffff;
1692
1693   while (count)
1694     {
1695       if (w)
1696         {
1697           a = sign_ext (mem_get_hi (list1), 16);
1698           b = sign_ext (mem_get_hi (list2), 16);
1699         }
1700       else
1701         {
1702           a = sign_ext (mem_get_qi (list1), 8);
1703           b = sign_ext (mem_get_qi (list2), 8);
1704         }
1705       tprintf("%lld + %d * %d = ", sum, a, b);
1706       sum += a * b;
1707       tprintf("%lld\n", sum);
1708       list1 += w ? 2 : 1;
1709       list2 += w ? 2 : 1;
1710       count --;
1711     }
1712   put_reg (r3, count);
1713   put_reg (a0, list1);
1714   put_reg (a1, list2);
1715   put_reg (r2r0, (int)(sum & 0xffffffffU));
1716   put_reg (r1, (int)(sum >> 32));
1717   }
1718
1719   /** 1011 ddd w dd10 1110              ROLC.size dest */
1720
1721   prefix (0, 1, 0);
1722   dc = decode_dest23 (ddd, dd, w+1);
1723   rot_op (dc, 1, 1);
1724
1725   /** 1010 ddd w dd10 1110              RORC.size dest */
1726
1727   prefix (0, 1, 0);
1728   dc = decode_dest23 (ddd, dd, w+1);
1729   rot_op (dc, 1, -1);
1730
1731   /** 1110 ddd w dd10 immm              ROT.size #IMM, dest */
1732
1733   prefix (0, 1, 0);
1734   dc = decode_dest23 (ddd, dd, w+1);
1735   rot_op (dc, IMM4(), -1);
1736
1737   /** 1010 ddd w dd11 1111              ROT.size R1H,dest */
1738
1739   prefix (0, 1, 0);
1740   dc = decode_dest23 (ddd, dd, w+1);
1741   a = sign_ext (get_reg (r1h), 8);
1742   rot_op (dc, a, -1);
1743
1744   /** 1101 1111                         RTS */
1745
1746   put_reg (pc, mem_get_si (get_reg (sp)));
1747   put_reg (sp, get_reg (sp) + 4);
1748
1749   /** 0000 0001 1001 ddd w dd10 1110    SBB.size #IMM, dest */
1750
1751   prefix (0, 0, 0);
1752   dc = decode_dest23 (ddd, dd, w+1);
1753   imm = IMM (w+1);
1754   MATH_OP (dc, imm, !carry, -);
1755
1756   /** 0000 0001 1sss ddd w dd ss 0110   SBB.size src,dest */
1757
1758   prefix (0, 0, 0);
1759   sc = decode_src23 (sss, ss, w+1);
1760   dc = decode_dest23 (ddd, dd, w+1);
1761   MATH_OP (dc, get_src (sc), !carry, -);
1762
1763   /** 1101 ddd1 dd11 cond               SCcond dest */
1764
1765   prefix (0, 1, 0);
1766   dc = decode_dest23 (ddd, dd, 2);
1767   if (condition_true (cond))
1768     put_dest (dc, 1);
1769   else
1770     put_dest (dc, 0);
1771
1772   /** 1011 1000 110w 0011               SCMPU.size */
1773
1774   ta0 = get_reg (a0);
1775   ta1 = get_reg (a1);
1776
1777   for (;;)
1778     {
1779       t0 = mem_get_qi (ta0);
1780       t2 = mem_get_qi (ta1);
1781       if (w)
1782         {
1783           t1 = mem_get_qi (ta0 + 1);
1784           t3 = mem_get_qi (ta1 + 1);
1785         }
1786       dif = t0 - t2;
1787       if (dif == 0 && t0 != 0 && w)
1788         dif = t1 - t3;
1789       set_oszc (dif, 1, dif > 0);
1790
1791       ta0 += w ? 2 : 1;
1792       ta1 += w ? 2 : 1;
1793
1794       if (t0 == 0 || t0 != t2)
1795         break;
1796       if (w && (t1 == 0 || t1 != t3))
1797         break;
1798     }
1799
1800   /** 1111 ddd w dd00 immm              SHA.size #IMM,dest */
1801
1802   prefix (0, 1, 0);
1803   dc = decode_dest23 (ddd, dd, w+1);
1804   shift_op (dc, 1, IMM4(), 1);
1805
1806   /** 1010 ddd0 dd10 0001               SHA.L #IMM,dest */
1807
1808   prefix (0, 1, 0);
1809   dc = decode_dest23 (ddd, dd, 4);
1810   imm = sign_ext (IMM(1), 8);
1811   shift_op (dc, 1, imm, 1);
1812
1813   /** 1011 ddd w dd11 1110              SHA.size R1H,dest */
1814
1815   prefix (0, 1, 0);
1816   dc = decode_dest23 (ddd, dd, w+1);
1817   a = sign_ext (get_reg (r1h), 8);
1818   shift_op (dc, 1, a, 1);
1819
1820   /** 1100 ddd0 dd01 0001               SHA.L   R1H,dest */
1821
1822   prefix (0, 1, 0);
1823   dc = decode_dest23 (ddd, dd, 4);
1824   a = sign_ext (get_reg (r1h), 8);
1825   shift_op (dc, 1, a, 1);
1826
1827   /** 1100 ddd0 dd10 0001               SHANC.L #IMM,dest */
1828
1829   M32C_ONLY();
1830   prefix (0, 1, 0);
1831   dc = decode_dest23 (ddd, dd, 4);
1832   imm = sign_ext (IMM(1), 8);
1833   shift_op (dc, 1, imm, 0);
1834
1835   /** 1110 ddd w dd00 immm              SHL.size #IMM, dest */
1836
1837   prefix (0, 1, 0);
1838   dc = decode_dest23 (ddd, dd, w+1);
1839   shift_op (dc, 0, IMM4(), 1);
1840
1841   /** 1001 ddd0 dd10 0001               SHL.L #IMM, dest */
1842
1843   prefix (0, 1, 0);
1844   dc = decode_dest23 (ddd, dd, 4);
1845   imm = sign_ext (IMM(1), 8);
1846   shift_op (dc, 0, imm, 1);
1847
1848   /** 1010 ddd w dd11 1110              SHL.size R1H,dest */
1849
1850   prefix (0, 1, 0);
1851   dc = decode_dest23 (ddd, dd, w+1);
1852   a = sign_ext (get_reg (r1h), 8);
1853   shift_op (dc, 0, a, 1);
1854
1855   /** 1100 ddd0 dd00 0001               SHL.L R1H,dest */
1856
1857   prefix (0, 1, 0);
1858   dc = decode_dest23 (ddd, dd, 4);
1859   a = sign_ext (get_reg (r1h), 8);
1860   shift_op (dc, 0, a, 1);
1861
1862   /** 1000 ddd0 dd10 0001               SHLNC.L #IMM,dest */
1863
1864   M32C_ONLY();
1865   prefix (0, 1, 0);
1866   dc = decode_dest23 (ddd, dd, 4);
1867   imm = sign_ext (IMM(1), 8);
1868   shift_op (dc, 0, imm, 0);
1869
1870   /** 1011 0010 100w 0011               SIN.size */
1871
1872   v = get_reg (a0);
1873   a = get_reg (a1);
1874   b = get_reg (r3);
1875   if (b) for (;b;)
1876     {
1877       if (w)
1878         mem_put_hi(a, mem_get_hi (v));
1879       else
1880         mem_put_qi(a, mem_get_qi (v));
1881       a += w ? 2 : 1;
1882       b --;
1883     }
1884   put_reg (a0, v);
1885   put_reg (a1, a);
1886   put_reg (r3, b);
1887
1888   /** 1011 0110 100w 0011               SMOVB.size */
1889
1890   v = get_reg (a0);
1891   a = get_reg (a1);
1892   b = get_reg (r3);
1893   if (b) for (;b;)
1894     {
1895       if (w)
1896         mem_put_hi(a, mem_get_hi (v));
1897       else
1898         mem_put_qi(a, mem_get_qi (v));
1899       v -= w ? 2 : 1;
1900       a -= w ? 2 : 1;
1901       b --;
1902     }
1903   put_reg (a0, v);
1904   put_reg (a1, a);
1905   put_reg (r3, b);
1906
1907   /** 1011 0000 100w 0011               SMOVF.size */
1908
1909   v = get_reg (a0);
1910   a = get_reg (a1);
1911   b = get_reg (r3);
1912   if (b) for (;b;)
1913     {
1914       if (w)
1915         mem_put_hi(a, mem_get_hi (v));
1916       else
1917         mem_put_qi(a, mem_get_qi (v));
1918       v += w ? 2 : 1;
1919       a += w ? 2 : 1;
1920       b --;
1921     }
1922   put_reg (a0, v);
1923   put_reg (a1, a);
1924   put_reg (r3, b);
1925
1926   /** 1011 1000 100w 0011               SMOVU.size */
1927
1928   v = get_reg (a0);
1929   a = get_reg (a1);
1930   do
1931     {
1932       if (w)
1933         mem_put_hi(a, (t0 = mem_get_hi (v)));
1934       else
1935         mem_put_qi(a, (t0 = mem_get_qi (v)));
1936       v += w ? 2 : 1;
1937       a += w ? 2 : 1;
1938       if (t0 == 0
1939           || (w && ((t0 & 0xff) == 0 || (t0 & 0xff00) == 0)))
1940         break;
1941     } while (1);
1942   put_reg (a0, v);
1943   put_reg (a1, a);
1944
1945   /** 1011 0100 100w 0011               SOUT.size */
1946
1947   v = get_reg (a0);
1948   a = get_reg (a1);
1949   b = get_reg (r3);
1950   for (;b;)
1951     {
1952       if (w)
1953         mem_put_hi(a, mem_get_hi (v));
1954       else
1955         mem_put_qi(a, mem_get_qi (v));
1956       v += w ? 2 : 1;
1957       b --;
1958     }
1959   put_reg (a0, v);
1960   put_reg (a1, a);
1961   put_reg (r3, b);
1962
1963   /** 1011 1000 000w 0011               SSTR.size */
1964
1965   a = get_reg (a1);
1966   b = get_reg (r3);
1967   v = get_reg (w ? r0 : r0l);
1968   for (;b;)
1969     {
1970       if (w)
1971         mem_put_hi(a, v);
1972       else
1973         mem_put_qi(a, v);
1974       a += w ? 2 : 1;
1975       b --;
1976     }
1977   put_reg (a1, a);
1978   put_reg (r3, b);
1979
1980   /** 0000 0001 1101 ddd1 dd01 0src     STC src,dest */
1981
1982   prefix (0, 0, 0);
1983   dc = decode_dest23 (ddd, dd, 4);
1984   sc = decode_cr_b (src, CR_B_DMA0);
1985   a = get_src (sc);
1986   put_dest (dc, a);
1987
1988   /** 0000 0001 1101 ddd1 dd01 1src     STC src,dest */
1989
1990   prefix (0, 0, 0);
1991   dc = decode_dest23 (ddd, dd, 2);
1992   sc = decode_cr_b (src, CR_B_DCT0);
1993   a = get_src (sc);
1994   put_dest (dc, a);
1995
1996   /** 1101 ddd1 dd01 0src               STC src,dest */
1997
1998   prefix (0, 0, 0);
1999   dc = decode_dest23 (ddd, dd, 4);
2000   sc = decode_cr_b (src, CR_B_INTB);
2001   a = get_src (sc);
2002   put_dest (dc, a);
2003
2004   /** 1011 0110 1101 0011               STCX abs16,abs24 */
2005
2006   NOTYET();
2007
2008   /** 1001 ddd w dd01 1111              STNZ.size #IMM,dest */
2009
2010   prefix (0, 1, 0);
2011   dc = decode_dest23 (ddd, dd, w+1);
2012   imm = IMM(w+1);
2013   if (! FLAG_Z)
2014     put_dest (dc, imm);
2015
2016   /** 1001 ddd w dd00 1111              STZ.size #IMM,dest */
2017
2018   prefix (0, 1, 0);
2019   dc = decode_dest23 (ddd, dd, w+1);
2020   imm = IMM(w+1);
2021   if (FLAG_Z)
2022     put_dest (dc, imm);
2023
2024   /** 1001 ddd w dd11 1111              STZX.size #IMM1,#IMM2,dest */
2025
2026   prefix (0, 1, 0);
2027   dc = decode_dest23 (ddd, dd, w+1);
2028   a = IMM(w+1);
2029   b = IMM(w+1);
2030   if (FLAG_Z)
2031     put_dest (dc, a);
2032   else
2033     put_dest (dc, b);
2034
2035   /** 1000 ddd w dd11 1110              SUB.size:G #IMM,dest */
2036
2037   prefix (0, 1, 0);
2038   dc = decode_dest23(ddd, dd, w+1);
2039   imm = IMM(w+1);
2040   MATH_OP (dc, imm, 0, -);
2041
2042   /** 1001 ddd0 dd11 0001               SUB.L:G #IMM,dest */
2043
2044   prefix (0, 1, 0);
2045   dc = decode_dest23(ddd, dd, 4);
2046   imm = IMM(4);
2047   MATH_OP (dc, imm, 0, -);
2048
2049   /** 00dd 111w                         SUB.size:S #IMM,dest */
2050
2051   prefix (0, 1, 0);
2052   dc = decode_dest2(dd, w+1);
2053   imm = IMM (w+1);
2054   MATH_OP (dc, imm, 0, -);
2055
2056   /** 1sss ddd w dd ss 1010             SUB.size:G src,dest */
2057
2058   prefix (1, 1, 0);
2059   sc = decode_src23(sss, ss, w+1);
2060   dc = decode_dest23(ddd, dd, w+1);
2061   b = get_src (sc);
2062   MATH_OP (dc, b, 0, -);
2063
2064   /** 1sss ddd1 dd ss 0000              SUB.L:G src,dest */
2065
2066   prefix (1, 1, 0);
2067   sc = decode_src23(sss, ss, 4);
2068   dc = decode_dest23(ddd, dd, 4);
2069   b = get_src (sc);
2070   MATH_OP (dc, b, 0, -);
2071
2072   /** 1001 ddd0 dd01 0001               SUBX #IMM,dest */
2073
2074   prefix (0, 1, 0);
2075   dc = decode_dest23(ddd, dd, 4);
2076   imm = sign_ext (IMM(1), 8);
2077   MATH_OP (dc, imm, 0, -);
2078
2079   /** 1sss ddd0 dd ss 0000              SUBX src,dest */
2080
2081   prefix (1, 1, 0);
2082   sc = decode_src23(sss, ss, 1);
2083   dc = decode_dest23(ddd, dd, 4);
2084   b = sign_ext (get_src (sc), 8);
2085   MATH_OP (dc, b, 0, -);
2086
2087   /** 1001 ddd w dd11 1110              TST.size:G #IMM,dest */
2088
2089   prefix (0, 0, 0);
2090   dc = decode_dest23 (ddd, dd, w+1);
2091   imm = IMM(w+1);
2092   a = get_src (dc);
2093   v = a & imm;
2094   set_sz (v, w+1);
2095
2096   /** 00dd 110w                         TST.size:S #IMM,dest */
2097
2098   prefix (0, 0, 0);
2099   dc = decode_dest2 (dd, w+1);
2100   imm = IMM(w+1);
2101   a = get_src (dc);
2102   v = a & imm;
2103   set_sz (v, w+1);
2104
2105   /** 0000 0001 1sss ddd w dd ss 1001   TST.size:G src,dest */
2106
2107   prefix (0, 0, 0);
2108   sc = decode_src23 (sss, ss, w+1);
2109   dc = decode_dest23 (ddd, dd, w+1);
2110   b = get_src (sc);
2111   a = get_src (dc);
2112   v = a & b;
2113   set_sz (v, w+1);
2114
2115   /** 1111 1111                         UND */
2116
2117   trigger_fixed_interrupt (0xffffdc);
2118
2119   /** 1011 0010 0000 0011               WAIT */
2120
2121   ;
2122
2123   /** 1101 ddd w dd00 1src              XCHG.size src,dest */
2124
2125   dc = decode_dest23 (ddd, dd, w+1);
2126   sc = decode_src3 (src, w+1);
2127   a = get_src (dc);
2128   b = get_src (sc);
2129   put_dest (dc, b);
2130   put_dest (sc, a);
2131
2132   /** 1001 ddd w dd00 1110              XOR.size #IMM,dest */
2133
2134   prefix (0, 1, 0);
2135   dc = decode_dest23(ddd, dd, w+1);
2136   imm = IMM(w+1);
2137   LOGIC_OP (dc, imm, ^);
2138
2139   /** 1sss ddd w dd ss 1001             XOR.size src,dest */
2140
2141   prefix (1, 1, 0);
2142   sc = decode_src23(sss, ss, w+1);
2143   dc = decode_dest23(ddd, dd, w+1);
2144   b = get_src (sc);
2145   LOGIC_OP (dc, b, ^);
2146
2147 /** */
2148
2149   return step_result;
2150 }