sim/m32c/r8c.opc

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