sim/m32c/r8c.opc

   1 /* r8c.opc --- semantics for r8c 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 M16C_ONLY() /* FIXME: add something here */
  50
  51 #define GETBYTE() (op[opi++] = getbyte())
  52
  53 #define UNSUPPORTED() unsupported("unsupported", orig_pc)
  54 #define NOTYET() unsupported("unimplemented", orig_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 bw)
  82 {
  83   int rv = getbyte ();
  84   if (bw)
  85     rv = rv + 256 * getbyte();
  86   if (bw == 2)
  87     rv = rv + 65536 * getbyte();
  88   return rv;
  89 }
  90
  91 #define IMM4() (immm >= 8 ? 7 - immm : immm + 1)
  92
  93 #define UNARY_SOP \
  94   dc = decode_srcdest4 (dest, w); \
  95   v = sign_ext (get_src (dc), w?16:8);
  96
  97 #define UNARY_UOP \
  98   dc = decode_srcdest4 (dest, w); \
  99   v = get_src (dc);
 100
 101 #define BINARY_SOP \
 102   sc = decode_srcdest4 (srcx, w); \
 103   dc = decode_srcdest4 (dest, w); \
 104   a = sign_ext (get_src (sc), w?16:8); \
 105   b = sign_ext (get_src (dc), w?16:8);
 106
 107 #define BINARY_UOP \
 108   sc = decode_srcdest4 (srcx, w); \
 109   dc = decode_srcdest4 (dest, w); \
 110   a = get_src (sc); \
 111   b = get_src (dc);
 112
 113 #define carry (FLAG_C ? 1 : 0)
 114
 115 static void
 116 cmp (int d, int s, int w)
 117 {
 118   int a, b, f=0;
 119   int mask = w ? 0xffff : 0xff;
 120   a = d - s;
 121   b = sign_ext (d, w?16:8) - sign_ext (s, w?16:8);
 122   tprintf ("cmp: %x - %x = %08x, %x - %x = %d\n",
 123            d, s, a,
 124            sign_ext(d,w?16:8), sign_ext(s,w?16:8), b);
 125
 126   if (b == 0)
 127     f |= FLAGBIT_Z;
 128   if (b & (w ? 0x8000 : 0x80))
 129     f |= FLAGBIT_S;
 130   if ((d & mask) >= (s & mask))
 131     f |= FLAGBIT_C;
 132   if (b < (w ? -32768 : -128) || b > (w ? 32767 : 127))
 133     f |= FLAGBIT_O;
 134
 135   set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_O | FLAGBIT_C, f);
 136 }
 137
 138 static void
 139 div_op (int s, int u, int x, int w)
 140 {
 141   srcdest sc;
 142   int v, a, b;
 143
 144   if (s == -1)
 145     s = IMM(w);
 146   else
 147     {
 148       sc = decode_srcdest4 (s, w);
 149       s = get_src (sc);
 150     }
 151
 152   v = get_reg (w ? r2r0 : r0);
 153
 154   if (!u)
 155     {
 156       s = sign_ext (s, w ? 16 : 8);
 157       v = sign_ext (v, w ? 16 : 8);
 158     }
 159
 160   if (s == 0)
 161     {
 162       set_flags (FLAGBIT_O, FLAGBIT_O);
 163       return;
 164     }
 165
 166   if (u)
 167     {
 168       a = (unsigned int)v / (unsigned int)s;
 169       b = (unsigned int)v % (unsigned int)s;
 170     }
 171   else
 172     {
 173       a = v / s;
 174       b = v % s;
 175     }
 176   if (x)
 177     {
 178       if ((s > 0 && b < 0)
 179           || (s < 0 && b > 0))
 180         {
 181           a --;
 182           b += s;
 183         }
 184     }
 185   tprintf ("%d / %d = %d rem %d\n", v, s, a, b);
 186   if ((!u && (a > (w ? 32767 : 127)
 187              || a < (w ? -32768 : -129)))
 188       || (u && (a > (w ? 65536 : 255))))
 189     set_flags (FLAGBIT_O, FLAGBIT_O);
 190   else
 191     set_flags (FLAGBIT_O, 0);
 192
 193   put_reg (w ? r0 : r0l, a);
 194   put_reg (w ? r2 : r0h, b);
 195 }
 196
 197 static void
 198 rot_op (srcdest sd, int rotc, int count)
 199 {
 200   int mask = (sd.bytes == 2) ? 0xffff : 0xff;
 201   int msb = (sd.bytes == 2) ? 0x8000 : 0x80;
 202   int v = get_src (sd);
 203   int c = carry, ct;
 204
 205   tprintf("%s %x by %d\n", rotc ? "rotc" : "rot", v, count);
 206   tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
 207   while (count > 0)
 208     {
 209       ct = (v & msb) ? 1 : 0;
 210       v <<= 1;
 211       v |= rotc ? c : ct;
 212       v &= mask;
 213       c = ct;
 214       tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
 215       count --;
 216     }
 217   while (count < 0)
 218     {
 219       ct = v & 1;
 220       v >>= 1;
 221       v |= (rotc ? c : ct) * msb;
 222       c = ct;
 223       tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
 224       count ++;
 225     }
 226   put_dest (sd, v);
 227   set_szc (v, sd.bytes, c);
 228 }
 229
 230 static void
 231 shift_op (srcdest sd, int arith, int count)
 232 {
 233   int mask = (sd.bytes == 2) ? 0xffff : 0xff;
 234   int msb = (sd.bytes == 2) ? 0x8000 : 0x80;
 235   int v = get_src (sd);
 236   int c = 0;
 237
 238   if (sd.bytes == 4)
 239     {
 240       mask = 0xffffffffU;
 241       msb = 0x80000000U;
 242       if (count > 16 || count < -16)
 243         {
 244           fprintf(stderr, "Error: SI shift of %d undefined\n", count);
 245           exit(1);
 246         }
 247       if (count > 16)
 248         count = (count - 1) % 16 + 1;
 249       if (count < -16)
 250         count = -((-count - 1) % 16 + 1);
 251     }
 252
 253   tprintf("%s %x by %d\n", arith ? "sha" : "shl", v, count);
 254   tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
 255   while (count > 0)
 256     {
 257       c = (v & msb) ? 1 : 0;
 258       v <<= 1;
 259       v &= mask;
 260       tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
 261       count --;
 262     }
 263   while (count < 0)
 264     {
 265       c = v & 1;
 266       if (arith)
 267         v = (v & msb) | (v >> 1);
 268       else
 269         v = (v >> 1) & (msb - 1);
 270       tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
 271       count ++;
 272     }
 273   put_dest (sd, v);
 274   set_szc (v, sd.bytes, c);
 275 }
 276
 277 #define MATH_OP(dc,s,c,op,carryrel) \
 278   a = get_src(dc); \
 279   b = s & b2mask[dc.bytes]; \
 280   v2 = a op b op c; \
 281   tprintf("0x%x " #op " 0x%x " #op " 0x%x = 0x%x\n", a, b, c, v2); \
 282   a = sign_ext (a, dc.bytes * 8); \
 283   b = sign_ext (s, dc.bytes * 8); \
 284   v = a op b op c; \
 285   tprintf("%d " #op " %d " #op " %d = %d\n", a, b, c, v); \
 286   set_oszc (v, dc.bytes, v2 carryrel); \
 287   put_dest (dc, v2);
 288
 289 #define BIT_OP(field,expr) \
 290   dc = decode_bit (field); \
 291   b = get_bit (dc); \
 292   v = expr; \
 293   tprintf ("b=%d, carry=%d, %s = %d\n", b, carry, #expr, v); \
 294   put_bit (dc, v);
 295
 296 #define BIT_OPC(field,expr) \
 297   dc = decode_bit (field); \
 298   b = get_bit (dc); \
 299   v = expr; \
 300   tprintf ("b=%d, carry=%d, %s = %d\n", b, carry, #expr, v); \
 301   set_c (v);
 302
 303 /* The "BMcnd dest" opcode uses a different encoding for the */
 304 /* condition than other opcodes.  */
 305 static int bmcnd_cond_map[] = {
 306   0, 1, 2, 3, 8, 9, 10, 11, 4, 5, 6, 7, 12, 13, 14, 15
 307 };
 308
 309 int
 310 decode_r8c (void)
 311 {
 312   unsigned char op[40];
 313   int opi = 0;
 314   int v, v2, a, b;
 315   int orig_pc = get_reg (pc);
 316   srcdest sc, dc;
 317   int imm;
 318
 319   step_result = M32C_MAKE_STEPPED ();
 320
 321   tprintf("trace: decode pc = %05x\n", orig_pc);
 322
 323   /** VARY dst 011 100 101 110 111 */
 324
 325   /** 0111 011w 1111 dest  ABS.size dest */
 326
 327   UNARY_SOP;
 328   a = v<0 ? -v : v;
 329   tprintf("abs(%d) = %d\n", v, a);
 330   set_osz(a, w+1);
 331   put_dest (dc, a);
 332
 333   /** 0111 011w 0110 dest  ADC.size #IMM,dest */
 334
 335   dc = decode_srcdest4(dest, w);
 336   imm = IMM(w);
 337   MATH_OP (dc, imm, carry, +, > (w?0xffff:0xff));
 338
 339   /** 1011 000w srcx dest  ADC.size src,dest */
 340
 341   sc = decode_srcdest4(srcx, w);
 342   dc = decode_srcdest4(dest, w);
 343   b = get_src (sc);
 344   MATH_OP (dc, b, carry, +, > (w?0xffff:0xff));
 345
 346   /** 0111 011w 1110 dest  ADCF.size dest */
 347
 348   dc = decode_srcdest4(dest, w);
 349   MATH_OP (dc, 0, carry, +, > (w?0xffff:0xff));
 350
 351   /** 0111 011w 0100 dest  ADD.size:G #imm,dest */
 352
 353   dc = decode_srcdest4(dest, w);
 354   imm = IMM(w);
 355   MATH_OP (dc, imm, 0, +, > (w?0xffff:0xff));
 356
 357   /** 1100 100w immm dest  ADD.size:Q #IMM,dest */
 358
 359   dc = decode_srcdest4(dest, w);
 360   imm = sign_ext (immm, 4);
 361   MATH_OP (dc, imm, 0, +, > (w?0xffff:0xff));
 362
 363   /** 1000 0dst            ADD.B:S #IMM8,dst */
 364
 365   imm = IMM(0);
 366   dc = decode_dest3 (dst, 0);
 367   MATH_OP (dc, imm, 0, +, > 0xff);
 368
 369   /** 1010 000w srcx dest  ADD.size:G src,dest */
 370
 371   sc = decode_srcdest4(srcx, w);
 372   dc = decode_srcdest4(dest, w);
 373   b = get_src (sc);
 374   MATH_OP (dc, b, 0, +, > (w?0xffff:0xff));
 375
 376   /** 0010 0d sr           ADD.B:S src,R0L/R0H */
 377
 378   sc = decode_src2 (sr, 0, d);
 379   dc = decode_dest1 (d, 0);
 380   b = get_src (sc);
 381   MATH_OP (dc, b, 0, +, > 0xff);
 382
 383   /** 0111 110w 1110 1011  ADD.size:G #IMM,sp */
 384
 385   dc = reg_sd (sp);
 386   imm = sign_ext (IMM(w), w?16:8);
 387   MATH_OP (dc, imm, 0, +, > 0xffff);
 388
 389   /** 0111 1101 1011 immm  ADD.size:Q #IMM,sp */
 390
 391   dc = reg_sd (sp);
 392   imm = sign_ext (immm, 4);
 393   MATH_OP (dc, imm, 0, +, > 0xffff);
 394
 395   /** 1111 100w immm dest  ADJNZ.size #IMM,dest,label */
 396
 397   UNARY_UOP;
 398   imm = sign_ext(immm, 4);
 399   tprintf("%x + %d = %x\n", v, imm, v+imm);
 400   v += imm;
 401   put_dest (dc, v);
 402   a = sign_ext (IMM(0), 8);
 403   if ((v & (w ? 0xffff : 0xff)) != 0)
 404     {
 405       tprintf("jmp: %x + 2 + %d = ", get_reg (pc), a);
 406       put_reg (pc, orig_pc + 2 + a);
 407       tprintf("%x\n", get_reg (pc));
 408     }
 409
 410   /** 0111 011w 0010 dest  AND.size:G #IMM,dest */
 411
 412   UNARY_UOP;
 413   imm = IMM(w);
 414   tprintf ("%x & %x = %x\n", v, imm, v & imm);
 415   v &= imm;
 416   set_sz (v, w+1);
 417   put_dest (dc, v);
 418
 419   /** 1001 0dst            AND.B:S #IMM8,dest */
 420
 421   imm = IMM(0);
 422   dc = decode_dest3 (dst, 0);
 423   v = get_src (dc);
 424   tprintf("%x & %x = %x\n", v, imm, v & imm);
 425   v &= imm;
 426   set_sz (v, 1);
 427   put_dest (dc, v);
 428
 429   /** 1001 000w srcx dest  AND.size:G src.dest */
 430
 431   BINARY_UOP;
 432   tprintf ("%x & %x = %x\n", a, b, a & b);
 433   v = a & b;
 434   set_sz (v, w+1);
 435   put_dest (dc, v);
 436
 437   /** 0001 0d sr           AND.B:S src,R0L/R0H */
 438
 439   sc = decode_src2 (sr, 0, d);
 440   dc = decode_dest1 (d, 0);
 441   a = get_src (sc);
 442   b = get_src (dc);
 443   v = a & b;
 444   tprintf("%x & %x = %x\n", a, b, v);
 445   set_sz (v, 1);
 446   put_dest (dc, v);
 447
 448   /** 0111 1110 0100 srcx  BAND src */
 449
 450   BIT_OPC (srcx, b & carry);
 451
 452   /** 0111 1110 1000 dest  BCLR:G dest */
 453
 454   dc = decode_bit (dest);
 455   put_bit (dc, 0);
 456
 457   /** 0100 0bit            BCLR:S bit,base:11[SB] */
 458
 459   dc = decode_bit11 (bit);
 460   put_bit (dc, 0);
 461
 462   /** 0111 1110 0010 dest  BMcnd dest  */
 463
 464   dc = decode_bit (dest);
 465   if (condition_true (bmcnd_cond_map [IMM (0) & 15]))
 466     put_bit (dc, 1);
 467   else
 468     put_bit (dc, 0);
 469
 470   /** 0111 1101 1101 cond  BMcnd C  */
 471
 472   if (condition_true (cond))
 473     set_c (1);
 474   else
 475     set_c (0);
 476
 477   /** 0111 1110 0101 srcx  BNAND src */
 478
 479   BIT_OPC (srcx, (!b) & carry);
 480
 481   /** 0111 1110 0111 srcx  BNOR src */
 482
 483   BIT_OPC (srcx, (!b) | carry);
 484
 485   /** 0111 1110 1010 dest  BNOT:G dest */
 486
 487   BIT_OP (dest, !b);
 488
 489   /** 0101 0bit            BNOT:S bit,base:11[SB] */
 490
 491   dc = decode_bit11 (bit);
 492   put_bit (dc, !get_bit (dc));
 493
 494   /** 0111 1110 0011 srcx  BNTST src */
 495
 496   dc = decode_bit (srcx);
 497   b = get_bit (dc);
 498   set_zc (!b, !b);
 499
 500   /** 0111 1110 1101 srcx  BNXOR src */
 501
 502   BIT_OPC (srcx, !b ^ carry);
 503
 504   /** 0111 1110 0110 srcx  BOR src */
 505
 506   BIT_OPC (srcx, b | carry);
 507
 508   /** 0000 0000            BRK */
 509
 510   /* We report the break to our caller with the PC still pointing at the
 511      breakpoint instruction.  */
 512   put_reg (pc, orig_pc);
 513   if (verbose)
 514     printf("[break]\n");
 515   return M32C_MAKE_HIT_BREAK ();
 516
 517   /** 0111 1110 1001 dest  BSET:G dest */
 518
 519   dc = decode_bit (dest);
 520   put_bit (dc, 1);
 521
 522   /** 0100 1bit            BSET:S bit,base:11[SB] */
 523
 524   dc = decode_bit11 (bit);
 525   put_bit (dc, 1);
 526
 527   /** 0111 1110 1011 srcx  BTST:G src */
 528
 529   dc = decode_bit (srcx);
 530   b = get_bit (dc);
 531   set_zc (!b, b);
 532
 533   /** 0101 1bit            BTST:S bit,base:11[SB] */
 534
 535   dc = decode_bit11 (bit);
 536   b = get_bit (dc);
 537   set_zc (!b, b);
 538
 539   /** 0111 1110 0000 dest  BTSTC dest */
 540
 541   dc = decode_bit (dest);
 542   b = get_bit (dc);
 543   set_zc (!b, b);
 544   put_bit (dc, 0);
 545
 546   /** 0111 1110 0001 dest  BTSTS dest */
 547
 548   dc = decode_bit (dest);
 549   b = get_bit (dc);
 550   set_zc (!b, b);
 551   put_bit (dc, 1);
 552
 553   /** 0111 1110 1100 srcx  BXOR src */
 554
 555   BIT_OPC (srcx, b ^ carry);
 556
 557   /** 0111 011w 1000 dest  CMP.size:G #IMM,dest */
 558
 559   UNARY_UOP;
 560   imm = IMM(w);
 561   cmp (v, imm, w);
 562
 563   /** 1101 000w immm dest  CMP.size:Q #IMM,dest */
 564
 565   UNARY_UOP;
 566   immm = sign_ext (immm, 4);
 567   cmp (v, immm, w);
 568
 569   /** 1110 0dst            CMP.B:S #IMM8,dest */
 570
 571   imm = IMM(0);
 572   dc = decode_dest3 (dst, 0);
 573   v = get_src (dc);
 574   cmp (v, imm, 0);
 575
 576   /** 1100 000w srcx dest  CMP.size:G src,dest */
 577
 578   BINARY_UOP;
 579   cmp(b, a, w);
 580
 581   /** 0011 1d sr           CMP.B:S src,R0L/R0H */
 582
 583   sc = decode_src2 (sr, 0, d);
 584   dc = decode_dest1 (d, 0);
 585   a = get_src (sc);
 586   b = get_src (dc);
 587   cmp (b, a, 0);
 588
 589   /** 0111 110w 1110 i1c s  DADC,DADD,DSBB,DSUB */
 590
 591   /* w = width, i = immediate, c = carry, s = subtract */
 592
 593   {
 594   int src = i ? IMM(w) : get_reg (w ? r1 : r0h);
 595   int dest = get_reg (w ? r0 : r0l);
 596   int res;
 597
 598   src = bcd2int(src, w);
 599   dest = bcd2int(dest, w);
 600
 601   tprintf("decimal: %d %s %d", dest, s?"-":"+", src);
 602   if (c)
 603     tprintf(" c=%d", carry);
 604
 605   if (!s)
 606     {
 607       res = dest + src;
 608       if (c)
 609         res += carry;
 610       c = res > (w ? 9999 : 99);
 611     }
 612   else
 613     {
 614       res = dest - src;
 615       if (c)
 616         res -= (1-carry);
 617       c = res >= 0;
 618       if (res < 0)
 619         res += w ? 10000 : 100;
 620     }
 621
 622   res = int2bcd (res, w);
 623   tprintf(" = %x\n", res);
 624
 625   set_szc (res, w+1, c);
 626
 627   put_reg (w ? r0 : r0l, res);
 628   }
 629
 630   /** 1010 1dst            DEC.B dest */
 631
 632   dc = decode_dest3 (dst, 0);
 633   v = get_src (dc);
 634   tprintf("%x -- = %x\n", v, v-1);
 635   v --;
 636   set_sz (v, 1);
 637   put_dest (dc, v);
 638
 639   /** 1111 d010            DEC.W dest */
 640
 641   v = get_reg (d ? a1 : a0);
 642   tprintf("%x -- = %x\n", v, v-1);
 643   v --;
 644   set_sz (v, 2);
 645   put_reg (d ? a1 : a0, v);
 646
 647   /** 0111 110w 1110 0001  DIV.size #IMM */
 648
 649   div_op (-1, 0, 0, w);
 650
 651   /** 0111 011w 1101 srcx  DIV.size src */
 652
 653   div_op (srcx, 0, 0, w);
 654
 655   /** 0111 110w 1110 0000  DIVU.size #IMM */
 656
 657   div_op (-1, 1, 0, w);
 658
 659   /** 0111 011w 1100 srcx  DIVU.size src */
 660
 661   div_op (srcx, 1, 0, w);
 662
 663   /** 0111 110w 1110 0011  DIVX.size #IMM */
 664
 665   div_op (-1, 0, 1, w);
 666
 667   /** 0111 011w 1001 srcx  DIVX.size src */
 668
 669   div_op (srcx, 0, 1, w);
 670
 671   /** 0111 1100 1111 0010  ENTER #IMM8 */
 672
 673   imm = IMM(0);
 674   put_reg (sp, get_reg (sp) - 2);
 675   mem_put_hi (get_reg (sp), get_reg (fb));
 676   put_reg (fb, get_reg (sp));
 677   put_reg (sp, get_reg (sp) - imm);
 678
 679   /** 0111 1101 1111 0010  EXITD */
 680
 681   put_reg (sp, get_reg (fb));
 682   put_reg (fb, mem_get_hi (get_reg (sp)));
 683   put_reg (sp, get_reg (sp) + 2);
 684   put_reg (pc, mem_get_psi (get_reg (sp)));
 685   put_reg (sp, get_reg (sp) + 3);
 686
 687   /** 0111 1100 0110 dest  EXTS.B dest */
 688
 689   dc = decode_srcdest4 (dest, 0);
 690   v = sign_ext (get_src (dc), 8);
 691   dc = widen_sd (dc);
 692   put_dest (dc, v);
 693   set_sz (v, 1);
 694
 695   /** 0111 1100 1111 0011  EXTS.W R0 */
 696
 697   v = sign_ext (get_reg (r0), 16);
 698   put_reg (r2r0, v);
 699   set_sz (v, 2);
 700
 701   /** 1110 1011 0flg 0101  FCLR dest */
 702
 703   set_flags (1 << flg, 0);
 704
 705   /** 1110 1011 0flg 0100  FSET dest */
 706
 707   set_flags (1 << flg, 1 << flg);
 708
 709   /** 1010 0dst            INC.B dest */
 710
 711   dc = decode_dest3 (dst, 0);
 712   v = get_src (dc);
 713   tprintf("%x ++ = %x\n", v, v+1);
 714   v ++;
 715   set_sz (v, 1);
 716   put_dest (dc, v);
 717
 718   /** 1011 d010            INC.W dest */
 719
 720   v = get_reg (d ? a1 : a0);
 721   tprintf("%x ++ = %x\n", v, v+1);
 722   v ++;
 723   set_sz (v, 2);
 724   put_reg (d ? a1 : a0, v);
 725
 726   /** 1110 1011 11vector   INT #imm */
 727
 728   trigger_based_interrupt (vector);
 729
 730   /** 1111 0110            INTO */
 731
 732   if (FLAG_O)
 733     trigger_fixed_interrupt (0xffe0);
 734
 735   /** 0110 1cnd            Jcnd label */
 736
 737   v = sign_ext (IMM(0), 8);
 738   if (condition_true (cnd))
 739     put_reg (pc, orig_pc + 1 + v);
 740
 741   /** 0111 1101 1100 cond  Jcnd label */
 742
 743   v = sign_ext (IMM(0), 8);
 744   if (condition_true (cond))
 745     put_reg (pc, orig_pc + 2 + v);
 746
 747   /** 0110 0dsp            JMP.S label */
 748
 749   put_reg (pc, orig_pc + 2 + dsp);
 750
 751   /** 1111 1110            JMP.B label */
 752
 753   imm = sign_ext (IMM(0), 8);
 754   if (imm == -1)
 755     {
 756       if (verbose)
 757         printf("[jmp-to-self detected as exit]\n");
 758       return M32C_MAKE_HIT_BREAK ();
 759     }
 760   put_reg (pc, orig_pc + 1 + imm);
 761
 762   /** 1111 0100            JMP.W label */
 763
 764   imm = sign_ext (IMM(1), 16);
 765   put_reg (pc, orig_pc + 1 + imm);
 766
 767   /** 1111 1100            JMP.A label */
 768
 769   imm = IMM(2);
 770   put_reg (pc, imm);
 771
 772   /** 0111 1101 0010 srcx  JMPI.W src */
 773
 774   sc = decode_jumpdest (srcx, 1);
 775   a = get_src (sc);
 776   a = sign_ext (a, 16);
 777   put_reg (pc, orig_pc + a);
 778
 779   /** 0111 1101 0000 srcx  JMPI.A src */
 780
 781   sc = decode_jumpdest (srcx, 0);
 782   a = get_src (sc);
 783   put_reg (pc, a);
 784
 785   /** 1110 1110            JMPS #IMM8 */
 786
 787   M16C_ONLY();
 788
 789   imm = IMM(0);
 790   a = 0xf0000 + mem_get_hi (0xffffe - imm * 2);
 791   put_reg (pc, a);
 792
 793   /** 1111 0101            JSR.W label */
 794
 795   imm = sign_ext (IMM(1), 16);
 796   put_reg (sp, get_reg (sp) - 3);
 797   mem_put_psi (get_reg (sp), get_reg (pc));
 798   put_reg (pc, orig_pc + imm + 1);
 799
 800   /** 1111 1101            JSR.A label */
 801
 802   imm = IMM(2);
 803   put_reg (sp, get_reg (sp) - 3);
 804   mem_put_psi (get_reg (sp), get_reg (pc));
 805   put_reg (pc, imm);
 806
 807   /** 0111 1101 0011 srcx  JSRI.W src */
 808
 809   sc = decode_jumpdest (srcx, 1);
 810   a = get_src (sc);
 811   a = sign_ext (a, 16);
 812
 813   put_reg (sp, get_reg (sp) - 3);
 814   mem_put_psi (get_reg (sp), get_reg (pc));
 815   put_reg (pc, orig_pc + a);
 816
 817   /** 0111 1101 0001 srcx  JSRI.A src */
 818
 819   sc = decode_jumpdest (srcx, 0);
 820   a = get_src (sc);
 821
 822   put_reg (sp, get_reg (sp) - 3);
 823   mem_put_psi (get_reg (sp), get_reg (pc));
 824   put_reg (pc, a);
 825
 826   /** 1110 1111            JSRS #IMM8 */
 827
 828   M16C_ONLY();
 829
 830   imm = IMM(0);
 831   a = 0xf0000 + mem_get_hi (0xffffe - imm * 2);
 832
 833   put_reg (sp, get_reg (sp) - 3);
 834   mem_put_psi (get_reg (sp), get_reg (pc));
 835   put_reg (pc, a);
 836
 837   /** 1110 1011 0reg 0000  LDC #IMM16,dest */
 838
 839   dc = decode_cr (reg);
 840   imm = IMM(1);
 841   put_dest (dc, imm);
 842
 843   /** 0111 1010 1reg srcx  LDC src,dest */
 844
 845   dc = decode_cr (reg);
 846   sc = decode_srcdest4 (srcx,1);
 847   put_dest (dc, get_src (sc));
 848
 849   /** 0111 1100 1111 0000  LDCTX abs16,abs20 */
 850
 851   NOTYET();
 852
 853   /** 0111 010w 1000 dest  LDE.size abs20,dest */
 854
 855   dc = decode_srcdest4 (dest, w);
 856   imm = IMM(2);
 857   if (w)
 858     v = mem_get_hi (imm);
 859   else
 860     v = mem_get_qi (imm);
 861   put_dest (dc, v);
 862
 863   /** 0111 010w 1001 dest  LDE.size dsp:20[a0], dest */
 864
 865   dc = decode_srcdest4 (dest, w);
 866   imm = IMM(2) + get_reg (a0);
 867   if (w)
 868     v = mem_get_hi (imm);
 869   else
 870     v = mem_get_qi (imm);
 871   put_dest (dc, v);
 872
 873   /** 0111 010w 1010 dest  LDE.size [a1a0],dest */
 874
 875   dc = decode_srcdest4 (dest, w);
 876   imm = get_reg (a1a0);
 877   if (w)
 878     v = mem_get_hi (imm);
 879   else
 880     v = mem_get_qi (imm);
 881   put_dest (dc, v);
 882
 883   /** 0111 1101 1010 0flg  LDIPL #IMM */
 884
 885   set_flags (0x700, flg*0x100);
 886
 887   /** 0111 010w 1100 dest  MOV.size:G #IMM,dest */
 888
 889   dc = decode_srcdest4 (dest, w);
 890   imm = IMM(w);
 891   v = imm;
 892   tprintf("%x = %x\n", v, v);
 893   set_sz(v, w+1);
 894   put_dest (dc, v);
 895
 896   /** 1101 100w immm dest  MOV.size:Q #IMM,dest */
 897
 898   dc = decode_srcdest4 (dest, w);
 899   v = sign_ext (immm, 4);
 900   tprintf ("%x = %x\n", v, v);
 901   set_sz (v, w+1);
 902   put_dest (dc, v);
 903
 904   /** 1100 0dst            MOV.B:S #IMM8,dest */
 905
 906   imm = IMM(0);
 907   dc = decode_dest3 (dst, 0);
 908   v = imm;
 909   tprintf("%x = %x\n", v, v);
 910   set_sz (v, 1);
 911   put_dest (dc, v);
 912
 913   /** 1w10 d010            MOV.size:S #IMM,dest */
 914
 915   /* Note that for w, 0=W and 1=B unlike the usual meaning.  */
 916   v = IMM(1-w);
 917   tprintf("%x = %x\n", v, v);
 918   set_sz (v, 2-w);
 919   put_reg (d ? a1 : a0, v);
 920
 921   /** 1011 0dst            MOV.B:Z #0,dest */
 922
 923   dc = decode_dest3 (dst, 0);
 924   v = 0;
 925   set_sz (v, 1);
 926   put_dest (dc, v);
 927
 928   /** 0111 001w srcx dest  MOV.size:G src,dest */
 929
 930   sc = decode_srcdest4 (srcx, w);
 931   dc = decode_srcdest4 (dest, w);
 932   v = get_src (sc);
 933   set_sz (v, w+1);
 934   put_dest (dc, v);
 935
 936   /** 0011 0d sr           MOV.B:S src,dest */
 937
 938   sc = decode_src2 (sr, 0, d);
 939   v = get_src (sc);
 940   set_sz (v, 1);
 941   put_reg (d ? a1 : a0, v);
 942
 943   /** 0000 0s ds           MOV.B:S R0L/R0H,dest */
 944
 945   if (ds == 0)
 946     UNSUPPORTED();
 947   dc = decode_src2 (ds, 0, s);
 948   v = get_reg (s ? r0h : r0l);
 949   set_sz (v, 1);
 950   put_dest (dc, v);
 951
 952   /** 0000 1d sr           MOV.B:S src,R0L/R0H */
 953
 954   sc = decode_src2 (sr, 0, d);
 955   v = get_src (sc);
 956   set_sz (v, 1);
 957   put_reg (d ? r0h : r0l, v);
 958
 959   /** 0111 010w 1011 dest  MOV.size:G dsp:8[SP], dest */
 960
 961   dc = decode_srcdest4 (dest, w);
 962   imm = IMM(0);
 963   a = get_reg (sp) + sign_ext (imm, 8);
 964   a &= addr_mask;
 965   if (w)
 966     v = mem_get_hi (a);
 967   else
 968     v = mem_get_qi (a);
 969   set_sz (v, w+1);
 970   put_dest (dc, v);
 971
 972   /** 0111 010w 0011 srcx  MOV.size:G src, disp8[SP] */
 973
 974   sc = decode_srcdest4 (srcx, w);
 975   imm = IMM(0);
 976   a = get_reg (sp) + sign_ext (imm, 8);
 977   a &= addr_mask;
 978   v = get_src (sc);
 979   if (w)
 980     mem_put_hi (a, v);
 981   else
 982     mem_put_qi (a, v);
 983   set_sz (v, w+1);
 984
 985   /** 1110 1011 0reg 1src  MOVA src,dest */
 986
 987   {
 988   static reg_id map[] = { r0, r1, r2, r3, a0, a1, 0, 0 };
 989   sc = decode_srcdest4 (8 + src, 0);
 990   put_reg (map[reg], sc.u.addr);
 991   }
 992
 993   /** 0111 1100 10hl dest  MOVdir R0L,dest */
 994
 995   if (dest == 0 || dest == 4 || dest == 5)
 996     UNSUPPORTED();
 997   dc = decode_srcdest4 (dest, 0);
 998   a = get_src (dc);
 999   b = get_reg (r0l);
1000   switch (hl)
1001     {
1002     case 0: a = (a & 0xf0) | (b & 0x0f); break;
1003     case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break;
1004     case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break;
1005     case 3: a = (a & 0x0f) | (b & 0xf0); break;
1006     }
1007   put_dest (dc, a);
1008
1009   /** 0111 1100 00hl srcx  MOVdir src,R0L */
1010
1011   if (srcx == 0 || srcx == 4 || srcx == 5)
1012     UNSUPPORTED();
1013   sc = decode_srcdest4 (srcx, 0);
1014   a = get_reg (r0l);
1015   b = get_src (sc);
1016   switch (hl)
1017     {
1018     case 0: a = (a & 0xf0) | (b & 0x0f); break;
1019     case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break;
1020     case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break;
1021     case 3: a = (a & 0x0f) | (b & 0xf0); break;
1022     }
1023   put_reg (r0l, a);
1024
1025   /** 0111 110w 0101 dest  MUL.size #IMM,dest */
1026
1027   UNARY_SOP;
1028   imm = sign_ext (IMM(w), w?16:8);
1029   tprintf("%d * %d = %d\n", v, imm, v*imm);
1030   v *= imm;
1031   dc = widen_sd (dc);
1032   put_dest (dc, v);
1033
1034   /** 0111 100w srcx dest  MUL.size src,dest */
1035
1036   BINARY_SOP;
1037   v = a * b;
1038   tprintf("%d * %d = %d\n", a, b, v);
1039   dc = widen_sd (dc);
1040   put_dest (dc, v);
1041
1042   /** 0111 110w 0100 dest  MULU.size #IMM,dest */
1043
1044   UNARY_UOP;
1045   imm = IMM(w);
1046   tprintf("%u * %u = %u\n", v, imm, v*imm);
1047   v *= imm;
1048   dc = widen_sd (dc);
1049   put_dest (dc, v);
1050
1051   /** 0111 000w srcx dest  MULU.size src,dest */
1052
1053   BINARY_UOP;
1054   v = a * b;
1055   tprintf("%u * %u = %u\n", a, b, v);
1056   dc = widen_sd (dc);
1057   put_dest (dc, v);
1058
1059   /** 0111 010w 0101 dest  NEG.size dest */
1060
1061   UNARY_SOP;
1062   tprintf("%d * -1 = %d\n", v, -v);
1063   v = -v;
1064   set_oszc (v, w+1, v == 0);
1065   put_dest (dc, v);
1066
1067   /** 0000 0100            NOP */
1068
1069   tprintf("nop\n");
1070
1071   /** 0111 010w 0111 dest  NOT.size:G */
1072
1073   UNARY_UOP;
1074   tprintf("~ %x = %x\n", v, ~v);
1075   v = ~v;
1076   set_sz (v, w+1);
1077   put_dest (dc, v);
1078
1079   /** 1011 1dst            NOT.B:S dest */
1080
1081   dc = decode_dest3 (dst, 0);
1082   v = get_src (dc);
1083   tprintf("~ %x = %x\n", v, ~v);
1084   v = ~v;
1085   set_sz (v, 1);
1086   put_dest (dc, v);
1087
1088   /** 0111 011w 0011 dest  OR.size:G #IMM,dest */
1089
1090   UNARY_UOP;
1091   imm = IMM(w);
1092   tprintf ("%x | %x = %x\n", v, imm, v | imm);
1093   v |= imm;
1094   set_sz (v, w+1);
1095   put_dest (dc, v);
1096
1097   /** 1001 1dst            OR.B:S #IMM8,dest */
1098
1099   imm = IMM(0);
1100   dc = decode_dest3 (dst, 0);
1101   v = get_src (dc);
1102   tprintf("%x | %x = %x\n", v, imm, v|imm);
1103   v |= imm;
1104   set_sz (v, 1);
1105   put_dest (dc, v);
1106
1107   /** 1001 100w srcx dest  OR.size:G src,dest */
1108
1109   BINARY_UOP;
1110   tprintf ("%x | %x = %x\n", a, b, a | b);
1111   v = a | b;
1112   set_sz (v, w+1);
1113   put_dest (dc, v);
1114
1115   /** 0001 1d sr           OR.B:S src,R0L/R0H */
1116
1117   sc = decode_src2 (sr, 0, d);
1118   dc = decode_dest1 (d, 0);
1119   a = get_src (sc);
1120   b = get_src (dc);
1121   v = a | b;
1122   tprintf("%x | %x = %x\n", a, b, v);
1123   set_sz (v, 1);
1124   put_dest (dc, v);
1125
1126   /** 0111 010w 1101 dest  POP.size:G dest */
1127
1128   dc = decode_srcdest4 (dest, w);
1129   if (w)
1130     {
1131       v = mem_get_hi (get_reg (sp));
1132       put_reg (sp, get_reg (sp) + 2);
1133       tprintf("pophi: %x\n", v);
1134     }
1135   else
1136     {
1137       v = mem_get_qi (get_reg (sp));
1138       put_reg (sp, get_reg (sp) + 1);
1139       tprintf("popqi: %x\n", v);
1140     }
1141   put_dest (dc, v);
1142
1143   /** 1001 d010            POP.B:S dest */
1144
1145   v = mem_get_qi (get_reg (sp));
1146   put_reg (d ? r0h : r0l, v);
1147   put_reg (sp, get_reg (sp) + 1);
1148   tprintf("popqi: %x\n", v);
1149
1150   /** 1101 d010            POP.W:S dest */
1151
1152   v = mem_get_hi (get_reg (sp));
1153   put_reg (d ? a1 : a0, v);
1154   put_reg (sp, get_reg (sp) + 2);
1155   tprintf("pophi: %x\n", v);
1156
1157   /** 1110 1011 0reg 0011  POPC dest */
1158
1159   dc = decode_cr (reg);
1160   v = mem_get_hi (get_reg (sp));
1161   put_dest (dc, v);
1162   put_reg (sp, get_reg (sp) + 2);
1163   tprintf("popc: %x\n", v);
1164
1165   /** 1110 1101            POPM dest */
1166
1167   {
1168   static int map[] = { r0, r1, r2, r3, a0, a1, sb, fb };
1169   imm = IMM(0);
1170   tprintf("popm: %x\n", imm);
1171   for (a=0; a<8; a++)
1172     if (imm & (1<<a))
1173       {
1174         v = mem_get_hi (get_reg (sp));
1175         put_reg (map[a], v);
1176         put_reg (sp, get_reg (sp) + 2);
1177       }
1178   }
1179
1180   /** 0111 110w 1110 0010  PUSH.size:G #IMM */
1181
1182   imm = IMM(w);
1183   if (w)
1184     {
1185       put_reg (sp, get_reg (sp) - 2);
1186       mem_put_hi (get_reg (sp), imm);
1187       tprintf("pushhi %04x\n", imm);
1188     }
1189   else
1190     {
1191       put_reg (sp, get_reg (sp) - 1);
1192       mem_put_qi (get_reg (sp), imm);
1193       tprintf("pushqi %02x\n", imm);
1194     }
1195
1196   /** 0111 010w 0100 srcx  PUSH.size:G src */
1197
1198   sc = decode_srcdest4 (srcx, w);
1199   v = get_src (sc);
1200   if (w)
1201     {
1202       put_reg (sp, get_reg (sp) - 2);
1203       mem_put_hi (get_reg (sp), v);
1204       tprintf("pushhi: %x\n", v);
1205     }
1206   else
1207     {
1208       put_reg (sp, get_reg (sp) - 1);
1209       mem_put_qi (get_reg (sp), v);
1210       tprintf("pushqi: %x\n", v);
1211     }
1212
1213   /** 1000 s010            PUSH.B:S src */
1214
1215   v = get_reg (s ? r0h : r0l);
1216   put_reg (sp, get_reg (sp) - 1);
1217   mem_put_qi (get_reg (sp), v);
1218   tprintf("pushqi: %x\n", v);
1219
1220   /** 1100 s010            PUSH.W:S src */
1221
1222   v = get_reg (s ? a1 : a0);
1223   put_reg (sp, get_reg (sp) - 2);
1224   mem_put_hi (get_reg (sp), v);
1225   tprintf("pushhi: %x\n", v);
1226
1227   /** 0111 1101 1001 srcx  PUSHA src */
1228
1229   sc = decode_srcdest4 (srcx, 0);
1230   put_reg (sp, get_reg (sp) - 2);
1231   mem_put_hi (get_reg (sp), sc.u.addr);
1232   tprintf("pushhi: %x\n", sc.u.addr);
1233
1234   /** 1110 1011 0src 0010  PUSHC src */
1235
1236   sc = decode_cr (src);
1237   put_reg (sp, get_reg (sp) - 2);
1238   v = get_src (sc);
1239   mem_put_hi (get_reg (sp), v);
1240   tprintf("pushc: %x\n", v);
1241
1242   /** 1110 1100            PUSHM src */
1243
1244   {
1245   static int map[] = { fb, sb, a1, a0, r3, r2, r1, r0 };
1246   imm = IMM(0);
1247   tprintf("pushm: %x\n", imm);
1248   for (a=0; a<8; a++)
1249     if (imm & (1<<a))
1250       {
1251         put_reg (sp, get_reg (sp) - 2);
1252         v = get_reg (map[a]);
1253         mem_put_hi (get_reg (sp), v);
1254       }
1255   }
1256
1257   /** 1111 1011            REIT */
1258
1259   a = get_reg (sp);
1260   v = (mem_get_hi (a)
1261        + 4096 * (mem_get_qi (a+3) & 0xf0));
1262   b = (mem_get_qi (a+2)
1263        + 256 * (mem_get_qi (a+3) & 0xff));
1264   put_reg (pc, v);
1265   put_reg (flags, b);
1266   put_reg (sp, get_reg (sp) + 4);
1267
1268   /** 0111 110w 1111 0001  RMPA.size */
1269
1270   {
1271   int count = get_reg (r3);
1272   int list1 = get_reg (a0);
1273   int list2 = get_reg (a1);
1274   int sum = get_reg (w ? r2r0 : r0);
1275
1276   while (count)
1277     {
1278       if (w)
1279         {
1280           a = sign_ext (mem_get_hi (list1), 16);
1281           b = sign_ext (mem_get_hi (list2), 16);
1282         }
1283       else
1284         {
1285           a = sign_ext (mem_get_qi (list1), 8);
1286           b = sign_ext (mem_get_qi (list2), 8);
1287         }
1288       tprintf("%d + %d * %d = ", sum, a, b);
1289       sum += a * b;
1290       tprintf("%d\n", sum);
1291       list1 += w ? 2 : 1;
1292       list2 += w ? 2 : 1;
1293       count --;
1294     }
1295   put_reg (r3, count);
1296   put_reg (a0, list1);
1297   put_reg (a1, list2);
1298   put_reg (w ? r2r0 : r0, sum);
1299   }
1300
1301   /** 0111 011w 1010 dest  ROLC.size dest */
1302
1303   dc = decode_srcdest4 (dest, w);
1304   rot_op (dc, 1, 1);
1305
1306   /** 0111 011w 1011 dest  RORC.size dest */
1307
1308   dc = decode_srcdest4 (dest, w);
1309   rot_op (dc, 1, -1);
1310
1311   /** 1110 000w immm dest  ROT.size #IMM,dest */
1312
1313   dc = decode_srcdest4 (dest, w);
1314   rot_op (dc, 0, IMM4());
1315
1316   /** 0111 010w 0110 dest  ROT.size R1H,dest */
1317
1318   dc = decode_srcdest4 (dest, w);
1319   rot_op (dc, 0, sign_ext (get_reg (r1h), 8));
1320
1321   /** 1111 0011            RTS */
1322
1323   put_reg (pc, mem_get_psi (get_reg (sp)));
1324   put_reg (sp, get_reg (sp) + 3);
1325
1326   /** 0111 011w 0111 dest  SBB.size #IMM,dest */
1327
1328   dc = decode_srcdest4 (dest, w);
1329   imm = IMM(w);
1330   MATH_OP (dc, imm, !carry, -, >= 0);
1331
1332   /** 1011 100w srcx dest  SBB.size src,dest */
1333
1334   sc = decode_srcdest4(srcx, w);
1335   dc = decode_srcdest4(dest, w);
1336   b = get_src (sc);
1337   MATH_OP (dc, b, !carry, -, >= 0);
1338
1339   /** 1111 000w immm dest  SHA.size #IMM, dest */
1340
1341   dc = decode_srcdest4(dest, w);
1342   shift_op (dc, 1, IMM4());
1343
1344   /** 0111 010w 1111 dest  SHA.size R1H,dest */
1345
1346   dc = decode_srcdest4(dest, w);
1347   a = sign_ext (get_reg (r1h), 8);
1348   shift_op (dc, 1, a);
1349
1350   /** 1110 1011 101d immm  SHA.L #IMM, dest */
1351
1352   dc = reg_sd (d ? r3r1 : r2r0);
1353   shift_op (dc, 1, IMM4());
1354
1355   /** 1110 1011 001d 0001  SHA.L R1H,dest */
1356
1357   dc = reg_sd (d ? r3r1 : r2r0);
1358   a = sign_ext (get_reg (r1h), 8);
1359   shift_op (dc, 1, a);
1360
1361   /** 1110 100w immm dest  SHL.size #IMM, dest */
1362
1363   dc = decode_srcdest4(dest, w);
1364   shift_op (dc, 0, IMM4());
1365
1366   /** 0111 010w 1110 dest  SHL.size R1H,dest */
1367
1368   dc = decode_srcdest4(dest, w);
1369   a = sign_ext (get_reg (r1h), 8);
1370   shift_op (dc, 0, a);
1371
1372   /** 1110 1011 100d immm  SHL.L #IMM,dest */
1373
1374   dc = reg_sd (d ? r3r1 : r2r0);
1375   shift_op (dc, 0, IMM4());
1376
1377   /** 1110 1011 000d 0001  SHL.L R1H,dest */
1378
1379   dc = reg_sd (d ? r3r1 : r2r0);
1380   a = sign_ext (get_reg (r1h), 8);
1381   shift_op (dc, 0, a);
1382
1383   /** 0111 110w 1110 100z  SMOVB.size */
1384
1385   {
1386   int count = get_reg (r3);
1387   int s1 = get_reg (a0) + (get_reg (r1h) << 16);
1388   int s2 = get_reg (a1);
1389   int inc = (w ? 2 : 1) * (z ? -1 : 1);
1390
1391   while (count)
1392     {
1393       if (w)
1394         {
1395           v = mem_get_hi (s1);
1396           mem_put_hi (s2, v);
1397         }
1398       else
1399         {
1400           v = mem_get_qi (s1);
1401           mem_put_qi (s2, v);
1402         }
1403       s1 += inc;
1404       s2 += inc;
1405       count --;
1406     }
1407   put_reg (r3, count);
1408   put_reg (a0, s1 & 0xffff);
1409   put_reg (a1, s2);
1410   put_reg (r1h, s1 >> 16);
1411   }
1412
1413   /** 0111 110w 1110 1010  SSTR.size */
1414
1415   {
1416   int count = get_reg (r3);
1417   int s1 = get_reg (a1);
1418   v = get_reg (w ? r0 : r0l);
1419
1420   while (count)
1421     {
1422       if (w)
1423         {
1424           mem_put_hi (s1, v);
1425           s1 += 2;
1426         }
1427       else
1428         {
1429           mem_put_qi (s1, v);
1430           s1 += 1;
1431         }
1432       count --;
1433     }
1434   put_reg (r3, count);
1435   put_reg (a1, s1);
1436   }
1437
1438   /** 0111 1011 1src dest  STC src,dest */
1439
1440   dc = decode_srcdest4 (dest, 1);
1441   sc = decode_cr (src);
1442   put_dest (dc, get_src(sc));
1443
1444   /** 0111 1100 1100 dest  STC PC,dest */
1445
1446   dc = decode_srcdest4 (dest, 1);
1447   dc.bytes = 3;
1448   put_dest (dc, orig_pc);
1449
1450   /** 0111 1101 1111 0000  STCTX abs16,abs20 */
1451
1452   NOTYET();
1453
1454   /** 0111 010w 0000 srcx  STE.size src,abs20 */
1455
1456   sc = decode_srcdest4 (srcx, w);
1457   a = IMM(2);
1458   v = get_src (sc);
1459   if (w)
1460     mem_put_hi (a, v);
1461   else
1462     mem_put_qi (a, v);
1463   if (srcx == 4 || srcx == 5)
1464     {
1465       v = get_reg (sc.u.reg);
1466       set_sz (v, 2);
1467     }
1468   else
1469     set_sz (v, w+1);
1470
1471   /** 0111 010w 0001 srcx  STE.size src,disp20[a0] */
1472
1473   sc = decode_srcdest4 (srcx, w);
1474   a = get_reg(a0) + IMM(2);
1475   v = get_src (sc);
1476   if (w)
1477     mem_put_hi (a, v);
1478   else
1479     mem_put_qi (a, v);
1480   if (srcx == 4 || srcx == 5)
1481     {
1482       v = get_reg (sc.u.reg);
1483       set_sz (v, 2);
1484     }
1485   else
1486     set_sz (v, w+1);
1487
1488   /** 0111 010w 0010 srcx  STE.size src,[a1a0] */
1489
1490   sc = decode_srcdest4 (srcx, w);
1491   a = get_reg(a1a0);
1492   v = get_src (sc);
1493   if (w)
1494     mem_put_hi (a, v);
1495   else
1496     mem_put_qi (a, v);
1497   if (srcx == 4 || srcx == 5)
1498     {
1499       v = get_reg (sc.u.reg);
1500       set_sz (v, 2);
1501     }
1502   else
1503     set_sz (v, w+1);
1504
1505   /** 1101 0dst            STNZ #IMM8,dest */
1506
1507   imm = IMM(0);
1508   dc = decode_dest3(dst, 0);
1509   if (!FLAG_Z)
1510     put_dest (dc, imm);
1511
1512   /** 1100 1dst            STZ #IMM8,dest */
1513
1514   imm = IMM(0);
1515   dc = decode_dest3(dst, 0);
1516   if (FLAG_Z)
1517     put_dest (dc, imm);
1518
1519   /** 1101 1dst            STZX #IMM81,#IMM82,dest */
1520
1521   a = IMM(0);
1522   dc = decode_dest3(dst, 0);
1523   b = IMM(0);
1524   if (FLAG_Z)
1525     put_dest (dc, a);
1526   else
1527     put_dest (dc, b);
1528
1529   /** 0111 011w 0101 dest  SUB.size:G #IMM,dest */
1530
1531   dc = decode_srcdest4 (dest, w);
1532   imm = IMM(w);
1533   MATH_OP (dc, imm, 0, -, >= 0);
1534
1535   /** 1000 1dst            SUB.B:S #IMM8,dest */
1536
1537   imm = IMM(0);
1538   dc = decode_dest3 (dst, 0);
1539   MATH_OP (dc, imm, 0, -, >= 0);
1540
1541   /** 1010 100w srcx dest  SUB.size:G src,dest */
1542
1543   sc = decode_srcdest4(srcx, w);
1544   dc = decode_srcdest4(dest, w);
1545   b = get_src (sc);
1546   MATH_OP (dc, b, 0, -, >= 0);
1547
1548   /** 0010 1d sr           SUB.B:S src,R0L/R0H */
1549
1550   sc = decode_src2 (sr, 0, d);
1551   dc = decode_dest1 (d, 0);
1552   b = get_src (sc);
1553   MATH_OP (dc, b, 0, -, >= 0);
1554
1555   /** 0111 011w 0000 dest  TST.size #IMM, dest */
1556
1557   UNARY_UOP;
1558   imm = IMM(w);
1559   tprintf ("%x & %x = %x\n", v, imm, v & imm);
1560   v &= imm;
1561   set_sz (v, w+1);
1562
1563   /** 1000 000w srcx dest  TST.size src,dest */
1564
1565   BINARY_UOP;
1566   tprintf ("%x & %x = %x\n", a, b, a & b);
1567   v = a & b;
1568   set_sz (v, w+1);
1569
1570   /** 1111 1111            UND */
1571
1572   trigger_fixed_interrupt (0xffdc);
1573
1574   /** 0111 1101 1111 0011  WAIT */
1575
1576   tprintf("waiting...\n");
1577
1578   /** 0111 101w 00sr dest  XCHG.size src,dest */
1579
1580   sc = decode_srcdest4 (sr, w);
1581   dc = decode_srcdest4 (dest, w);
1582   a = get_src (sc);
1583   b = get_src (dc);
1584   put_dest (dc, a);
1585   put_dest (sc, b);
1586
1587   /** 0111 011w 0001 dest  XOR.size #IMM,dest */
1588
1589   UNARY_UOP;
1590   imm = IMM(w);
1591   tprintf ("%x ^ %x = %x\n", v, imm, v ^ imm);
1592   v ^= imm;
1593   set_sz (v, w+1);
1594   put_dest (dc, v);
1595
1596   /** 1000 100w srcx dest  XOR.size src,dest */
1597
1598   BINARY_UOP;
1599   tprintf ("%x ^ %x = %x\n", a, b, a ^ b);
1600   v = a ^ b;
1601   set_sz (v, w+1);
1602   put_dest (dc, v);
1603
1604   /**                      OP */
1605 /** */
1606
1607   return step_result;
1608 }