1 /* m32c.opc --- semantics for m32c opcodes. -*- mode: c -*-
3 Copyright (C) 2005, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
5 Contributed by Red Hat, Inc.
7 This file is part of the GNU simulators.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
31 #define AU __attribute__((unused))
33 #define tprintf if (trace) printf
49 #define M32C_ONLY() /* FIXME: add something here */
51 #define GETBYTE() (op[opi++] = getbyte())
53 #define UNSUPPORTED() unsupported("unsupported", m32c_opcode_pc)
54 #define NOTYET() unsupported("unimplemented", m32c_opcode_pc)
57 unsupported (char *tag, int orig_pc)
60 printf("%s opcode at %08x\n", tag, orig_pc);
65 printf(" %s", bits(b>>4, 4));
66 printf(" %s", bits(b, 4));
73 printf(" %02x", mem_get_pc ());
87 rv = mem_get_qi (get_reg(pc));
90 rv = mem_get_hi (get_reg(pc));
93 rv = mem_get_psi (get_reg(pc));
96 rv = mem_get_si (get_reg(pc));
103 #define IMM4() (immm >= 8 ? 7 - immm : immm + 1)
105 #define NO_PREFIX() PREFIX(0,0,0)
107 /* Indicate which sorts of prefixes are allowed for the current
110 prefix (src_allowed, dest_allowed, index_bytewidth)
112 /* At the moment, we don't do anything with this information. We
113 just wanted to get the information entered in some
114 machine-readable form while we were going through all the
118 #define MATH_OP(dc,s,c,op) \
122 mb = s & b2mask[dc.bytes]; \
123 ll = (long long)ma op (long long)mb op c; \
124 tprintf("0x%x " #op " 0x%x " #op " 0x%x = 0x%llx\n", ma, mb, c, ll); \
125 ma = sign_ext (ma, dc.bytes * 8); \
126 mb = sign_ext (s, dc.bytes * 8); \
128 tprintf("%d " #op " %d " #op " %d = %d\n", ma, mb, c, v); \
129 set_oszc (v, dc.bytes, (1 op 1) ? (ll > b2mask[dc.bytes]) : (ll >= 0)); \
133 #define LOGIC_OP(dc,s,op) \
137 mb = s & b2mask[dc.bytes]; \
139 tprintf("0x%x " #op " 0x%x = 0x%x\n", ma, mb, v); \
140 set_sz (v, dc.bytes); \
144 #define BIT_OP(dc,bit,expr) \
145 b = get_bit2 (dc, bitindex == -1 ? bit : bitindex); \
147 tprintf ("b=%d, bit=%d, carry=%d, %s = %d\n", \
148 b, bitindex == -1 ? bit : bitindex, carry, #expr, v); \
149 put_bit2 (dc, bitindex == -1 ? bit : bitindex, v);
151 #define BIT_OPC(dc,bit,expr) \
152 b = get_bit2 (dc, bitindex == -1 ? bit : bitindex); \
154 tprintf ("b=%d, bit=%d, carry=%d, %s = %d\n", \
155 b, bitindex == -1 ? bit : bitindex, carry, #expr, v); \
158 #define carry (FLAG_C ? 1 : 0)
161 cmp (int d, int s, int bytes)
165 b = sign_ext (d, bytes*8) - sign_ext (s, bytes*8);
166 tprintf ("cmp: %x - %x = %08x, %x - %x = %d\n",
168 sign_ext(d,bytes*8), sign_ext(s,bytes*8), b);
172 if (b & b2signbit[bytes])
174 if ((d & b2mask[bytes]) >= (s & b2mask[bytes]))
176 if (b < b2minsigned[bytes] || b > b2maxsigned[bytes])
179 set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_O | FLAGBIT_C, f);
183 dadd_op (int ddd, int dd, int sss, int ss, int imm, int add, int cy, int w)
192 sc = decode_src23 (sss, ss, w+1);
195 dc = decode_dest23 (ddd, dd, w+1);
203 tprintf("decimal: %d %s %d", a, add?"+":"-", b);
205 tprintf(" c=%d", carry);
212 cy = res > (w ? 9999 : 99);
221 res += w ? 10000 : 100;
224 res = int2bcd (res, w);
225 tprintf(" = %x\n", res);
227 set_szc (res, w+1, cy);
231 #define DADDV(A,C) dadd_op(ddd, dd, sss, ss, 0, A, C, w)
232 #define DADDI(A,C) dadd_op(ddd, dd, 0, 0, 1, A, C, w)
235 div_op (int sss, int ss, int u, int x, int bytes)
244 sc = decode_dest23 (sss, ss, bytes);
248 v = get_reg (bytes > 1 ? r2r0 : r0);
252 /* FIXME? do we sign extend a0/a1 to .L? Docs say zero extend. */
253 s = sign_ext (s, bytes*8);
254 v = sign_ext (v, bytes*8);
259 set_flags (FLAGBIT_O, FLAGBIT_O);
265 a = (unsigned int)v / (unsigned int)s;
266 b = (unsigned int)v % (unsigned int)s;
282 tprintf ("%d / %d = %d rem %d\n", v, s, a, b);
283 if ((!u && (a > b2maxsigned[bytes]
284 || a < b2minsigned[bytes]))
285 || (u && (a > b2mask[bytes])))
286 set_flags (FLAGBIT_O, FLAGBIT_O);
288 set_flags (FLAGBIT_O, 0);
307 index_op (int sss, int ss, int do_s, int do_d, int scale, int w)
309 srcdest sc = decode_src23 (sss, ss, w+1);
310 int v = get_src (sc) * scale;
311 tprintf("%d = %d * %d, %d %d\n", v, get_src(sc), scale, do_s, do_d);
312 decode_index (do_s * v, do_d * v);
314 #define INDEXOP(scale,do_s,do_d) \
315 index_op (sss, ss, do_s, do_d, scale, w); goto next_opcode
318 rot_op (srcdest sd, int rotc, int count)
320 int mask = (sd.bytes == 2) ? 0xffff : 0xff;
321 int msb = (sd.bytes == 2) ? 0x8000 : 0x80;
322 int v = get_src (sd);
325 tprintf("%s %x by %d\n", rotc ? "rotc" : "rot", v, count);
326 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
329 ct = (v & msb) ? 1 : 0;
334 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
341 v |= (rotc ? c : ct) * msb;
343 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
347 set_szc (v, sd.bytes, c);
351 shift_op (srcdest sd, int arith, int count, int setc)
353 int mask = (sd.bytes == 2) ? 0xffff : 0xff;
354 int msb = (sd.bytes == 2) ? 0x8000 : 0x80;
355 int v = get_src (sd);
365 tprintf("%s %x by %d\n", arith ? "sha" : "shl", v, count);
366 tprintf (": %s %d %d\n", bits(v, 8*sd.bytes), c, o);
369 c = (v & msb) ? 1 : 0;
372 if (c != ((v & msb) ? 1 : 0))
374 tprintf (": %s %d %d\n", bits(v, 8*sd.bytes), c, o);
381 v = (v & msb) | (v >> 1);
383 v = (v >> 1) & (msb - 1);
384 tprintf (": %s %d %d\n", bits(v, 8*sd.bytes), c, o);
388 set_sz (v, sd.bytes);
391 set_flags (FLAGBIT_O, o ? FLAGBIT_O : 0);
400 unsigned char op[40];
407 int t0, t1=0, t2, t3=0;
410 step_result = M32C_MAKE_STEPPED ();
412 decode_indirect (0, 0);
417 m32c_opcode_pc = get_reg (pc);
419 tprintf("trace: decode pc = %06x\n", m32c_opcode_pc);
421 if (m32c_opcode_pc == 0)
424 printf("Abort: PC is zero, here from:\n");
426 printf(" 0x%06x\n", pcs[(ipcs+15-i)%16]);
427 return M32C_MAKE_HIT_BREAK ();
429 pcs[ipcs++] = m32c_opcode_pc;
432 /** VARY sss 000 001 010 011 100 */
433 /** VARY ddd 000 001 010 011 100 */
435 /** 0000 1001 indirect dest */
437 decode_indirect (0, 1);
440 /** 0100 0001 indirect src */
442 decode_indirect (1, 0);
445 /** 0100 1001 indirect src and dest */
447 decode_indirect (1, 1);
450 /** 1010 ddd w dd01 1111 ABS.size dest */
453 dc = decode_dest23 (ddd, dd, w+1);
454 v = sign_ext (get_src (dc), w?16:8);
456 tprintf("abs(%d) = %d\n", v, a);
460 /** 0000 0001 1000 ddd w dd10 1110 ADC.size #IMM,dest */
463 dc = decode_dest23 (ddd, dd, w+1);
465 MATH_OP (dc, imm, carry, +);
467 /** 0000 0001 1sss ddd w dd ss 0100 ADC.size src,dest */
470 sc = decode_src23 (sss, ss, w+1);
471 dc = decode_dest23 (ddd, dd, w+1);
473 MATH_OP (dc, b, carry, +);
475 /** 1011 ddd w dd01 1110 ADCF.size dest */
478 dc = decode_dest23 (ddd, dd, w+1);
479 MATH_OP (dc, 0, carry, +);
481 /** 1000 ddd w dd10 1110 ADD.size:G #IMM,dest */
484 dc = decode_dest23(ddd, dd, w+1);
486 MATH_OP (dc, imm, 0, +);
488 /** 1000 ddd0 dd11 0001 ADD.L:G #IMM,dest */
491 dc = decode_dest23(ddd, dd, 4);
493 MATH_OP (dc, imm, 0, +);
495 /** 111L ddd w dd11 immm ADD.size:Q #IMM,dest */
498 dc = decode_dest23(ddd, dd, L ? 4 : (w+1));
499 imm = sign_ext (immm, 4);
500 MATH_OP (dc, imm, 0, +);
502 /** 00dd 011w ADD.size:S #IMM,dest */
505 dc = decode_dest2(dd, w+1);
507 MATH_OP (dc, imm, 0, +);
509 /** 10i0 110d ADD.L:S #IMM,A0/A1 */
512 dc = reg_sd (d ? a1 : a0);
514 MATH_OP (dc, imm, 0, +);
516 /** 1sss ddd w dd ss 1000 ADD.size:G src,dest */
519 sc = decode_src23(sss, ss, w+1);
520 dc = decode_dest23(ddd, dd, w+1);
522 MATH_OP (dc, b, 0, +);
524 /** 1sss ddd1 dd ss 0010 ADD.L:G src,dest */
527 sc = decode_src23(sss, ss, 4);
528 dc = decode_dest23(ddd, dd, 4);
530 MATH_OP (dc, b, 0, +);
532 /** 1011 0110 0001 0011 ADD.L:G #IMM16,SP */
536 b = sign_ext (IMM(2), 16);
537 MATH_OP (dc, b, 0, +);
539 /** 01ii 001i ADD.L:Q #IMM3,SP */
544 MATH_OP (dc, b, 0, +);
546 /** 1011 0110 0000 0011 ADD.L:S #IMM8,SP */
550 b = sign_ext (IMM(1), 8);
551 MATH_OP (dc, b, 0, +);
553 /** 1000 ddd0 dd01 0001 ADDX #IMM,dest */
556 dc = decode_dest23(ddd, dd, 4);
557 imm = sign_ext (IMM(1), 8);
558 MATH_OP (dc, imm, 0, +);
560 /** 1sss ddd0 dd ss 0010 ADDX src,dest */
563 sc = decode_src23(sss, ss, 1);
564 dc = decode_dest23(ddd, dd, 4);
565 b = sign_ext (get_src (sc), 8);
566 MATH_OP (dc, b, 0, +);
568 /** 1111 ddd w dd01 immm ADJNZ.size #IMM,dest,label */
571 dc = decode_dest23 (ddd, dd, w+1);
573 imm = sign_ext(immm, 4);
574 tprintf("%d + %d = %d\n", v, imm, v+imm);
577 a = sign_ext (IMM(1), 8);
578 if ((v & (w ? 0xffff : 0xff)) != 0)
580 tprintf("jmp: %x + 2 + %d = ", get_reg (pc), a);
581 put_reg (pc, m32c_opcode_pc + 2 + a);
582 tprintf("%x\n", get_reg (pc));
585 /** 1000 ddd w dd11 1111 AND.size:G #IMM,dest */
588 dc = decode_dest23(ddd, dd, w+1);
590 LOGIC_OP (dc, imm, &);
592 /** 01dd 110w AND.size:S #IMM,dest */
595 dc = decode_dest2(dd, w+1);
597 LOGIC_OP (dc, imm, &);
599 /** 1sss ddd w dd ss 1101 AND.size:G src,dest */
602 sc = decode_src23(sss, ss, w+1);
603 dc = decode_dest23(ddd, dd, w+1);
607 /** 0000 0001 1101 sss0 ss00 1bit BAND src */
609 sc = decode_src23 (sss, ss, 1);
610 BIT_OPC (sc, bit, b & carry);
612 /** 1101 ddd0 dd11 0bit BCLR dest */
614 dc = decode_dest23 (ddd, dd, 1);
617 /** 1100 ddd w dd10 1110 BITINDEX.size src */
620 dc = decode_dest23 (ddd, dd, w+1);
621 bitindex = get_src (dc);
622 tprintf ("bitindex set to %d\n", bitindex);
625 /** 1101 ddd0 dd01 0bit BMcnd dest */
628 dc = decode_dest23 (ddd, dd, 1);
629 if (condition_true (IMM (1)))
630 put_bit2 (dc, bit, 1);
632 put_bit2 (dc, bit, 0);
634 /** 1101 1001 0c10 1cnd BMcnd C */
637 if (condition_true (c * 8 + cnd))
642 /** 0000 0001 1101 sss0 ss01 1bit BNAND src */
645 sc = decode_src23 (sss, ss, 1);
646 BIT_OPC (sc, bit, (!b) & carry);
648 /** 0000 0001 1101 sss0 ss11 0bit BNOR src */
651 sc = decode_src23 (sss, ss, 1);
652 BIT_OPC (sc, bit, (!b) | carry);
654 /** 1101 ddd0 dd01 1bit BNOT dest */
657 dc = decode_dest23 (ddd, dd, 1);
658 BIT_OP (dc, bit, !b);
660 /** 0000 0001 1101 sss0 ss00 0bit BNTST src */
663 sc = decode_dest23 (sss, ss, 1);
664 b = get_bit2 (sc, bit);
667 /** 0000 0001 1101 sss0 ss11 1bit BNXOR src */
670 sc = decode_src23 (sss, ss, 1);
671 BIT_OPC (sc, bit, !b ^ carry);
673 /** 0000 0001 1101 sss0 ss10 0bit BOR src */
676 sc = decode_src23 (sss, ss, 1);
677 BIT_OPC (sc, bit, b | carry);
681 /* We report the break to our caller with the PC still pointing at the
682 breakpoint instruction. */
683 put_reg (pc, m32c_opcode_pc);
686 if (in_gdb || (regs.r_intbl == 0 && regs.r_intbh == 0))
687 return M32C_MAKE_HIT_BREAK ();
688 if (mem_get_qi (0xFFFFE7) == 0xff)
689 trigger_based_interrupt (0);
691 trigger_fixed_interrupt (0xFFFFE4);
693 /** 1111 1110 GBRK */
695 /* This alternate break, which is not part of the chip's opcode set,
696 is here in case you need to debug a program that itself uses the
697 chip's BRK opcode. You'll need to modify your copy of GDB to use
698 this opcode instead of the real BRK. */
701 /* We report the break to our caller with the PC still pointing at the
702 breakpoint instruction. */
703 put_reg (pc, m32c_opcode_pc);
705 printf("[gdb break]\n");
706 return M32C_MAKE_HIT_BREAK ();
708 /** 0000 1000 BRK2 */
711 printf("[break2]\n");
713 return M32C_MAKE_HIT_BREAK ();
714 if (mem_get_qi (0xFFFFE7) == 0xff)
715 trigger_based_interrupt (0);
717 trigger_fixed_interrupt (0xFFFFE4);
719 /** 1101 ddd0 dd11 1bit BSET dest */
721 dc = decode_dest23 (ddd, dd, 1);
724 /** 1101 sss0 ss00 0bit BTST:G src */
727 sc = decode_src23 (sss, ss, 1);
728 b = get_bit2 (sc, bit);
731 /** 00bb 101b BTST:S src */
733 sc = decode_src23 (3, 3, 1); /* bit,base:19 */
734 b = get_bit2 (sc, bb*2 + b);
737 /** 1101 ddd0 dd10 0bit BTSTC dest */
740 sc = decode_dest23 (ddd, dd, 1);
741 b = get_bit2 (sc, bit);
743 put_bit2 (sc, bit, 0);
745 /** 1101 ddd0 dd10 1bit BTSTS dest */
748 sc = decode_dest23 (ddd, dd, 1);
749 b = get_bit2 (sc, bit);
751 put_bit2 (sc, bit, 1);
753 /** 0000 0001 1101 sss0 ss10 1bit BXOR src */
756 sc = decode_src23 (sss, ss, 1);
757 BIT_OPC (sc, bit, b ^ carry);
759 /** 0000 0001 1000 ddd w dd11 1110 CLIP.size #IMM1,#IMM2,dest */
762 dc = decode_dest23 (ddd, dd, w+1);
763 a = sign_ext (IMM(w+1), w*8+8);
764 b = sign_ext (IMM(w+1), w*8+8);
765 v = sign_ext (get_src (dc), w*8+8);
766 tprintf("clip %d <= %d <= %d : ", a, v, b);
774 /** 1001 ddd w dd10 1110 CMP.size:G #IMM,dest */
777 dc = decode_dest23 (ddd, dd, w+1);
782 /** 1010 ddd0 dd11 0001 CMP.L:G #IMM32,dest */
785 dc = decode_dest23 (ddd, dd, 4);
790 /** 1110 ddd w dd01 immm CMP.size:Q #IMM,dest */
793 dc = decode_dest23 (ddd, dd, w+1);
795 immm = sign_ext (immm, 4);
798 /** 01dd 011w CMP.size:S #IMM,dest */
801 dc = decode_dest2 (dd, w+1);
803 imm = sign_ext (IMM(w+1),w*8+8);
806 /** 1sss ddd w dd ss 0110 CMP.size:G src,dest */
809 sc = decode_src23 (sss, ss, w+1);
810 dc = decode_dest23 (ddd, dd, w+1);
815 /** 1sss ddd1 dd ss 0001 CMP.L:G src,dest */
818 sc = decode_src23 (sss, ss, 4);
819 dc = decode_dest23 (ddd, dd, 4);
824 /** 01dd 000w CMP.size:S src,R0/R0L */
827 dc = decode_dest2 (dd, w+1);
828 a = get_reg (w ? r0 : r0l);
832 /** 1010 ddd0 dd01 0001 CMPX #IMM,dest */
835 dc = decode_dest23 (ddd, dd, 4);
837 imm = sign_ext (IMM(1), 8);
840 /** 0000 0001 1000 ddd w dd00 1110 DADC.size #IMM,dest */
844 /** 0000 0001 1sss ddd w dd ss 1000 DADC.size src,dest */
848 /** 0000 0001 1000 ddd w dd01 1110 DADD.size #IMM,dest */
852 /** 0000 0001 1sss ddd w dd ss 0000 DADD.size src,dest */
856 /** 1011 ddd w dd00 1110 DEC.size dest */
859 dc = decode_dest23 (ddd, dd, w+1);
862 tprintf ("%x -- = %x\n", a, v);
866 /** 1011 0000 010w 0011 DIV.size #IMM */
869 div_op (-1, 0, 0, 0, w+1);
871 /** 1000 sss w ss01 1110 DIV.size src */
874 div_op (sss, ss, 0, 0, w+1);
876 /** 0000 0001 1010 sss1 ss01 1111 DIV.L src */
880 div_op (sss, ss, 0, 0, 4);
882 /** 1011 0000 000w 0011 DIVU.size #IMM */
885 div_op (-1, 0, 1, 0, w+1);
887 /** 1000 sss w ss00 1110 DIVU.size src */
890 div_op (sss, ss, 1, 0, w+1);
892 /** 0000 0001 1010 sss1 ss00 1111 DIVU.L src */
896 div_op (sss, ss, 1, 0, 4);
898 /** 1011 0010 010w 0011 DIVX.size #IMM */
901 div_op (-1, 0, 0, 1, w+1);
903 /** 1001 sss w ss01 1110 DIVX.size src */
906 div_op (sss, ss, 0, 1, w+1);
908 /** 0000 0001 1010 sss1 ss10 1111 DIVX.L src */
912 div_op (sss, ss, 0, 1, 4);
914 /** 0000 0001 1001 ddd w dd00 1110 DSBB.size #IMM,dest */
918 /** 0000 0001 1sss ddd w dd ss 1010 DSBB.size src,dest */
922 /** 0000 0001 1001 ddd w dd01 1110 DSUB.size #IMM,dest */
926 /** 0000 0001 1sss ddd w dd ss 0010 DSUB.size src,dest */
930 /** 1110 1100 ENTER #IMM */
933 put_reg (sp, get_reg (sp) - 4);
934 mem_put_si (get_reg (sp), get_reg (fb));
935 put_reg (fb, get_reg (sp));
936 put_reg (sp, get_reg (sp) - imm);
938 /** 1111 1100 EXITD */
940 put_reg (sp, get_reg (fb));
941 put_reg (fb, mem_get_si (get_reg (sp)));
942 put_reg (sp, get_reg (sp) + 4);
943 put_reg (pc, mem_get_si (get_reg (sp)));
944 put_reg (sp, get_reg (sp) + 4);
946 /** 1100 ddd w dd01 1110 EXTS.size dest */
949 dc = decode_dest23 (ddd, dd, w+1);
950 v = sign_ext (get_src (dc), (w+1)*8);
955 /** 0000 0001 1sss ddd0 dd ss 0111 EXTS.B src,dest */
958 sc = decode_src23 (sss, ss, 1);
959 dc = decode_dest23 (ddd, dd, 2);
960 v = sign_ext (get_src (sc), 8);
964 /** 0000 0001 1sss ddd0 dd ss 1011 EXTZ src,dest */
967 sc = decode_src23 (sss, ss, 1);
968 dc = decode_dest23 (ddd, dd, 2);
973 /** 1101 0011 1110 1dst FCLR dest */
975 set_flags (1 << dst, 0);
977 /** 1001 1111 FREIT */
981 /** 1101 0001 1110 1dst FSET dest */
983 set_flags (1 << dst, 1 << dst);
985 /** 1010 ddd w dd00 1110 INC.size dest */
988 dc = decode_dest23 (ddd, dd, w+1);
991 tprintf ("%x ++ = %x\n", a, v);
995 /** 1000 sss0 ss0w 0011 INDEXB.size src */
997 /** 1010 sss0 ss0w 0011 INDEXBD.size src */
999 /** 1100 sss0 ss0w 0011 INDEXBS.size src */
1001 /** 1001 sss0 ss1w 0011 INDEXL.size src */
1003 /** 1011 sss0 ss1w 0011 INDEXLD.size src */
1005 /** 1001 sss0 ss0w 0011 INDEXLS.size src */
1007 /** 1000 sss0 ss1w 0011 INDEXW.size src */
1009 /** 1010 sss0 ss1w 0011 INDEXWD.size src */
1011 /** 1100 sss0 ss1w 0011 INDEXWS.size src */
1014 /** 1011 1110 vector00 INT #IMM */
1017 trigger_based_interrupt (vector);
1019 /** 1011 1111 INTO */
1023 trigger_fixed_interrupt (0xffffe0);
1025 /** 1ccc 101c Jcnd label */
1028 v = sign_ext (IMM(1), 8);
1029 if (condition_true (ccc*2+c))
1030 put_reg (pc, m32c_opcode_pc + 1 + v);
1032 /** 01dd 101d JMP.S label */
1035 put_reg (pc, m32c_opcode_pc + (dd*2+d) + 2);
1037 /** 1011 1011 JMP.B label */
1040 imm = sign_ext (IMM(1), 8);
1044 printf("[jmp-to-self detected as exit]\n");
1045 return M32C_MAKE_HIT_BREAK ();
1047 put_reg (pc, m32c_opcode_pc + 1 + imm);
1049 /** 1100 1110 JMP.W label */
1052 imm = sign_ext (IMM(2), 16);
1053 put_reg (pc, m32c_opcode_pc + 1 + imm);
1055 /** 1100 1100 JMP.A label */
1061 /** 1100 sss1 ss00 1111 JMPI.W src */
1064 sc = decode_src23 (sss, ss, 2);
1066 a = sign_ext (a, 16);
1067 put_reg (pc, m32c_opcode_pc + a);
1069 /** 1000 sss0 ss00 0001 JMPI.A src */
1072 sc = decode_src23 (sss, ss, 3);
1076 /** 1101 1100 JMPS #IMM8 */
1080 a = 0xff0000 + mem_get_hi (0xfffe00 - imm * 2);
1083 /** 1100 1111 JSR.W label */
1086 imm = sign_ext (IMM(2), 16);
1087 put_reg (sp, get_reg (sp) - 4);
1088 mem_put_si (get_reg (sp), get_reg (pc));
1089 put_reg (pc, m32c_opcode_pc + imm + 1);
1091 /** 1100 1101 JSR.A label */
1095 put_reg (sp, get_reg (sp) - 4);
1096 mem_put_si (get_reg (sp), get_reg (pc));
1099 /** 1100 sss1 ss01 1111 JSRI.W src */
1102 sc = decode_src23 (sss, ss, 2);
1104 a = sign_ext (a, 16);
1105 put_reg (sp, get_reg (sp) - 4);
1106 mem_put_si (get_reg (sp), get_reg (pc));
1107 put_reg (pc, m32c_opcode_pc + a);
1109 /** 1001 sss0 ss00 0001 JSRI.A src */
1112 sc = decode_src23 (sss, ss, 3);
1114 put_reg (sp, get_reg (sp) - 4);
1115 mem_put_si (get_reg (sp), get_reg (pc));
1118 /** 1101 1101 JSRS #IMM8 */
1122 a = 0xff0000 + mem_get_hi (0xfffe00 - imm * 2);
1123 put_reg (sp, get_reg (sp) - 4);
1124 mem_put_si (get_reg (sp), get_reg (pc));
1127 /** 1101 0101 1010 1dst LDC #IMM16,dest */
1130 dc = decode_cr_b (dst, CR_B_DCT0);
1133 /** 1101 0101 0010 1dst LDC #IMM24,dest */
1136 dc = decode_cr_b (dst, CR_B_INTB);
1139 /** 1101 0101 0110 1dst LDC #IMM24,dest */
1142 dc = decode_cr_b (dst, CR_B_DMA0);
1145 /** 0000 0001 1101 sss1 ss00 1dst LDC src,dest */
1148 sc = decode_src23 (sss, ss, 2);
1149 dc = decode_cr_b (dst, CR_B_DCT0);
1153 /** 1101 sss1 ss00 0dst LDC src,dest */
1156 sc = decode_src23 (sss, ss, 3);
1157 dc = decode_cr_b (dst, CR_B_INTB);
1161 /** 0000 0001 1101 sss1 ss00 0dst LDC src,dest */
1164 sc = decode_src23 (sss, ss, 3);
1165 dc = decode_cr_b (dst, CR_B_DMA0);
1169 /** 1011 0110 1100 0011 LDCTX */
1173 /** 1101 0101 1110 1imm LDIPL #IMM */
1175 set_flags (0x7000, imm*0x1000);
1177 /** 0000 0001 1000 ddd w dd11 1111 MAX.size #IMM,dest */
1181 dc = decode_dest23 (ddd, dd, w);
1182 imm = sign_ext (IMM(w), w*8);
1183 a = sign_ext (get_src (dc), w*8);
1184 tprintf ("max %d %d\n", imm, a);
1188 /** 0000 0001 1sss ddd w dd ss 1101 MAX.size src,dest */
1192 sc = decode_src23 (sss, ss, w);
1193 dc = decode_dest23 (ddd, dd, w);
1194 b = sign_ext (get_src (sc), w*8);
1195 a = sign_ext (get_src (dc), w*8);
1196 tprintf ("max %d %d\n", b, a);
1200 /** 0000 0001 1000 ddd w dd10 1111 MIN.size #IMM,dest */
1204 dc = decode_dest23 (ddd, dd, w);
1205 imm = sign_ext (IMM(w), w*8);
1206 a = sign_ext (get_src (dc), w*8);
1207 tprintf ("min %d %d\n", imm, a);
1211 /** 0000 0001 1sss ddd w dd ss 1100 MIN.size src,dest */
1215 sc = decode_src23 (sss, ss, w);
1216 dc = decode_dest23 (ddd, dd, w);
1217 b = sign_ext (get_src (sc), w*8);
1218 a = sign_ext (get_src (dc), w*8);
1219 tprintf ("min %d %d\n", b, a);
1223 /** 1001 ddd w dd10 1111 MOV.size:G #IMM,dest */
1225 dc = decode_dest23 (ddd, dd, w+1);
1228 tprintf("%x = %x\n", v, v);
1232 /** 1011 ddd0 dd11 0001 MOV.L:G #IMM,dest */
1234 dc = decode_dest23 (ddd, dd, 4);
1237 tprintf("%x = %x\n", v, v);
1241 /** 1111 ddd w dd10 immm MOV.size:Q #IMM4,dest */
1243 dc = decode_dest23 (ddd, dd, w+1);
1244 imm = sign_ext (immm, 4);
1246 tprintf("%x = %d\n", v, v);
1250 /** 00dd 010w MOV.size:S #IMM,dest */
1253 dc = decode_dest2 (dd, w+1);
1258 /** 10w1 110d MOV.size:S #IMM,a0/a1 */
1260 imm = IMM(w ? 3 : 2);
1261 put_reg (d ? a1 : a0, imm);
1262 set_sz (imm & addr_mask, w+1);
1264 /** 00dd 001w MOV.size:Z #0,dest */
1267 dc = decode_dest2 (dd, w+1);
1271 /** 1sss ddd w dd ss 1011 MOV.size:G src,dest */
1274 sc = decode_src23 (sss, ss, w+1);
1275 dc = decode_dest23 (ddd, dd, w+1);
1280 /** 1sss ddd1 dd ss 0011 MOV.L:G src,dest */
1283 sc = decode_src23 (sss, ss, 4);
1284 dc = decode_dest23 (ddd, dd, 4);
1289 /** VARY SS 01 10 11 */
1290 /** 00SS 100w MOV.size:S src,R0L/R0 */
1293 sc = decode_dest2 (SS, w+1);
1295 put_reg (w ? r0 : r0l, v);
1298 /** 01ss 111w MOV.size:S src,R1L/R1 */
1301 sc = decode_dest2 (ss, w+1);
1303 put_reg (w ? r1 : r1l, v);
1306 /** VARY DD 01 10 11 */
1307 /** 00DD 000w MOV.size:S R0L/R0,dest */
1310 dc = decode_dest2 (DD, w+1);
1311 v = get_reg (w ? r0 : r0l);
1315 /** 01ss 100d MOV.L:S src,A0/A1 */
1318 sc = decode_dest2 (ss, 4);
1320 put_reg (d ? a1 : a0, v);
1323 /** 1011 ddd w dd00 1111 MOV.size:G dsp:8[SP], dest */
1327 dc = decode_dest23 (ddd, dd, w+1);
1328 a = get_reg (sp) + sign_ext (imm, 8);
1337 /** 1010 sss w ss00 1111 MOV.size:G src,dsp:8[SP] */
1340 sc = decode_dest23 (sss, ss, w+1);
1342 a = get_reg (sp) + sign_ext (imm, 8);
1351 /** 1101 sss1 ss01 1dst MOVA src,dest */
1353 static reg_id map[8] = { r2r0, r3r1, a0, a1 };
1355 sc = decode_src23 (sss, ss, 1);
1356 if (!sc.mem || !map[dst])
1358 put_reg (map[dst], sc.u.addr);
1360 /** 0000 0001 1011 ddd0 dd hl 1110 MOVdir R0L,dest */
1363 dc = decode_dest23 (ddd, dd, 1);
1368 case 0: a = (a & 0xf0) | (b & 0x0f); break;
1369 case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break;
1370 case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break;
1371 case 3: a = (a & 0x0f) | (b & 0xf0); break;
1375 /** 0000 0001 1010 sss0 ss hl 1110 MOVdir src,R0L */
1378 sc = decode_dest23 (sss, ss, 1);
1383 case 0: a = (a & 0xf0) | (b & 0x0f); break;
1384 case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break;
1385 case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break;
1386 case 3: a = (a & 0x0f) | (b & 0xf0); break;
1390 /** 1011 ddd0 dd01 0001 MOVX #IMM,dest */
1393 dc = decode_dest23 (ddd, dd, 4);
1394 imm = sign_ext (IMM(1), 8);
1398 /** 1000 ddd w dd01 1111 MUL.size #IMM,dest */
1402 dc = decode_dest23 (ddd, dd, w);
1403 v = sign_ext (get_src (dc), w*8);
1404 imm = sign_ext (IMM(w), w*8);
1405 tprintf("%d * %d = %d\n", v, imm, v*imm);
1410 /** 1sss ddd w dd ss 1100 MUL.size src,dest */
1414 sc = decode_src23 (sss, ss, w);
1415 dc = decode_dest23 (ddd, dd, w);
1416 a = sign_ext (get_src (sc), w*8);
1417 b = sign_ext (get_src (dc), w*8);
1418 tprintf("%d * %d = %d\n", a, b, a*b);
1423 /** 0000 0001 1000 sss1 ss01 1111 MUL.L src,R2R0 */
1427 sc = decode_src23 (sss, ss, 4);
1428 a = sign_ext (get_src (sc), 32);
1429 b = sign_ext (get_reg (r2r0), 32);
1430 ll = (long long)a * (long long)b;
1431 tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll);
1432 if (ll < b2minsigned[4] || ll > b2maxsigned[4])
1433 set_flags (FLAGBIT_O, FLAGBIT_O);
1435 set_flags (FLAGBIT_O, 0);
1436 put_reg (r2r0, (int)ll);
1438 /** 1100 sss1 ss11 1110 MULEX src */
1441 sc = decode_dest23 (sss, ss, 2);
1442 a = sign_ext (get_src (sc), 16);
1443 b = sign_ext (get_reg (r2r0), 32);
1444 ll = (long long)a * (long long)b;
1445 tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll);
1446 put_reg (r2r0, (int)ll);
1447 put_reg (r1, (int)(ll >> 32));
1449 /** 1000 ddd w dd00 1111 MULU.size #IMM,dest */
1453 dc = decode_dest23 (ddd, dd, w);
1456 tprintf("%d * %d = %d\n", v, imm, v*imm);
1461 /** 1sss ddd w dd ss 0100 MULU.size src,dest */
1465 sc = decode_src23 (sss, ss, w);
1466 dc = decode_dest23 (ddd, dd, w);
1469 tprintf("%d * %d = %d\n", a, b, a*b);
1474 /** 0000 0001 1000 sss1 ss00 1111 MULU.L src,R2R0 */
1478 sc = decode_src23 (sss, ss, 4);
1481 ll = (long long)a * (long long)b;
1482 tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll);
1483 if (ll < b2minsigned[4] || ll > b2maxsigned[4])
1484 set_flags (FLAGBIT_O, FLAGBIT_O);
1486 set_flags (FLAGBIT_O, 0);
1487 put_reg (r2r0, (int)ll);
1489 /** 1010 ddd w dd10 1111 NEG.size dest */
1492 dc = decode_dest23 (ddd, dd, w+1);
1493 a = sign_ext (get_src (dc), (w+1)*8);
1495 tprintf("%d * -1 = %d\n", a, v);
1496 set_oszc(v, w+1, v==0);
1499 /** 1101 1110 NOP */
1503 /** 1010 ddd w dd01 1110 NOT.size dest */
1506 dc = decode_dest23 (ddd, dd, w+1);
1509 tprintf("~ %x = %x\n", a, v);
1513 /** 1000 ddd w dd10 1111 OR.size:G #IMM,dest */
1516 dc = decode_dest23(ddd, dd, w+1);
1518 LOGIC_OP (dc, imm, |);
1520 /** 01dd 010w OR.size:S #IMM,dest */
1523 dc = decode_dest2(dd, w+1);
1525 LOGIC_OP (dc, imm, |);
1527 /** 1sss ddd w dd ss 0101 OR.size:G src,dest */
1530 sc = decode_src23(sss, ss, w+1);
1531 dc = decode_dest23(ddd, dd, w+1);
1533 LOGIC_OP (dc, b, |);
1535 /** 1011 ddd w dd10 1111 POP.size dest */
1538 dc = decode_dest23 (ddd, dd, w+1);
1540 a = mem_get_hi (get_reg (sp));
1542 a = mem_get_qi (get_reg (sp));
1543 put_reg (sp, get_reg (sp) + 2);
1544 tprintf("pop%s: %x\n", w ? "hi" : "qi", a);
1547 /** 1101 0011 1010 1dst POPC dest */
1550 dc = decode_cr_b (dst, CR_B_DCT0);
1551 a = mem_get_hi (get_reg (sp));
1552 put_reg (sp, get_reg (sp) + 2);
1553 tprintf("pophi: %x\n", a);
1556 /** 1101 0011 0010 1dst POPC dest */
1559 dc = decode_cr_b (dst, CR_B_INTB);
1560 a = mem_get_si (get_reg (sp));
1561 put_reg (sp, get_reg (sp) + 4);
1562 tprintf("popsi: %x\n", a);
1565 /** 1000 1110 POPM dest */
1567 static int map[] = { r0, r1, r2, r3, a0, a1, sb, fb };
1570 tprintf("popm: %x\n", imm);
1574 v = mem_get_hi (get_reg (sp));
1575 put_reg (map[a], v);
1576 put_reg (sp, get_reg (sp) + 2);
1581 v = mem_get_si (get_reg (sp));
1582 put_reg (map[a], v);
1583 put_reg (sp, get_reg (sp) + 4);
1586 /** 1010 111w PUSH.size #IMM */
1590 tprintf("push%s: %x\n", w ? "hi" : "qi", imm);
1591 int a = get_reg (sp) - 2;
1593 mem_put_hi (a, imm);
1595 mem_put_qi (a, imm);
1598 /** 1100 sss w ss00 1110 PUSH.size src */
1601 sc = decode_dest23 (sss, ss, w+1);
1603 put_reg (sp, get_reg (sp) - 2);
1605 mem_put_hi (get_reg (sp), a);
1607 mem_put_qi (get_reg (sp), a);
1608 tprintf("push%s: %x\n", w ? "hi" : "qi", a);
1610 /** 1011 0110 0101 0011 PUSH.L #IMM32 */
1613 put_reg (sp, get_reg (sp) - 4);
1614 mem_put_si (get_reg (sp), imm);
1616 /** 1010 sss0 ss00 0001 PUSH.L src */
1619 sc = decode_dest23 (sss, ss, 4);
1621 put_reg (sp, get_reg (sp) - 4);
1622 mem_put_si (get_reg (sp), a);
1624 /** 1011 0sa0 ss00 0001 PUSHA src */
1627 sc = decode_dest23 (sa, ss, 1);
1628 put_reg (sp, get_reg (sp) - 4);
1629 mem_put_hi (get_reg (sp), sc.u.addr);
1630 tprintf("pushsi: %x\n", sc.u.addr);
1632 /** 1101 0001 1010 1src PUSHC src */
1635 sc = decode_cr_b (src, CR_B_DCT0);
1637 put_reg (sp, get_reg (sp) - 2);
1638 mem_put_hi (get_reg (sp), a);
1639 tprintf("pushhi: %x\n", a);
1641 /** 1101 0001 0010 1src PUSHC src */
1644 sc = decode_cr_b (src, CR_B_INTB);
1646 put_reg (sp, get_reg (sp) - 4);
1647 mem_put_si (get_reg (sp), a);
1648 tprintf("pushsi: %x\n", a);
1650 /** 1000 1111 PUSHM src */
1652 static int map[] = { fb, sb, a1, a0, r3, r2, r1, r0 };
1654 tprintf("pushm: %x\n", imm);
1658 put_reg (sp, get_reg (sp) - 4);
1659 v = get_reg (map[a]);
1660 mem_put_si (get_reg (sp), v);
1665 put_reg (sp, get_reg (sp) - 2);
1666 v = get_reg (map[a]);
1667 mem_put_hi (get_reg (sp), v);
1670 /** 1001 1110 REIT */
1673 put_reg (pc, mem_get_si (a));
1675 put_reg (flags, mem_get_hi (a));
1679 /** 1011 1000 010w 0011 RMPA.size */
1681 int count = get_reg (r3);
1682 int list1 = get_reg (a0);
1683 int list2 = get_reg (a1);
1684 long long sum = get_reg_ll (r3r1r2r0) & 0xffffff;
1690 a = sign_ext (mem_get_hi (list1), 16);
1691 b = sign_ext (mem_get_hi (list2), 16);
1695 a = sign_ext (mem_get_qi (list1), 8);
1696 b = sign_ext (mem_get_qi (list2), 8);
1698 tprintf("%lld + %d * %d = ", sum, a, b);
1700 tprintf("%lld\n", sum);
1705 put_reg (r3, count);
1706 put_reg (a0, list1);
1707 put_reg (a1, list2);
1708 put_reg (r2r0, (int)(sum & 0xffffffffU));
1709 put_reg (r1, (int)(sum >> 32));
1711 /** 1011 ddd w dd10 1110 ROLC.size dest */
1714 dc = decode_dest23 (ddd, dd, w+1);
1717 /** 1010 ddd w dd10 1110 RORC.size dest */
1720 dc = decode_dest23 (ddd, dd, w+1);
1723 /** 1110 ddd w dd10 immm ROT.size #IMM, dest */
1726 dc = decode_dest23 (ddd, dd, w+1);
1727 rot_op (dc, IMM4(), -1);
1729 /** 1010 ddd w dd11 1111 ROT.size R1H,dest */
1732 dc = decode_dest23 (ddd, dd, w+1);
1733 a = sign_ext (get_reg (r1h), 8);
1736 /** 1101 1111 RTS */
1738 put_reg (pc, mem_get_si (get_reg (sp)));
1739 put_reg (sp, get_reg (sp) + 4);
1741 /** 0000 0001 1001 ddd w dd10 1110 SBB.size #IMM, dest */
1744 dc = decode_dest23 (ddd, dd, w+1);
1746 MATH_OP (dc, imm, !carry, -);
1748 /** 0000 0001 1sss ddd w dd ss 0110 SBB.size src,dest */
1751 sc = decode_src23 (sss, ss, w+1);
1752 dc = decode_dest23 (ddd, dd, w+1);
1753 MATH_OP (dc, get_src (sc), !carry, -);
1755 /** 1101 ddd1 dd11 cond SCcond dest */
1758 dc = decode_dest23 (ddd, dd, 2);
1759 if (condition_true (cond))
1764 /** 1011 1000 110w 0011 SCMPU.size */
1771 t0 = mem_get_qi (ta0);
1772 t2 = mem_get_qi (ta1);
1775 t1 = mem_get_qi (ta0 + 1);
1776 t3 = mem_get_qi (ta1 + 1);
1779 if (dif == 0 && t0 != 0 && w)
1781 set_oszc (dif, 1, dif > 0);
1786 if (t0 == 0 || t0 != t2)
1788 if (w && (t1 == 0 || t1 != t3))
1792 /** 1111 ddd w dd00 immm SHA.size #IMM,dest */
1795 dc = decode_dest23 (ddd, dd, w+1);
1796 shift_op (dc, 1, IMM4(), 1);
1798 /** 1010 ddd0 dd10 0001 SHA.L #IMM,dest */
1801 dc = decode_dest23 (ddd, dd, 4);
1802 imm = sign_ext (IMM(1), 8);
1803 shift_op (dc, 1, imm, 1);
1805 /** 1011 ddd w dd11 1110 SHA.size R1H,dest */
1808 dc = decode_dest23 (ddd, dd, w+1);
1809 a = sign_ext (get_reg (r1h), 8);
1810 shift_op (dc, 1, a, 1);
1812 /** 1100 ddd0 dd01 0001 SHA.L R1H,dest */
1815 dc = decode_dest23 (ddd, dd, 4);
1816 a = sign_ext (get_reg (r1h), 8);
1817 shift_op (dc, 1, a, 1);
1819 /** 1100 ddd0 dd10 0001 SHANC.L #IMM,dest */
1823 dc = decode_dest23 (ddd, dd, 4);
1824 imm = sign_ext (IMM(1), 8);
1825 shift_op (dc, 1, imm, 0);
1827 /** 1110 ddd w dd00 immm SHL.size #IMM, dest */
1830 dc = decode_dest23 (ddd, dd, w+1);
1831 shift_op (dc, 0, IMM4(), 1);
1833 /** 1001 ddd0 dd10 0001 SHL.L #IMM, dest */
1836 dc = decode_dest23 (ddd, dd, 4);
1837 imm = sign_ext (IMM(1), 8);
1838 shift_op (dc, 0, imm, 1);
1840 /** 1010 ddd w dd11 1110 SHL.size R1H,dest */
1843 dc = decode_dest23 (ddd, dd, w+1);
1844 a = sign_ext (get_reg (r1h), 8);
1845 shift_op (dc, 0, a, 1);
1847 /** 1100 ddd0 dd00 0001 SHL.L R1H,dest */
1850 dc = decode_dest23 (ddd, dd, 4);
1851 a = sign_ext (get_reg (r1h), 8);
1852 shift_op (dc, 0, a, 1);
1854 /** 1000 ddd0 dd10 0001 SHLNC.L #IMM,dest */
1858 dc = decode_dest23 (ddd, dd, 4);
1859 imm = sign_ext (IMM(1), 8);
1860 shift_op (dc, 0, imm, 0);
1862 /** 1011 0010 100w 0011 SIN.size */
1870 mem_put_hi(a, mem_get_hi (v));
1872 mem_put_qi(a, mem_get_qi (v));
1880 /** 1011 0110 100w 0011 SMOVB.size */
1888 mem_put_hi(a, mem_get_hi (v));
1890 mem_put_qi(a, mem_get_qi (v));
1899 /** 1011 0000 100w 0011 SMOVF.size */
1907 mem_put_hi(a, mem_get_hi (v));
1909 mem_put_qi(a, mem_get_qi (v));
1918 /** 1011 1000 100w 0011 SMOVU.size */
1925 mem_put_hi(a, (t0 = mem_get_hi (v)));
1927 mem_put_qi(a, (t0 = mem_get_qi (v)));
1931 || (w && ((t0 & 0xff) == 0 || (t0 & 0xff00) == 0)))
1937 /** 1011 0100 100w 0011 SOUT.size */
1945 mem_put_hi(a, mem_get_hi (v));
1947 mem_put_qi(a, mem_get_qi (v));
1955 /** 1011 1000 000w 0011 SSTR.size */
1959 v = get_reg (w ? r0 : r0l);
1972 /** 0000 0001 1101 ddd1 dd01 0src STC src,dest */
1975 dc = decode_dest23 (ddd, dd, 4);
1976 sc = decode_cr_b (src, CR_B_DMA0);
1980 /** 0000 0001 1101 ddd1 dd01 1src STC src,dest */
1983 dc = decode_dest23 (ddd, dd, 2);
1984 sc = decode_cr_b (src, CR_B_DCT0);
1988 /** 1101 ddd1 dd01 0src STC src,dest */
1991 dc = decode_dest23 (ddd, dd, 4);
1992 sc = decode_cr_b (src, CR_B_INTB);
1996 /** 1011 0110 1101 0011 STCX abs16,abs24 */
2000 /** 1001 ddd w dd01 1111 STNZ.size #IMM,dest */
2003 dc = decode_dest23 (ddd, dd, w+1);
2008 /** 1001 ddd w dd00 1111 STZ.size #IMM,dest */
2011 dc = decode_dest23 (ddd, dd, w+1);
2016 /** 1001 ddd w dd11 1111 STZX.size #IMM1,#IMM2,dest */
2019 dc = decode_dest23 (ddd, dd, w+1);
2027 /** 1000 ddd w dd11 1110 SUB.size:G #IMM,dest */
2030 dc = decode_dest23(ddd, dd, w+1);
2032 MATH_OP (dc, imm, 0, -);
2034 /** 1001 ddd0 dd11 0001 SUB.L:G #IMM,dest */
2037 dc = decode_dest23(ddd, dd, 4);
2039 MATH_OP (dc, imm, 0, -);
2041 /** 00dd 111w SUB.size:S #IMM,dest */
2044 dc = decode_dest2(dd, w+1);
2046 MATH_OP (dc, imm, 0, -);
2048 /** 1sss ddd w dd ss 1010 SUB.size:G src,dest */
2051 sc = decode_src23(sss, ss, w+1);
2052 dc = decode_dest23(ddd, dd, w+1);
2054 MATH_OP (dc, b, 0, -);
2056 /** 1sss ddd1 dd ss 0000 SUB.L:G src,dest */
2059 sc = decode_src23(sss, ss, 4);
2060 dc = decode_dest23(ddd, dd, 4);
2062 MATH_OP (dc, b, 0, -);
2064 /** 1001 ddd0 dd01 0001 SUBX #IMM,dest */
2067 dc = decode_dest23(ddd, dd, 4);
2068 imm = sign_ext (IMM(1), 8);
2069 MATH_OP (dc, imm, 0, -);
2071 /** 1sss ddd0 dd ss 0000 SUBX src,dest */
2074 sc = decode_src23(sss, ss, 1);
2075 dc = decode_dest23(ddd, dd, 4);
2076 b = sign_ext (get_src (sc), 8);
2077 MATH_OP (dc, b, 0, -);
2079 /** 1001 ddd w dd11 1110 TST.size:G #IMM,dest */
2082 dc = decode_dest23 (ddd, dd, w+1);
2088 /** 00dd 110w TST.size:S #IMM,dest */
2091 dc = decode_dest2 (dd, w+1);
2097 /** 0000 0001 1sss ddd w dd ss 1001 TST.size:G src,dest */
2100 sc = decode_src23 (sss, ss, w+1);
2101 dc = decode_dest23 (ddd, dd, w+1);
2107 /** 1111 1111 UND */
2109 trigger_fixed_interrupt (0xffffdc);
2111 /** 1011 0010 0000 0011 WAIT */
2115 /** 1101 ddd w dd00 1src XCHG.size src,dest */
2117 dc = decode_dest23 (ddd, dd, w+1);
2118 sc = decode_src3 (src, w+1);
2124 /** 1001 ddd w dd00 1110 XOR.size #IMM,dest */
2127 dc = decode_dest23(ddd, dd, w+1);
2129 LOGIC_OP (dc, imm, ^);
2131 /** 1sss ddd w dd ss 1001 XOR.size src,dest */
2134 sc = decode_src23(sss, ss, w+1);
2135 dc = decode_dest23(ddd, dd, w+1);
2137 LOGIC_OP (dc, b, ^);