sim/m32c/r8c.opc

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