sim/m32c/m32c.opc

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