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