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   int src = i ? IMM(w) : get_reg (w ? r1 : r0h);
 592   int dest = get_reg (w ? r0 : r0l);
 593   int res;
 594
 595   src = bcd2int(src, w);
 596   dest = bcd2int(dest, w);
 597
 598   tprintf("decimal: %d %s %d", dest, s?"-":"+", src);
 599   if (c)
 600     tprintf(" c=%d", carry);
 601
 602   if (!s)
 603     {
 604       res = dest + src;
 605       if (c)
 606         res += carry;
 607       c = res > (w ? 9999 : 99);
 608     }
 609   else
 610     {
 611       res = dest - src;
 612       if (c)
 613         res -= (1-carry);
 614       c = res >= 0;
 615       if (res < 0)
 616         res += w ? 10000 : 100;
 617     }
 618
 619   res = int2bcd (res, w);
 620   tprintf(" = %x\n", res);
 621
 622   set_szc (res, w+1, c);
 623
 624   put_reg (w ? r0 : r0l, res);
 625
 626   /** 1010 1dst            DEC.B dest */
 627
 628   dc = decode_dest3 (dst, 0);
 629   v = get_src (dc);
 630   tprintf("%x -- = %x\n", v, v-1);
 631   v --;
 632   set_sz (v, 1);
 633   put_dest (dc, v);
 634
 635   /** 1111 d010            DEC.W dest */
 636
 637   v = get_reg (d ? a1 : a0);
 638   tprintf("%x -- = %x\n", v, v-1);
 639   v --;
 640   set_sz (v, 2);
 641   put_reg (d ? a1 : a0, v);
 642
 643   /** 0111 110w 1110 0001  DIV.size #IMM */
 644
 645   div_op (-1, 0, 0, w);
 646
 647   /** 0111 011w 1101 srcx  DIV.size src */
 648
 649   div_op (srcx, 0, 0, w);
 650
 651   /** 0111 110w 1110 0000  DIVU.size #IMM */
 652
 653   div_op (-1, 1, 0, w);
 654
 655   /** 0111 011w 1100 srcx  DIVU.size src */
 656
 657   div_op (srcx, 1, 0, w);
 658
 659   /** 0111 110w 1110 0011  DIVX.size #IMM */
 660
 661   div_op (-1, 0, 1, w);
 662
 663   /** 0111 011w 1001 srcx  DIVX.size src */
 664
 665   div_op (srcx, 0, 1, w);
 666
 667   /** 0111 1100 1111 0010  ENTER #IMM8 */
 668
 669   imm = IMM(0);
 670   put_reg (sp, get_reg (sp) - 2);
 671   mem_put_hi (get_reg (sp), get_reg (fb));
 672   put_reg (fb, get_reg (sp));
 673   put_reg (sp, get_reg (sp) - imm);
 674
 675   /** 0111 1101 1111 0010  EXITD */
 676
 677   put_reg (sp, get_reg (fb));
 678   put_reg (fb, mem_get_hi (get_reg (sp)));
 679   put_reg (sp, get_reg (sp) + 2);
 680   put_reg (pc, mem_get_psi (get_reg (sp)));
 681   put_reg (sp, get_reg (sp) + 3);
 682
 683   /** 0111 1100 0110 dest  EXTS.B dest */
 684
 685   dc = decode_srcdest4 (dest, 0);
 686   v = sign_ext (get_src (dc), 8);
 687   dc = widen_sd (dc);
 688   put_dest (dc, v);
 689   set_sz (v, 1);
 690
 691   /** 0111 1100 1111 0011  EXTS.W R0 */
 692
 693   v = sign_ext (get_reg (r0), 16);
 694   put_reg (r2r0, v);
 695   set_sz (v, 2);
 696
 697   /** 1110 1011 0flg 0101  FCLR dest */
 698
 699   set_flags (1 << flg, 0);
 700
 701   /** 1110 1011 0flg 0100  FSET dest */
 702
 703   set_flags (1 << flg, 1 << flg);
 704
 705   /** 1010 0dst            INC.B dest */
 706
 707   dc = decode_dest3 (dst, 0);
 708   v = get_src (dc);
 709   tprintf("%x ++ = %x\n", v, v+1);
 710   v ++;
 711   set_sz (v, 1);
 712   put_dest (dc, v);
 713
 714   /** 1011 d010            INC.W dest */
 715
 716   v = get_reg (d ? a1 : a0);
 717   tprintf("%x ++ = %x\n", v, v+1);
 718   v ++;
 719   set_sz (v, 2);
 720   put_reg (d ? a1 : a0, v);
 721
 722   /** 1110 1011 11vector   INT #imm */
 723
 724   trigger_based_interrupt (vector);
 725
 726   /** 1111 0110            INTO */
 727
 728   if (FLAG_O)
 729     trigger_fixed_interrupt (0xffe0);
 730
 731   /** 0110 1cnd            Jcnd label */
 732
 733   v = sign_ext (IMM(0), 8);
 734   if (condition_true (cnd))
 735     put_reg (pc, orig_pc + 1 + v);
 736
 737   /** 0111 1101 1100 cond  Jcnd label */
 738
 739   v = sign_ext (IMM(0), 8);
 740   if (condition_true (cond))
 741     put_reg (pc, orig_pc + 2 + v);
 742
 743   /** 0110 0dsp            JMP.S label */
 744
 745   put_reg (pc, orig_pc + 2 + dsp);
 746
 747   /** 1111 1110            JMP.B label */
 748
 749   imm = sign_ext (IMM(0), 8);
 750   if (imm == -1)
 751     {
 752       if (verbose)
 753         printf("[jmp-to-self detected as exit]\n");
 754       return M32C_MAKE_HIT_BREAK ();
 755     }
 756   put_reg (pc, orig_pc + 1 + imm);
 757
 758   /** 1111 0100            JMP.W label */
 759
 760   imm = sign_ext (IMM(1), 16);
 761   put_reg (pc, orig_pc + 1 + imm);
 762
 763   /** 1111 1100            JMP.A label */
 764
 765   imm = IMM(2);
 766   put_reg (pc, imm);
 767
 768   /** 0111 1101 0010 srcx  JMPI.W src */
 769
 770   sc = decode_jumpdest (srcx, 1);
 771   a = get_src (sc);
 772   a = sign_ext (a, 16);
 773   put_reg (pc, orig_pc + a);
 774
 775   /** 0111 1101 0000 srcx  JMPI.A src */
 776
 777   sc = decode_jumpdest (srcx, 0);
 778   a = get_src (sc);
 779   put_reg (pc, a);
 780
 781   /** 1110 1110            JMPS #IMM8 */
 782
 783   M16C_ONLY();
 784
 785   imm = IMM(0);
 786   a = 0xf0000 + mem_get_hi (0xffffe - imm * 2);
 787   put_reg (pc, a);
 788
 789   /** 1111 0101            JSR.W label */
 790
 791   imm = sign_ext (IMM(1), 16);
 792   put_reg (sp, get_reg (sp) - 3);
 793   mem_put_psi (get_reg (sp), get_reg (pc));
 794   put_reg (pc, orig_pc + imm + 1);
 795
 796   /** 1111 1101            JSR.A label */
 797
 798   imm = IMM(2);
 799   put_reg (sp, get_reg (sp) - 3);
 800   mem_put_psi (get_reg (sp), get_reg (pc));
 801   put_reg (pc, imm);
 802
 803   /** 0111 1101 0011 srcx  JSRI.W src */
 804
 805   sc = decode_jumpdest (srcx, 1);
 806   a = get_src (sc);
 807   a = sign_ext (a, 16);
 808
 809   put_reg (sp, get_reg (sp) - 3);
 810   mem_put_psi (get_reg (sp), get_reg (pc));
 811   put_reg (pc, orig_pc + a);
 812
 813   /** 0111 1101 0001 srcx  JSRI.A src */
 814
 815   sc = decode_jumpdest (srcx, 0);
 816   a = get_src (sc);
 817
 818   put_reg (sp, get_reg (sp) - 3);
 819   mem_put_psi (get_reg (sp), get_reg (pc));
 820   put_reg (pc, a);
 821
 822   /** 1110 1111            JSRS #IMM8 */
 823
 824   M16C_ONLY();
 825
 826   imm = IMM(0);
 827   a = 0xf0000 + mem_get_hi (0xffffe - imm * 2);
 828
 829   put_reg (sp, get_reg (sp) - 3);
 830   mem_put_psi (get_reg (sp), get_reg (pc));
 831   put_reg (pc, a);
 832
 833   /** 1110 1011 0reg 0000  LDC #IMM16,dest */
 834
 835   dc = decode_cr (reg);
 836   imm = IMM(1);
 837   put_dest (dc, imm);
 838
 839   /** 0111 1010 1reg srcx  LDC src,dest */
 840
 841   dc = decode_cr (reg);
 842   sc = decode_srcdest4 (srcx,1);
 843   put_dest (dc, get_src (sc));
 844
 845   /** 0111 1100 1111 0000  LDCTX abs16,abs20 */
 846
 847   NOTYET();
 848
 849   /** 0111 010w 1000 dest  LDE.size abs20,dest */
 850
 851   dc = decode_srcdest4 (dest, w);
 852   imm = IMM(2);
 853   if (w)
 854     v = mem_get_hi (imm);
 855   else
 856     v = mem_get_qi (imm);
 857   put_dest (dc, v);
 858
 859   /** 0111 010w 1001 dest  LDE.size dsp:20[a0], dest */
 860
 861   dc = decode_srcdest4 (dest, w);
 862   imm = IMM(2) + get_reg (a0);
 863   if (w)
 864     v = mem_get_hi (imm);
 865   else
 866     v = mem_get_qi (imm);
 867   put_dest (dc, v);
 868
 869   /** 0111 010w 1010 dest  LDE.size [a1a0],dest */
 870
 871   dc = decode_srcdest4 (dest, w);
 872   imm = get_reg (a1a0);
 873   if (w)
 874     v = mem_get_hi (imm);
 875   else
 876     v = mem_get_qi (imm);
 877   put_dest (dc, v);
 878
 879   /** 0111 1101 1010 0imm  LDIPL #IMM */
 880
 881   set_flags (0x700, imm*0x100);
 882
 883   /** 0111 010w 1100 dest  MOV.size:G #IMM,dest */
 884
 885   dc = decode_srcdest4 (dest, w);
 886   imm = IMM(w);
 887   v = imm;
 888   tprintf("%x = %x\n", v, v);
 889   set_sz(v, w+1);
 890   put_dest (dc, v);
 891
 892   /** 1101 100w immm dest  MOV.size:Q #IMM,dest */
 893
 894   dc = decode_srcdest4 (dest, w);
 895   v = sign_ext (immm, 4);
 896   tprintf ("%x = %x\n", v, v);
 897   set_sz (v, w+1);
 898   put_dest (dc, v);
 899
 900   /** 1100 0dst            MOV.B:S #IMM8,dest */
 901
 902   imm = IMM(0);
 903   dc = decode_dest3 (dst, 0);
 904   v = imm;
 905   tprintf("%x = %x\n", v, v);
 906   set_sz (v, 1);
 907   put_dest (dc, v);
 908
 909   /** 1w10 d010            MOV.size:S #IMM,dest */
 910
 911   /* Note that for w, 0=W and 1=B unlike the usual meaning.  */
 912   v = IMM(1-w);
 913   tprintf("%x = %x\n", v, v);
 914   set_sz (v, 2-w);
 915   put_reg (d ? a1 : a0, v);
 916
 917   /** 1011 0dst            MOV.B:Z #0,dest */
 918
 919   dc = decode_dest3 (dst, 0);
 920   v = 0;
 921   set_sz (v, 1);
 922   put_dest (dc, v);
 923
 924   /** 0111 001w srcx dest  MOV.size:G src,dest */
 925
 926   sc = decode_srcdest4 (srcx, w);
 927   dc = decode_srcdest4 (dest, w);
 928   v = get_src (sc);
 929   set_sz (v, w+1);
 930   put_dest (dc, v);
 931
 932   /** 0011 0d sr           MOV.B:S src,dest */
 933
 934   sc = decode_src2 (sr, 0, d);
 935   v = get_src (sc);
 936   set_sz (v, 1);
 937   put_reg (d ? a1 : a0, v);
 938
 939   /** 0000 0s ds           MOV.B:S R0L/R0H,dest */
 940
 941   if (ds == 0)
 942     UNSUPPORTED();
 943   dc = decode_src2 (ds, 0, s);
 944   v = get_reg (s ? r0h : r0l);
 945   set_sz (v, 1);
 946   put_dest (dc, v);
 947
 948   /** 0000 1d sr           MOV.B:S src,R0L/R0H */
 949
 950   sc = decode_src2 (sr, 0, d);
 951   v = get_src (sc);
 952   set_sz (v, 1);
 953   put_reg (d ? r0h : r0l, v);
 954
 955   /** 0111 010w 1011 dest  MOV.size:G dsp:8[SP], dest */
 956
 957   dc = decode_srcdest4 (dest, w);
 958   imm = IMM(0);
 959   a = get_reg (sp) + sign_ext (imm, 8);
 960   a &= addr_mask;
 961   if (w)
 962     v = mem_get_hi (a);
 963   else
 964     v = mem_get_qi (a);
 965   set_sz (v, w+1);
 966   put_dest (dc, v);
 967
 968   /** 0111 010w 0011 srcx  MOV.size:G src, disp8[SP] */
 969
 970   sc = decode_srcdest4 (srcx, w);
 971   imm = IMM(0);
 972   a = get_reg (sp) + sign_ext (imm, 8);
 973   a &= addr_mask;
 974   v = get_src (sc);
 975   if (w)
 976     mem_put_hi (a, v);
 977   else
 978     mem_put_qi (a, v);
 979   set_sz (v, w+1);
 980
 981   /** 1110 1011 0reg 1src  MOVA src,dest */
 982
 983   static reg_id map[] = { r0, r1, r2, r3, a0, a1, 0, 0 };
 984   sc = decode_srcdest4 (8 + src, 0);
 985   put_reg (map[reg], sc.u.addr);
 986
 987   /** 0111 1100 10hl dest  MOVdir R0L,dest */
 988
 989   if (dest == 0 || dest == 4 || dest == 5)
 990     UNSUPPORTED();
 991   dc = decode_srcdest4 (dest, 0);
 992   a = get_src (dc);
 993   b = get_reg (r0l);
 994   switch (hl)
 995     {
 996     case 0: a = (a & 0xf0) | (b & 0x0f); break;
 997     case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break;
 998     case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break;
 999     case 3: a = (a & 0x0f) | (b & 0xf0); break;
1000     }
1001   put_dest (dc, a);
1002
1003   /** 0111 1100 00hl srcx  MOVdir src,R0L */
1004
1005   if (srcx == 0 || srcx == 4 || srcx == 5)
1006     UNSUPPORTED();
1007   sc = decode_srcdest4 (srcx, 0);
1008   a = get_reg (r0l);
1009   b = get_src (sc);
1010   switch (hl)
1011     {
1012     case 0: a = (a & 0xf0) | (b & 0x0f); break;
1013     case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break;
1014     case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break;
1015     case 3: a = (a & 0x0f) | (b & 0xf0); break;
1016     }
1017   put_reg (r0l, a);
1018
1019   /** 0111 110w 0101 dest  MUL.size #IMM,dest */
1020
1021   UNARY_SOP;
1022   imm = sign_ext (IMM(w), w?16:8);
1023   tprintf("%d * %d = %d\n", v, imm, v*imm);
1024   v *= imm;
1025   dc = widen_sd (dc);
1026   put_dest (dc, v);
1027
1028   /** 0111 100w srcx dest  MUL.size src,dest */
1029
1030   BINARY_SOP;
1031   v = a * b;
1032   tprintf("%d * %d = %d\n", a, b, v);
1033   dc = widen_sd (dc);
1034   put_dest (dc, v);
1035
1036   /** 0111 110w 0100 dest  MULU.size #IMM,dest */
1037
1038   UNARY_UOP;
1039   imm = IMM(w);
1040   tprintf("%u * %u = %u\n", v, imm, v*imm);
1041   v *= imm;
1042   dc = widen_sd (dc);
1043   put_dest (dc, v);
1044
1045   /** 0111 000w srcx dest  MULU.size src,dest */
1046
1047   BINARY_UOP;
1048   v = a * b;
1049   tprintf("%u * %u = %u\n", a, b, v);
1050   dc = widen_sd (dc);
1051   put_dest (dc, v);
1052
1053   /** 0111 010w 0101 dest  NEG.size dest */
1054
1055   UNARY_SOP;
1056   tprintf("%d * -1 = %d\n", v, -v);
1057   v = -v;
1058   set_oszc (v, w+1, v == 0);
1059   put_dest (dc, v);
1060
1061   /** 0000 0100            NOP */
1062
1063   tprintf("nop\n");
1064
1065   /** 0111 010w 0111 dest  NOT.size:G */
1066
1067   UNARY_UOP;
1068   tprintf("~ %x = %x\n", v, ~v);
1069   v = ~v;
1070   set_sz (v, w+1);
1071   put_dest (dc, v);
1072
1073   /** 1011 1dst            NOT.B:S dest */
1074
1075   dc = decode_dest3 (dst, 0);
1076   v = get_src (dc);
1077   tprintf("~ %x = %x\n", v, ~v);
1078   v = ~v;
1079   set_sz (v, 1);
1080   put_dest (dc, v);
1081
1082   /** 0111 011w 0011 dest  OR.size:G #IMM,dest */
1083
1084   UNARY_UOP;
1085   imm = IMM(w);
1086   tprintf ("%x | %x = %x\n", v, imm, v | imm);
1087   v |= imm;
1088   set_sz (v, w+1);
1089   put_dest (dc, v);
1090
1091   /** 1001 1dst            OR.B:S #IMM8,dest */
1092
1093   imm = IMM(0);
1094   dc = decode_dest3 (dst, 0);
1095   v = get_src (dc);
1096   tprintf("%x | %x = %x\n", v, imm, v|imm);
1097   v |= imm;
1098   set_sz (v, 1);
1099   put_dest (dc, v);
1100
1101   /** 1001 100w srcx dest  OR.size:G src,dest */
1102
1103   BINARY_UOP;
1104   tprintf ("%x | %x = %x\n", a, b, a | b);
1105   v = a | b;
1106   set_sz (v, w+1);
1107   put_dest (dc, v);
1108
1109   /** 0001 1d sr           OR.B:S src,R0L/R0H */
1110
1111   sc = decode_src2 (sr, 0, d);
1112   dc = decode_dest1 (d, 0);
1113   a = get_src (sc);
1114   b = get_src (dc);
1115   v = a | b;
1116   tprintf("%x | %x = %x\n", a, b, v);
1117   set_sz (v, 1);
1118   put_dest (dc, v);
1119
1120   /** 0111 010w 1101 dest  POP.size:G dest */
1121
1122   dc = decode_srcdest4 (dest, w);
1123   if (w)
1124     {
1125       v = mem_get_hi (get_reg (sp));
1126       put_reg (sp, get_reg (sp) + 2);
1127       tprintf("pophi: %x\n", v);
1128     }
1129   else
1130     {
1131       v = mem_get_qi (get_reg (sp));
1132       put_reg (sp, get_reg (sp) + 1);
1133       tprintf("popqi: %x\n", v);
1134     }
1135   put_dest (dc, v);
1136
1137   /** 1001 d010            POP.B:S dest */
1138
1139   v = mem_get_qi (get_reg (sp));
1140   put_reg (d ? r0h : r0l, v);
1141   put_reg (sp, get_reg (sp) + 1);
1142   tprintf("popqi: %x\n", v);
1143
1144   /** 1101 d010            POP.W:S dest */
1145
1146   v = mem_get_hi (get_reg (sp));
1147   put_reg (d ? a1 : a0, v);
1148   put_reg (sp, get_reg (sp) + 2);
1149   tprintf("pophi: %x\n", v);
1150
1151   /** 1110 1011 0reg 0011  POPC dest */
1152
1153   dc = decode_cr (reg);
1154   v = mem_get_hi (get_reg (sp));
1155   put_dest (dc, v);
1156   put_reg (sp, get_reg (sp) + 2);
1157   tprintf("popc: %x\n", v);
1158
1159   /** 1110 1101            POPM dest */
1160
1161   static int map[] = { r0, r1, r2, r3, a0, a1, sb, fb };
1162   imm = IMM(0);
1163   tprintf("popm: %x\n", imm);
1164   for (a=0; a<8; a++)
1165     if (imm & (1<<a))
1166       {
1167         v = mem_get_hi (get_reg (sp));
1168         put_reg (map[a], v);
1169         put_reg (sp, get_reg (sp) + 2);
1170       }
1171
1172   /** 0111 110w 1110 0010  PUSH.size:G #IMM */
1173
1174   imm = IMM(w);
1175   if (w)
1176     {
1177       put_reg (sp, get_reg (sp) - 2);
1178       mem_put_hi (get_reg (sp), imm);
1179       tprintf("pushhi %04x\n", imm);
1180     }
1181   else
1182     {
1183       put_reg (sp, get_reg (sp) - 1);
1184       mem_put_qi (get_reg (sp), imm);
1185       tprintf("pushqi %02x\n", imm);
1186     }
1187
1188   /** 0111 010w 0100 srcx  PUSH.size:G src */
1189
1190   sc = decode_srcdest4 (srcx, w);
1191   v = get_src (sc);
1192   if (w)
1193     {
1194       put_reg (sp, get_reg (sp) - 2);
1195       mem_put_hi (get_reg (sp), v);
1196       tprintf("pushhi: %x\n", v);
1197     }
1198   else
1199     {
1200       put_reg (sp, get_reg (sp) - 1);
1201       mem_put_qi (get_reg (sp), v);
1202       tprintf("pushqi: %x\n", v);
1203     }
1204
1205   /** 1000 s010            PUSH.B:S src */
1206
1207   v = get_reg (s ? r0h : r0l);
1208   put_reg (sp, get_reg (sp) - 1);
1209   mem_put_qi (get_reg (sp), v);
1210   tprintf("pushqi: %x\n", v);
1211
1212   /** 1100 s010            PUSH.W:S src */
1213
1214   v = get_reg (s ? a1 : a0);
1215   put_reg (sp, get_reg (sp) - 2);
1216   mem_put_hi (get_reg (sp), v);
1217   tprintf("pushhi: %x\n", v);
1218
1219   /** 0111 1101 1001 srcx  PUSHA src */
1220
1221   sc = decode_srcdest4 (srcx, 0);
1222   put_reg (sp, get_reg (sp) - 2);
1223   mem_put_hi (get_reg (sp), sc.u.addr);
1224   tprintf("pushhi: %x\n", sc.u.addr);
1225
1226   /** 1110 1011 0src 0010  PUSHC src */
1227
1228   sc = decode_cr (src);
1229   put_reg (sp, get_reg (sp) - 2);
1230   v = get_src (sc);
1231   mem_put_hi (get_reg (sp), v);
1232   tprintf("pushc: %x\n", v);
1233
1234   /** 1110 1100            PUSHM src */
1235
1236   static int map[] = { fb, sb, a1, a0, r3, r2, r1, r0 };
1237   imm = IMM(0);
1238   tprintf("pushm: %x\n", imm);
1239   for (a=0; a<8; a++)
1240     if (imm & (1<<a))
1241       {
1242         put_reg (sp, get_reg (sp) - 2);
1243         v = get_reg (map[a]);
1244         mem_put_hi (get_reg (sp), v);
1245       }
1246
1247   /** 1111 1011            REIT */
1248
1249   a = get_reg (sp);
1250   v = (mem_get_hi (a)
1251        + 4096 * (mem_get_qi (a+3) & 0xf0));
1252   b = (mem_get_qi (a+2)
1253        + 256 * (mem_get_qi (a+3) & 0xff));
1254   put_reg (pc, v);
1255   put_reg (flags, b);
1256   put_reg (sp, get_reg (sp) + 4);
1257
1258   /** 0111 110w 1111 0001  RMPA.size */
1259
1260   int count = get_reg (r3);
1261   int list1 = get_reg (a0);
1262   int list2 = get_reg (a1);
1263   int sum = get_reg (w ? r2r0 : r0);
1264
1265   while (count)
1266     {
1267       if (w)
1268         {
1269           a = sign_ext (mem_get_hi (list1), 16);
1270           b = sign_ext (mem_get_hi (list2), 16);
1271         }
1272       else
1273         {
1274           a = sign_ext (mem_get_qi (list1), 8);
1275           b = sign_ext (mem_get_qi (list2), 8);
1276         }
1277       tprintf("%d + %d * %d = ", sum, a, b);
1278       sum += a * b;
1279       tprintf("%d\n", sum);
1280       list1 += w ? 2 : 1;
1281       list2 += w ? 2 : 1;
1282       count --;
1283     }
1284   put_reg (r3, count);
1285   put_reg (a0, list1);
1286   put_reg (a1, list2);
1287   put_reg (w ? r2r0 : r0, sum);
1288
1289   /** 0111 011w 1010 dest  ROLC.size dest */
1290
1291   dc = decode_srcdest4 (dest, w);
1292   rot_op (dc, 1, 1);
1293
1294   /** 0111 011w 1011 dest  RORC.size dest */
1295
1296   dc = decode_srcdest4 (dest, w);
1297   rot_op (dc, 1, -1);
1298
1299   /** 1110 000w immm dest  ROT.size #IMM,dest */
1300
1301   dc = decode_srcdest4 (dest, w);
1302   rot_op (dc, 0, IMM4());
1303
1304   /** 0111 010w 0110 dest  ROT.size R1H,dest */
1305
1306   dc = decode_srcdest4 (dest, w);
1307   rot_op (dc, 0, sign_ext (get_reg (r1h), 8));
1308
1309   /** 1111 0011            RTS */
1310
1311   put_reg (pc, mem_get_psi (get_reg (sp)));
1312   put_reg (sp, get_reg (sp) + 3);
1313
1314   /** 0111 011w 0111 dest  SBB.size #IMM,dest */
1315
1316   dc = decode_srcdest4 (dest, w);
1317   imm = IMM(w);
1318   MATH_OP (dc, imm, !carry, -, >= 0);
1319
1320   /** 1011 100w srcx dest  SBB.size src,dest */
1321
1322   sc = decode_srcdest4(srcx, w);
1323   dc = decode_srcdest4(dest, w);
1324   b = get_src (sc);
1325   MATH_OP (dc, b, !carry, -, >= 0);
1326
1327   /** 1111 000w immm dest  SHA.size #IMM, dest */
1328
1329   dc = decode_srcdest4(dest, w);
1330   shift_op (dc, 1, IMM4());
1331
1332   /** 0111 010w 1111 dest  SHA.size R1H,dest */
1333
1334   dc = decode_srcdest4(dest, w);
1335   a = sign_ext (get_reg (r1h), 8);
1336   shift_op (dc, 1, a);
1337
1338   /** 1110 1011 101d immm  SHA.L #IMM, dest */
1339
1340   dc = reg_sd (d ? r3r1 : r2r0);
1341   shift_op (dc, 1, IMM4());
1342
1343   /** 1110 1011 001d 0001  SHA.L R1H,dest */
1344
1345   dc = reg_sd (d ? r3r1 : r2r0);
1346   a = sign_ext (get_reg (r1h), 8);
1347   shift_op (dc, 1, a);
1348
1349   /** 1110 100w immm dest  SHL.size #IMM, dest */
1350
1351   dc = decode_srcdest4(dest, w);
1352   shift_op (dc, 0, IMM4());
1353
1354   /** 0111 010w 1110 dest  SHL.size R1H,dest */
1355
1356   dc = decode_srcdest4(dest, w);
1357   a = sign_ext (get_reg (r1h), 8);
1358   shift_op (dc, 0, a);
1359
1360   /** 1110 1011 100d immm  SHL.L #IMM,dest */
1361
1362   dc = reg_sd (d ? r3r1 : r2r0);
1363   shift_op (dc, 0, IMM4());
1364
1365   /** 1110 1011 000d 0001  SHL.L R1H,dest */
1366
1367   dc = reg_sd (d ? r3r1 : r2r0);
1368   a = sign_ext (get_reg (r1h), 8);
1369   shift_op (dc, 0, a);
1370
1371   /** 0111 110w 1110 100b  SMOVB.size */
1372
1373   int count = get_reg (r3);
1374   int s1 = get_reg (a0) + (get_reg (r1h) << 16);
1375   int s2 = get_reg (a1);
1376   int inc = (w ? 2 : 1) * (b ? -1 : 1);
1377
1378   while (count)
1379     {
1380       if (w)
1381         {
1382           v = mem_get_hi (s1);
1383           mem_put_hi (s2, v);
1384         }
1385       else
1386         {
1387           v = mem_get_qi (s1);
1388           mem_put_qi (s2, v);
1389         }
1390       s1 += inc;
1391       s2 += inc;
1392       count --;
1393     }
1394   put_reg (r3, count);
1395   put_reg (a0, s1 & 0xffff);
1396   put_reg (a1, s2);
1397   put_reg (r1h, s1 >> 16);
1398
1399   /** 0111 110w 1110 1010  SSTR.size */
1400
1401   int count = get_reg (r3);
1402   int s1 = get_reg (a1);
1403   v = get_reg (w ? r0 : r0l);
1404
1405   while (count)
1406     {
1407       if (w)
1408         {
1409           mem_put_hi (s1, v);
1410           s1 += 2;
1411         }
1412       else
1413         {
1414           mem_put_qi (s1, v);
1415           s1 += 1;
1416         }
1417       count --;
1418     }
1419   put_reg (r3, count);
1420   put_reg (a1, s1);
1421
1422   /** 0111 1011 1src dest  STC src,dest */
1423
1424   dc = decode_srcdest4 (dest, 1);
1425   sc = decode_cr (src);
1426   put_dest (dc, get_src(sc));
1427
1428   /** 0111 1100 1100 dest  STC PC,dest */
1429
1430   dc = decode_srcdest4 (dest, 1);
1431   dc.bytes = 3;
1432   put_dest (dc, orig_pc);
1433
1434   /** 0111 1101 1111 0000  STCTX abs16,abs20 */
1435
1436   NOTYET();
1437
1438   /** 0111 010w 0000 srcx  STE.size src,abs20 */
1439
1440   sc = decode_srcdest4 (srcx, w);
1441   a = IMM(2);
1442   v = get_src (sc);
1443   if (w)
1444     mem_put_hi (a, v);
1445   else
1446     mem_put_qi (a, v);
1447   if (srcx == 4 || srcx == 5)
1448     {
1449       v = get_reg (sc.u.reg);
1450       set_sz (v, 2);
1451     }
1452   else
1453     set_sz (v, w+1);
1454
1455   /** 0111 010w 0001 srcx  STE.size src,disp20[a0] */
1456
1457   sc = decode_srcdest4 (srcx, w);
1458   a = get_reg(a0) + IMM(2);
1459   v = get_src (sc);
1460   if (w)
1461     mem_put_hi (a, v);
1462   else
1463     mem_put_qi (a, v);
1464   if (srcx == 4 || srcx == 5)
1465     {
1466       v = get_reg (sc.u.reg);
1467       set_sz (v, 2);
1468     }
1469   else
1470     set_sz (v, w+1);
1471
1472   /** 0111 010w 0010 srcx  STE.size src,[a1a0] */
1473
1474   sc = decode_srcdest4 (srcx, w);
1475   a = get_reg(a1a0);
1476   v = get_src (sc);
1477   if (w)
1478     mem_put_hi (a, v);
1479   else
1480     mem_put_qi (a, v);
1481   if (srcx == 4 || srcx == 5)
1482     {
1483       v = get_reg (sc.u.reg);
1484       set_sz (v, 2);
1485     }
1486   else
1487     set_sz (v, w+1);
1488
1489   /** 1101 0dst            STNZ #IMM8,dest */
1490
1491   imm = IMM(0);
1492   dc = decode_dest3(dst, 0);
1493   if (!FLAG_Z)
1494     put_dest (dc, imm);
1495
1496   /** 1100 1dst            STZ #IMM8,dest */
1497
1498   imm = IMM(0);
1499   dc = decode_dest3(dst, 0);
1500   if (FLAG_Z)
1501     put_dest (dc, imm);
1502
1503   /** 1101 1dst            STZX #IMM81,#IMM82,dest */
1504
1505   a = IMM(0);
1506   dc = decode_dest3(dst, 0);
1507   b = IMM(0);
1508   if (FLAG_Z)
1509     put_dest (dc, a);
1510   else
1511     put_dest (dc, b);
1512
1513   /** 0111 011w 0101 dest  SUB.size:G #IMM,dest */
1514
1515   dc = decode_srcdest4 (dest, w);
1516   imm = IMM(w);
1517   MATH_OP (dc, imm, 0, -, >= 0);
1518
1519   /** 1000 1dst            SUB.B:S #IMM8,dest */
1520
1521   imm = IMM(0);
1522   dc = decode_dest3 (dst, 0);
1523   MATH_OP (dc, imm, 0, -, >= 0);
1524
1525   /** 1010 100w srcx dest  SUB.size:G src,dest */
1526
1527   sc = decode_srcdest4(srcx, w);
1528   dc = decode_srcdest4(dest, w);
1529   b = get_src (sc);
1530   MATH_OP (dc, b, 0, -, >= 0);
1531
1532   /** 0010 1d sr           SUB.B:S src,R0L/R0H */
1533
1534   sc = decode_src2 (sr, 0, d);
1535   dc = decode_dest1 (d, 0);
1536   b = get_src (sc);
1537   MATH_OP (dc, b, 0, -, >= 0);
1538
1539   /** 0111 011w 0000 dest  TST.size #IMM, dest */
1540
1541   UNARY_UOP;
1542   imm = IMM(w);
1543   tprintf ("%x & %x = %x\n", v, imm, v & imm);
1544   v &= imm;
1545   set_sz (v, w+1);
1546
1547   /** 1000 000w srcx dest  TST.size src,dest */
1548
1549   BINARY_UOP;
1550   tprintf ("%x & %x = %x\n", a, b, a & b);
1551   v = a & b;
1552   set_sz (v, w+1);
1553
1554   /** 1111 1111            UND */
1555
1556   trigger_fixed_interrupt (0xffdc);
1557
1558   /** 0111 1101 1111 0011  WAIT */
1559
1560   tprintf("waiting...\n");
1561
1562   /** 0111 101w 00sr dest  XCHG.size src,dest */
1563
1564   sc = decode_srcdest4 (sr, w);
1565   dc = decode_srcdest4 (dest, w);
1566   a = get_src (sc);
1567   b = get_src (dc);
1568   put_dest (dc, a);
1569   put_dest (sc, b);
1570
1571   /** 0111 011w 0001 dest  XOR.size #IMM,dest */
1572
1573   UNARY_UOP;
1574   imm = IMM(w);
1575   tprintf ("%x ^ %x = %x\n", v, imm, v ^ imm);
1576   v ^= imm;
1577   set_sz (v, w+1);
1578   put_dest (dc, v);
1579
1580   /** 1000 100w srcx dest  XOR.size src,dest */
1581
1582   BINARY_UOP;
1583   tprintf ("%x ^ %x = %x\n", a, b, a ^ b);
1584   v = a ^ b;
1585   set_sz (v, w+1);
1586   put_dest (dc, v);
1587
1588   /**                      OP */
1589 /** */
1590
1591   return step_result;
1592 }