]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - sim/m32c/m32c.opc
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
sim: m32c: switch from custom fgets to getline
[thirdparty/binutils-gdb.git] / sim / m32c / m32c.opc
CommitLineData
d45a4bef
JB		 1/* m32c.opc --- semantics for m32c opcodes. -*- mode: c -*-
2
3666a048 3Copyright (C) 2005-2021 Free Software Foundation, Inc.
d45a4bef
JB		 4Contributed by Red Hat, Inc.
5
6This file is part of the GNU simulators.
7
4744ac1b
JB		 8This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 3 of the License, or
11(at your option) any later version.
d45a4bef 12
4744ac1b
JB		 13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
d45a4bef
JB		 17
18You should have received a copy of the GNU General Public License
4744ac1b 19along with this program. If not, see <http://www.gnu.org/licenses/>. */
d45a4bef
JB		 20
21
22#include <stdio.h>
23#include <stdlib.h>
24
f0c4dc40 25#include "ansidecl.h"
d45a4bef
JB		 26#include "cpu.h"
27#include "mem.h"
28#include "misc.h"
29#include "int.h"
30
d45a4bef
JB		 31#define tprintf if (trace) printf
32
33static unsigned char
269e9c18 34getbyte (void)
d45a4bef
JB		 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 M32C_ONLY() /* FIXME: add something here */
48
49#define GETBYTE() (op[opi++] = getbyte())
50
3877a145
DD		 51#define UNSUPPORTED() unsupported("unsupported", m32c_opcode_pc)
52#define NOTYET() unsupported("unimplemented", m32c_opcode_pc)
d45a4bef
JB		 53
54static void
55unsupported (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
78static int
79IMM(int bytes)
80{
81 int rv = 0;
82 switch (bytes)
83 {
84 case 1:
85 rv = mem_get_qi (get_reg(pc));
86 break;
87 case 2:
88 rv = mem_get_hi (get_reg(pc));
89 break;
90 case 3:
91 rv = mem_get_psi (get_reg(pc));
92 break;
93 case 4:
94 rv = mem_get_si (get_reg(pc));
95 break;
96 }
97 regs.r_pc += bytes;
98 return rv;
99}
100
101#define IMM4() (immm >= 8 ? 7 - immm : immm + 1)
102
103#define NO_PREFIX() PREFIX(0,0,0)
104
105/* Indicate which sorts of prefixes are allowed for the current
106 opcode. */
269e9c18
MF		 107static void
108prefix (int src_allowed, int dest_allowed, int index_bytewidth)
d45a4bef
JB		 109{
110 /* At the moment, we don't do anything with this information. We
111 just wanted to get the information entered in some
112 machine-readable form while we were going through all the
113 opcodes. */
114}
115
116#define MATH_OP(dc,s,c,op) \
117{ \
118 int ma, mb; \
119 ma = get_src(dc); \
120 mb = s & b2mask[dc.bytes]; \
121 ll = (long long)ma op (long long)mb op c; \
122 tprintf("0x%x " #op " 0x%x " #op " 0x%x = 0x%llx\n", ma, mb, c, ll); \
123 ma = sign_ext (ma, dc.bytes * 8); \
124 mb = sign_ext (s, dc.bytes * 8); \
125 v = ma op mb op c; \
126 tprintf("%d " #op " %d " #op " %d = %d\n", ma, mb, c, v); \
2b1a61a6 127 set_oszc (v, dc.bytes, (1 op 1) ? (ll > b2mask[dc.bytes]) : (ll >= 0)); \
d45a4bef
JB		 128 put_dest (dc, v); \
129}
130
131#define LOGIC_OP(dc,s,op) \
132{ \
133 int ma, mb; \
134 ma = get_src(dc); \
135 mb = s & b2mask[dc.bytes]; \
136 v = ma op mb; \
137 tprintf("0x%x " #op " 0x%x = 0x%x\n", ma, mb, v); \
138 set_sz (v, dc.bytes); \
139 put_dest (dc, v); \
140}
141
142#define BIT_OP(dc,bit,expr) \
143 b = get_bit2 (dc, bitindex == -1 ? bit : bitindex); \
144 v = expr; \
145 tprintf ("b=%d, bit=%d, carry=%d, %s = %d\n", \
146 b, bitindex == -1 ? bit : bitindex, carry, #expr, v); \
147 put_bit2 (dc, bitindex == -1 ? bit : bitindex, v);
148
149#define BIT_OPC(dc,bit,expr) \
150 b = get_bit2 (dc, bitindex == -1 ? bit : bitindex); \
151 v = expr; \
152 tprintf ("b=%d, bit=%d, carry=%d, %s = %d\n", \
153 b, bitindex == -1 ? bit : bitindex, carry, #expr, v); \
154 set_c (v);
155
156#define carry (FLAG_C ? 1 : 0)
157
158static void
159cmp (int d, int s, int bytes)
160{
161 int a, b, f=0;
162 a = d - s;
163 b = sign_ext (d, bytes*8) - sign_ext (s, bytes*8);
164 tprintf ("cmp: %x - %x = %08x, %x - %x = %d\n",
165 d, s, a,
166 sign_ext(d,bytes*8), sign_ext(s,bytes*8), b);
167
168 if (b == 0)
169 f |= FLAGBIT_Z;
170 if (b & b2signbit[bytes])
171 f |= FLAGBIT_S;
172 if ((d & b2mask[bytes]) >= (s & b2mask[bytes]))
173 f |= FLAGBIT_C;
174 if (b < b2minsigned[bytes] || b > b2maxsigned[bytes])
175 f |= FLAGBIT_O;
176
177 set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_O | FLAGBIT_C, f);
178}
179
180static void
181dadd_op (int ddd, int dd, int sss, int ss, int imm, int add, int cy, int w)
182{
183 srcdest sc, dc;
184 int a, b=0, res;
185
186 prefix (0, 0, 0);
187
188 if (!imm)
189 {
190 sc = decode_src23 (sss, ss, w+1);
191 b = get_src (sc);
192 }
193 dc = decode_dest23 (ddd, dd, w+1);
194 a = get_src (dc);
195 if (imm)
196 b = IMM(w+1);
197
198 a = bcd2int(a, w);
199 b = bcd2int(b, w);
200
201 tprintf("decimal: %d %s %d", a, add?"+":"-", b);
202 if (cy)
203 tprintf(" c=%d", carry);
204
205 if (add)
206 {
207 res = a + b;
208 if (cy)
209 res += carry;
210 cy = res > (w ? 9999 : 99);
211 }
212 else
213 {
214 res = a - b;
215 if (cy)
216 res -= (1-carry);
217 cy = res >= 0;
218 if (res < 0)
219 res += w ? 10000 : 100;
220 }
221
222 res = int2bcd (res, w);
223 tprintf(" = %x\n", res);
224
225 set_szc (res, w+1, cy);
226
227 put_dest (dc, res);
228}
229#define DADDV(A,C) dadd_op(ddd, dd, sss, ss, 0, A, C, w)
230#define DADDI(A,C) dadd_op(ddd, dd, 0, 0, 1, A, C, w)
231
232static void
233div_op (int sss, int ss, int u, int x, int bytes)
234{
235 srcdest sc;
236 int s, v, a, b;
237
238 if (sss == -1)
239 s = IMM(bytes);
240 else
241 {
242 sc = decode_dest23 (sss, ss, bytes);
243 s = get_src (sc);
244 }
245
246 v = get_reg (bytes > 1 ? r2r0 : r0);
247
248 if (!u)
249 {
250 /* FIXME? do we sign extend a0/a1 to .L? Docs say zero extend. */
251 s = sign_ext (s, bytes*8);
252 v = sign_ext (v, bytes*8);
253 }
254
255 if (s == 0)
256 {
257 set_flags (FLAGBIT_O, FLAGBIT_O);
258 return;
259 }
260
261 if (u)
262 {
263 a = (unsigned int)v / (unsigned int)s;
264 b = (unsigned int)v % (unsigned int)s;
265 }
266 else
267 {
268 a = v / s;
269 b = v % s;
270 }
271 if (x)
272 {
273 if ((s > 0 && b < 0)
274 || (s < 0 && b > 0))
275 {
276 a --;
277 b += s;
278 }
279 }
280 tprintf ("%d / %d = %d rem %d\n", v, s, a, b);
281 if ((!u && (a > b2maxsigned[bytes]
282 || a < b2minsigned[bytes]))
283 || (u && (a > b2mask[bytes])))
284 set_flags (FLAGBIT_O, FLAGBIT_O);
285 else
286 set_flags (FLAGBIT_O, 0);
287
288 switch (bytes)
289 {
290 case 1:
291 put_reg (r0l, a);
292 put_reg (r0h, b);
293 break;
294 case 2:
295 put_reg (r0, a);
296 put_reg (r2, b);
297 break;
298 case 4:
299 put_reg (r2r0, a);
300 break;
301 }
302}
303
304static void
305index_op (int sss, int ss, int do_s, int do_d, int scale, int w)
306{
307 srcdest sc = decode_src23 (sss, ss, w+1);
308 int v = get_src (sc) * scale;
309 tprintf("%d = %d * %d, %d %d\n", v, get_src(sc), scale, do_s, do_d);
310 decode_index (do_s * v, do_d * v);
311}
312#define INDEXOP(scale,do_s,do_d) \
313 index_op (sss, ss, do_s, do_d, scale, w); goto next_opcode
314
315static void
316rot_op (srcdest sd, int rotc, int count)
317{
318 int mask = (sd.bytes == 2) ? 0xffff : 0xff;
319 int msb = (sd.bytes == 2) ? 0x8000 : 0x80;
320 int v = get_src (sd);
321 int c = carry, ct;
322
323 tprintf("%s %x by %d\n", rotc ? "rotc" : "rot", v, count);
324 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
325 while (count > 0)
326 {
327 ct = (v & msb) ? 1 : 0;
328 v <<= 1;
329 v |= rotc ? c : ct;
330 v &= mask;
331 c = ct;
332 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
333 count --;
334 }
335 while (count < 0)
336 {
337 ct = v & 1;
338 v >>= 1;
339 v |= (rotc ? c : ct) * msb;
340 c = ct;
341 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);
342 count ++;
343 }
344 put_dest (sd, v);
345 set_szc (v, sd.bytes, c);
346}
347
348static void
349shift_op (srcdest sd, int arith, int count, int setc)
350{
351 int mask = (sd.bytes == 2) ? 0xffff : 0xff;
352 int msb = (sd.bytes == 2) ? 0x8000 : 0x80;
353 int v = get_src (sd);
354 int c = 0;
355 int o = 0;
356
357 if (sd.bytes == 4)
358 {
359 mask = 0xffffffffU;
360 msb = 0x80000000U;
361 }
362
363 tprintf("%s %x by %d\n", arith ? "sha" : "shl", v, count);
364 tprintf (": %s %d %d\n", bits(v, 8*sd.bytes), c, o);
365 while (count > 0)
366 {
367 c = (v & msb) ? 1 : 0;
368 v <<= 1;
369 v &= mask;
370 if (c != ((v & msb) ? 1 : 0))
371 o = 1;
372 tprintf (": %s %d %d\n", bits(v, 8*sd.bytes), c, o);
373 count --;
374 }
375 while (count < 0)
376 {
377 c = v & 1;
378 if (arith)
379 v = (v & msb) | (v >> 1);
380 else
381 v = (v >> 1) & (msb - 1);
382 tprintf (": %s %d %d\n", bits(v, 8*sd.bytes), c, o);
383 count ++;
384 }
385 put_dest (sd, v);
386 set_sz (v, sd.bytes);
387 if (setc)
388 set_c (c);
389 set_flags (FLAGBIT_O, o ? FLAGBIT_O : 0);
390}
391
3877a145
DD		 392static int pcs[16];
393static int ipcs = 0;
394
d45a4bef 395int
269e9c18 396decode_m32c (void)
d45a4bef
JB		 397{
398 unsigned char op[40];
399 int opi;
d45a4bef
JB		 400 int v, a, b;
401 long long ll;
402 srcdest sc, dc;
403 int imm;
404 int bitindex = -1;
405 int t0, t1=0, t2, t3=0;
406 int ta0, ta1, dif;
407
408 step_result = M32C_MAKE_STEPPED ();
409
410 decode_indirect (0, 0);
411 decode_index (0, 0);
412
413next_opcode:
414 opi = 0;
3877a145
DD		 415 m32c_opcode_pc = get_reg (pc);
416
417 tprintf("trace: decode pc = %06x\n", m32c_opcode_pc);
d45a4bef 418
3877a145
DD		 419 if (m32c_opcode_pc == 0)
420 {
421 int i;
422 printf("Abort: PC is zero, here from:\n");
423 for (i=0; i<4; i++)
424 printf(" 0x%06x\n", pcs[(ipcs+15-i)%16]);
425 return M32C_MAKE_HIT_BREAK ();
426 }
427 pcs[ipcs++] = m32c_opcode_pc;
428 ipcs %= 16;
d45a4bef
JB		 429
430 /** VARY sss 000 001 010 011 100 */
431 /** VARY ddd 000 001 010 011 100 */
432
433 /** 0000 1001 indirect dest */
434
435 decode_indirect (0, 1);
436 goto next_opcode;
437
438 /** 0100 0001 indirect src */
439
440 decode_indirect (1, 0);
441 goto next_opcode;
442
443 /** 0100 1001 indirect src and dest */
444
445 decode_indirect (1, 1);
446 goto next_opcode;
447
448 /** 1010 ddd w dd01 1111 ABS.size dest */
449
450 prefix (0, 1, 0);
451 dc = decode_dest23 (ddd, dd, w+1);
452 v = sign_ext (get_src (dc), w?16:8);
453 a = v<0 ? -v : v;
454 tprintf("abs(%d) = %d\n", v, a);
455 set_osz(a, w+1);
456 put_dest (dc, a);
457
458 /** 0000 0001 1000 ddd w dd10 1110 ADC.size #IMM,dest */
459
460 prefix (0, 0, 0);
461 dc = decode_dest23 (ddd, dd, w+1);
462 imm = IMM (w+1);
463 MATH_OP (dc, imm, carry, +);
464
465 /** 0000 0001 1sss ddd w dd ss 0100 ADC.size src,dest */
466
467 prefix (0, 0, 0);
468 sc = decode_src23 (sss, ss, w+1);
469 dc = decode_dest23 (ddd, dd, w+1);
470 b = get_src (sc);
471 MATH_OP (dc, b, carry, +);
472
473 /** 1011 ddd w dd01 1110 ADCF.size dest */
474
475 prefix (0, 1, 0);
476 dc = decode_dest23 (ddd, dd, w+1);
477 MATH_OP (dc, 0, carry, +);
478
479 /** 1000 ddd w dd10 1110 ADD.size:G #IMM,dest */
480
481 prefix (0, 1, 0);
482 dc = decode_dest23(ddd, dd, w+1);
483 imm = IMM(w+1);
484 MATH_OP (dc, imm, 0, +);
485
486 /** 1000 ddd0 dd11 0001 ADD.L:G #IMM,dest */
487
488 prefix (0, 1, 0);
489 dc = decode_dest23(ddd, dd, 4);
490 imm = IMM(4);
491 MATH_OP (dc, imm, 0, +);
492
493 /** 111L ddd w dd11 immm ADD.size:Q #IMM,dest */
494
495 prefix (0, 1, 0);
496 dc = decode_dest23(ddd, dd, L ? 4 : (w+1));
497 imm = sign_ext (immm, 4);
498 MATH_OP (dc, imm, 0, +);
499
500 /** 00dd 011w ADD.size:S #IMM,dest */
501
502 prefix (0, 1, 0);
503 dc = decode_dest2(dd, w+1);
504 imm = IMM (w+1);
505 MATH_OP (dc, imm, 0, +);
506
507 /** 10i0 110d ADD.L:S #IMM,A0/A1 */
508
509 prefix (0, 0, 0);
510 dc = reg_sd (d ? a1 : a0);
511 imm = i ? 2 : 1;
512 MATH_OP (dc, imm, 0, +);
513
514 /** 1sss ddd w dd ss 1000 ADD.size:G src,dest */
515
516 prefix (1, 1, 0);
517 sc = decode_src23(sss, ss, w+1);
518 dc = decode_dest23(ddd, dd, w+1);
519 b = get_src (sc);
520 MATH_OP (dc, b, 0, +);
521
522 /** 1sss ddd1 dd ss 0010 ADD.L:G src,dest */
523
524 prefix (1, 1, 0);
525 sc = decode_src23(sss, ss, 4);
526 dc = decode_dest23(ddd, dd, 4);
527 b = get_src (sc);
528 MATH_OP (dc, b, 0, +);
529
530 /** 1011 0110 0001 0011 ADD.L:G #IMM16,SP */
531
532 prefix (0, 0, 0);
533 dc = reg_sd (sp);
534 b = sign_ext (IMM(2), 16);
535 MATH_OP (dc, b, 0, +);
536
537 /** 01ii 001i ADD.L:Q #IMM3,SP */
538
539 prefix (0, 0, 0);
540 dc = reg_sd (sp);
541 b = ii * 2 + i + 1;
542 MATH_OP (dc, b, 0, +);
543
544 /** 1011 0110 0000 0011 ADD.L:S #IMM8,SP */
545
546 prefix (0, 0, 0);
547 dc = reg_sd (sp);
548 b = sign_ext (IMM(1), 8);
549 MATH_OP (dc, b, 0, +);
550
551 /** 1000 ddd0 dd01 0001 ADDX #IMM,dest */
552
553 prefix (0, 1, 0);
554 dc = decode_dest23(ddd, dd, 4);
555 imm = sign_ext (IMM(1), 8);
556 MATH_OP (dc, imm, 0, +);
557
558 /** 1sss ddd0 dd ss 0010 ADDX src,dest */
559
560 prefix (1, 1, 0);
561 sc = decode_src23(sss, ss, 1);
562 dc = decode_dest23(ddd, dd, 4);
563 b = sign_ext (get_src (sc), 8);
564 MATH_OP (dc, b, 0, +);
565
566 /** 1111 ddd w dd01 immm ADJNZ.size #IMM,dest,label */
567
568 prefix (0, 0, 0);
569 dc = decode_dest23 (ddd, dd, w+1);
570 v = get_src (dc);
571 imm = sign_ext(immm, 4);
572 tprintf("%d + %d = %d\n", v, imm, v+imm);
573 v += imm;
574 put_dest (dc, v);
575 a = sign_ext (IMM(1), 8);
576 if ((v & (w ? 0xffff : 0xff)) != 0)
577 {
578 tprintf("jmp: %x + 2 + %d = ", get_reg (pc), a);
3877a145 579 put_reg (pc, m32c_opcode_pc + 2 + a);
d45a4bef
JB		 580 tprintf("%x\n", get_reg (pc));
581 }
582
583 /** 1000 ddd w dd11 1111 AND.size:G #IMM,dest */
584
585 prefix (0, 1, 0);
586 dc = decode_dest23(ddd, dd, w+1);
587 imm = IMM(w+1);
588 LOGIC_OP (dc, imm, &);
589
590 /** 01dd 110w AND.size:S #IMM,dest */
591
592 prefix (0, 1, 0);
593 dc = decode_dest2(dd, w+1);
594 imm = IMM (w+1);
595 LOGIC_OP (dc, imm, &);
596
597 /** 1sss ddd w dd ss 1101 AND.size:G src,dest */
598
599 prefix (1, 1, 0);
600 sc = decode_src23(sss, ss, w+1);
601 dc = decode_dest23(ddd, dd, w+1);
602 b = get_src (sc);
603 LOGIC_OP (dc, b, &);
604
605 /** 0000 0001 1101 sss0 ss00 1bit BAND src */
606
607 sc = decode_src23 (sss, ss, 1);
608 BIT_OPC (sc, bit, b & carry);
609
610 /** 1101 ddd0 dd11 0bit BCLR dest */
611
612 dc = decode_dest23 (ddd, dd, 1);
613 BIT_OP (dc, bit, 0);
614
615 /** 1100 ddd w dd10 1110 BITINDEX.size src */
616
617 prefix (0, 0, 0);
618 dc = decode_dest23 (ddd, dd, w+1);
619 bitindex = get_src (dc);
620 tprintf ("bitindex set to %d\n", bitindex);
621 goto next_opcode;
622
623 /** 1101 ddd0 dd01 0bit BMcnd dest */
624
625 prefix (0, 0, 0);
626 dc = decode_dest23 (ddd, dd, 1);
627 if (condition_true (IMM (1)))
628 put_bit2 (dc, bit, 1);
629 else
630 put_bit2 (dc, bit, 0);
631
632 /** 1101 1001 0c10 1cnd BMcnd C */
633
634 prefix (0, 0, 0);
635 if (condition_true (c * 8 + cnd))
636 set_c (1);
637 else
638 set_c (0);
639
640 /** 0000 0001 1101 sss0 ss01 1bit BNAND src */
641
642 prefix (0, 0, 0);
643 sc = decode_src23 (sss, ss, 1);
ed25d732 644 BIT_OPC (sc, bit, (!b) & carry);
d45a4bef
JB		 645
646 /** 0000 0001 1101 sss0 ss11 0bit BNOR src */
647
648 prefix (0, 0, 0);
649 sc = decode_src23 (sss, ss, 1);
ed25d732 650 BIT_OPC (sc, bit, (!b) | carry);
d45a4bef
JB		 651
652 /** 1101 ddd0 dd01 1bit BNOT dest */
653
654 prefix (0, 0, 0);
655 dc = decode_dest23 (ddd, dd, 1);
656 BIT_OP (dc, bit, !b);
657
658 /** 0000 0001 1101 sss0 ss00 0bit BNTST src */
659
660 prefix (0, 0, 0);
661 sc = decode_dest23 (sss, ss, 1);
662 b = get_bit2 (sc, bit);
663 set_zc (!b, !b);
664
665 /** 0000 0001 1101 sss0 ss11 1bit BNXOR src */
666
667 prefix (0, 0, 0);
668 sc = decode_src23 (sss, ss, 1);
669 BIT_OPC (sc, bit, !b ^ carry);
670
671 /** 0000 0001 1101 sss0 ss10 0bit BOR src */
672
673 prefix (0, 0, 0);
674 sc = decode_src23 (sss, ss, 1);
675 BIT_OPC (sc, bit, b | carry);
676
677 /** 0000 0000 BRK */
678
679 /* We report the break to our caller with the PC still pointing at the
680 breakpoint instruction. */
3877a145 681 put_reg (pc, m32c_opcode_pc);
e7ddc197 682 if (verbose)
d45a4bef 683 printf("[break]\n");
3877a145
DD		 684 if (in_gdb || (regs.r_intbl == 0 && regs.r_intbh == 0))
685 return M32C_MAKE_HIT_BREAK ();
686 if (mem_get_qi (0xFFFFE7) == 0xff)
687 trigger_based_interrupt (0);
688 else
689 trigger_fixed_interrupt (0xFFFFE4);
690
691 /** 1111 1110 GBRK */
692
693 /* This alternate break, which is not part of the chip's opcode set,
694 is here in case you need to debug a program that itself uses the
695 chip's BRK opcode. You'll need to modify your copy of GDB to use
696 this opcode instead of the real BRK. */
697
698 /* GDB Break. */
699 /* We report the break to our caller with the PC still pointing at the
700 breakpoint instruction. */
701 put_reg (pc, m32c_opcode_pc);
e7ddc197 702 if (verbose)
3877a145 703 printf("[gdb break]\n");
d45a4bef
JB		 704 return M32C_MAKE_HIT_BREAK ();
705
3877a145 706 /** 0000 1000 BRK2 */
d45a4bef
JB		 707
708 if (verbose)
709 printf("[break2]\n");
3877a145
DD		 710 if (in_gdb)
711 return M32C_MAKE_HIT_BREAK ();
712 if (mem_get_qi (0xFFFFE7) == 0xff)
713 trigger_based_interrupt (0);
714 else
715 trigger_fixed_interrupt (0xFFFFE4);
d45a4bef
JB		 716
717 /** 1101 ddd0 dd11 1bit BSET dest */
718
719 dc = decode_dest23 (ddd, dd, 1);
720 BIT_OP (dc, bit, 1);
721
722 /** 1101 sss0 ss00 0bit BTST:G src */
723
724 prefix (0, 0, 0);
725 sc = decode_src23 (sss, ss, 1);
726 b = get_bit2 (sc, bit);
727 set_zc (!b, b);
728
729 /** 00bb 101b BTST:S src */
730
731 sc = decode_src23 (3, 3, 1); /* bit,base:19 */
732 b = get_bit2 (sc, bb*2 + b);
733 set_zc (!b, b);
734
735 /** 1101 ddd0 dd10 0bit BTSTC dest */
736
737 prefix (0, 0, 0);
738 sc = decode_dest23 (ddd, dd, 1);
739 b = get_bit2 (sc, bit);
740 set_zc (!b, b);
741 put_bit2 (sc, bit, 0);
742
743 /** 1101 ddd0 dd10 1bit BTSTS dest */
744
745 prefix (0, 0, 0);
746 sc = decode_dest23 (ddd, dd, 1);
747 b = get_bit2 (sc, bit);
748 set_zc (!b, b);
749 put_bit2 (sc, bit, 1);
750
751 /** 0000 0001 1101 sss0 ss10 1bit BXOR src */
752
753 prefix (0, 0, 0);
754 sc = decode_src23 (sss, ss, 1);
755 BIT_OPC (sc, bit, b ^ carry);
756
757 /** 0000 0001 1000 ddd w dd11 1110 CLIP.size #IMM1,#IMM2,dest */
758
759 prefix (0, 0, 0);
760 dc = decode_dest23 (ddd, dd, w+1);
761 a = sign_ext (IMM(w+1), w*8+8);
762 b = sign_ext (IMM(w+1), w*8+8);
763 v = sign_ext (get_src (dc), w*8+8);
764 tprintf("clip %d <= %d <= %d : ", a, v, b);
765 if (a > v)
766 v = a;
767 if (v > b)
768 v = b;
769 tprintf("%d\n", v);
770 put_dest (dc, v);
771
772 /** 1001 ddd w dd10 1110 CMP.size:G #IMM,dest */
773
774 prefix (0, 1, 0);
775 dc = decode_dest23 (ddd, dd, w+1);
776 v = get_src (dc);
777 imm = IMM(w+1);
778 cmp (v, imm, w+1);
779
780 /** 1010 ddd0 dd11 0001 CMP.L:G #IMM32,dest */
781
782 prefix (0, 1, 0);
783 dc = decode_dest23 (ddd, dd, 4);
784 v = get_src (dc);
785 imm = IMM(4);
786 cmp (v, imm, 4);
787
788 /** 1110 ddd w dd01 immm CMP.size:Q #IMM,dest */
789
790 prefix (0, 1, 0);
791 dc = decode_dest23 (ddd, dd, w+1);
792 v = get_src (dc);
793 immm = sign_ext (immm, 4);
794 cmp (v, immm, w+1);
795
796 /** 01dd 011w CMP.size:S #IMM,dest */
797
798 prefix (0, 1, 0);
799 dc = decode_dest2 (dd, w+1);
800 v = get_src (dc);
801 imm = sign_ext (IMM(w+1),w*8+8);
802 cmp (v, imm, w+1);
803
804 /** 1sss ddd w dd ss 0110 CMP.size:G src,dest */
805
806 prefix (1, 1, 0);
807 sc = decode_src23 (sss, ss, w+1);
808 dc = decode_dest23 (ddd, dd, w+1);
809 a = get_src (dc);
810 b = get_src (sc);
811 cmp (a, b, w+1);
812
813 /** 1sss ddd1 dd ss 0001 CMP.L:G src,dest */
814
815 prefix (1, 1, 0);
816 sc = decode_src23 (sss, ss, 4);
817 dc = decode_dest23 (ddd, dd, 4);
818 a = get_src (dc);
819 b = get_src (sc);
820 cmp (a, b, 4);
821
822 /** 01dd 000w CMP.size:S src,R0/R0L */
823
824 prefix (0, 1, 0);
825 dc = decode_dest2 (dd, w+1);
826 a = get_reg (w ? r0 : r0l);
827 b = get_src (dc);
828 cmp (a, b, w+1);
829
830 /** 1010 ddd0 dd01 0001 CMPX #IMM,dest */
831
832 prefix (0, 1, 0);
833 dc = decode_dest23 (ddd, dd, 4);
834 v = get_src (dc);
835 imm = sign_ext (IMM(1), 8);
836 cmp (v, imm, 4);
837
838 /** 0000 0001 1000 ddd w dd00 1110 DADC.size #IMM,dest */
839
840 DADDI(1,1);
841
842 /** 0000 0001 1sss ddd w dd ss 1000 DADC.size src,dest */
843
844 DADDV(1,1);
845
846 /** 0000 0001 1000 ddd w dd01 1110 DADD.size #IMM,dest */
847
848 DADDI(1,0);
849
850 /** 0000 0001 1sss ddd w dd ss 0000 DADD.size src,dest */
851
852 DADDV(1,0);
853
854 /** 1011 ddd w dd00 1110 DEC.size dest */
855
856 prefix (0, 1, 0);
857 dc = decode_dest23 (ddd, dd, w+1);
858 a = get_src (dc);
859 v = a-1;
860 tprintf ("%x -- = %x\n", a, v);
861 set_sz (v, w+1);
862 put_dest (dc, v);
863
864 /** 1011 0000 010w 0011 DIV.size #IMM */
865
866 prefix (0, 0, 0);
867 div_op (-1, 0, 0, 0, w+1);
868
869 /** 1000 sss w ss01 1110 DIV.size src */
870
871 prefix (0, 1, 0);
872 div_op (sss, ss, 0, 0, w+1);
873
874 /** 0000 0001 1010 sss1 ss01 1111 DIV.L src */
875
876 M32C_ONLY();
877 prefix (0, 0, 0);
878 div_op (sss, ss, 0, 0, 4);
879
880 /** 1011 0000 000w 0011 DIVU.size #IMM */
881
882 prefix (0, 0, 0);
883 div_op (-1, 0, 1, 0, w+1);
884
885 /** 1000 sss w ss00 1110 DIVU.size src */
886
887 prefix (0, 1, 0);
888 div_op (sss, ss, 1, 0, w+1);
889
890 /** 0000 0001 1010 sss1 ss00 1111 DIVU.L src */
891
892 M32C_ONLY();
893 prefix (0, 0, 0);
894 div_op (sss, ss, 1, 0, 4);
895
896 /** 1011 0010 010w 0011 DIVX.size #IMM */
897
898 prefix (0, 0, 0);
899 div_op (-1, 0, 0, 1, w+1);
900
901 /** 1001 sss w ss01 1110 DIVX.size src */
902
903 prefix (0, 1, 0);
904 div_op (sss, ss, 0, 1, w+1);
905
906 /** 0000 0001 1010 sss1 ss10 1111 DIVX.L src */
907
908 M32C_ONLY();
909 prefix (0, 0, 0);
910 div_op (sss, ss, 0, 1, 4);
911
912 /** 0000 0001 1001 ddd w dd00 1110 DSBB.size #IMM,dest */
913
914 DADDI(0,1);
915
916 /** 0000 0001 1sss ddd w dd ss 1010 DSBB.size src,dest */
917
918 DADDV(0,1);
919
920 /** 0000 0001 1001 ddd w dd01 1110 DSUB.size #IMM,dest */
921
922 DADDI(0,0);
923
924 /** 0000 0001 1sss ddd w dd ss 0010 DSUB.size src,dest */
925
926 DADDV(0,0);
927
928 /** 1110 1100 ENTER #IMM */
929
930 imm = IMM(1);
931 put_reg (sp, get_reg (sp) - 4);
932 mem_put_si (get_reg (sp), get_reg (fb));
933 put_reg (fb, get_reg (sp));
934 put_reg (sp, get_reg (sp) - imm);
935
936 /** 1111 1100 EXITD */
937
938 put_reg (sp, get_reg (fb));
939 put_reg (fb, mem_get_si (get_reg (sp)));
940 put_reg (sp, get_reg (sp) + 4);
941 put_reg (pc, mem_get_si (get_reg (sp)));
942 put_reg (sp, get_reg (sp) + 4);
943
944 /** 1100 ddd w dd01 1110 EXTS.size dest */
945
946 prefix (0, 0, 0);
947 dc = decode_dest23 (ddd, dd, w+1);
948 v = sign_ext (get_src (dc), (w+1)*8);
949 dc = widen_sd (dc);
950 put_dest (dc, v);
951 set_sz (v, (w+1)*2);
952
953 /** 0000 0001 1sss ddd0 dd ss 0111 EXTS.B src,dest */
954
955 prefix (0, 0, 0);
956 sc = decode_src23 (sss, ss, 1);
957 dc = decode_dest23 (ddd, dd, 2);
958 v = sign_ext (get_src (sc), 8);
959 put_dest (dc, v);
960 set_sz (v, 16);
961
962 /** 0000 0001 1sss ddd0 dd ss 1011 EXTZ src,dest */
963
964 prefix (0, 0, 0);
965 sc = decode_src23 (sss, ss, 1);
966 dc = decode_dest23 (ddd, dd, 2);
967 v = get_src (sc);
968 put_dest (dc, v);
969 set_sz (v, 16);
970
971 /** 1101 0011 1110 1dst FCLR dest */
972
973 set_flags (1 << dst, 0);
974
975 /** 1001 1111 FREIT */
976
977 NOTYET();
978
979 /** 1101 0001 1110 1dst FSET dest */
980
981 set_flags (1 << dst, 1 << dst);
982
983 /** 1010 ddd w dd00 1110 INC.size dest */
984
985 prefix (0, 1, 0);
986 dc = decode_dest23 (ddd, dd, w+1);
987 a = get_src (dc);
988 v = a+1;
989 tprintf ("%x ++ = %x\n", a, v);
990 set_sz (v, w+1);
991 put_dest (dc, v);
992
993 /** 1000 sss0 ss0w 0011 INDEXB.size src */
994 INDEXOP(1, 1, 1);
995 /** 1010 sss0 ss0w 0011 INDEXBD.size src */
996 INDEXOP(1, 0, 1);
997 /** 1100 sss0 ss0w 0011 INDEXBS.size src */
998 INDEXOP(1, 1, 0);
999 /** 1001 sss0 ss1w 0011 INDEXL.size src */
1000 INDEXOP(4, 1, 1);
1001 /** 1011 sss0 ss1w 0011 INDEXLD.size src */
1002 INDEXOP(4, 0, 1);
1003 /** 1001 sss0 ss0w 0011 INDEXLS.size src */
1004 INDEXOP(4, 1, 0);
1005 /** 1000 sss0 ss1w 0011 INDEXW.size src */
1006 INDEXOP(2, 1, 1);
1007 /** 1010 sss0 ss1w 0011 INDEXWD.size src */
1008 INDEXOP(2, 0, 1);
1009 /** 1100 sss0 ss1w 0011 INDEXWS.size src */
1010 INDEXOP(2, 1, 0);
1011
1012 /** 1011 1110 vector00 INT #IMM */
1013
1014 prefix (0, 0, 0);
1015 trigger_based_interrupt (vector);
1016
1017 /** 1011 1111 INTO */
1018
1019 prefix (0, 0, 0);
1020 if (FLAG_O)
1021 trigger_fixed_interrupt (0xffffe0);
1022
1023 /** 1ccc 101c Jcnd label */
1024
1025 prefix (0, 0, 0);
1026 v = sign_ext (IMM(1), 8);
1027 if (condition_true (ccc*2+c))
3877a145 1028 put_reg (pc, m32c_opcode_pc + 1 + v);
d45a4bef
JB		 1029
1030 /** 01dd 101d JMP.S label */
1031
1032 prefix (0, 0, 0);
3877a145 1033 put_reg (pc, m32c_opcode_pc + (dd*2+d) + 2);
d45a4bef
JB		 1034
1035 /** 1011 1011 JMP.B label */
1036
1037 prefix (0, 0, 0);
1038 imm = sign_ext (IMM(1), 8);
1039 if (imm == -1)
1040 {
1041 if (verbose)
1042 printf("[jmp-to-self detected as exit]\n");
1043 return M32C_MAKE_HIT_BREAK ();
1044 }
3877a145 1045 put_reg (pc, m32c_opcode_pc + 1 + imm);
d45a4bef
JB		 1046
1047 /** 1100 1110 JMP.W label */
1048
1049 prefix (0, 0, 0);
1050 imm = sign_ext (IMM(2), 16);
3877a145 1051 put_reg (pc, m32c_opcode_pc + 1 + imm);
d45a4bef
JB		 1052
1053 /** 1100 1100 JMP.A label */
1054
1055 prefix (0, 0, 0);
1056 imm = IMM(3);
1057 put_reg (pc, imm);
1058
1059 /** 1100 sss1 ss00 1111 JMPI.W src */
1060
1061 prefix (0, 0, 0);
1062 sc = decode_src23 (sss, ss, 2);
1063 a = get_src (sc);
1064 a = sign_ext (a, 16);
3877a145 1065 put_reg (pc, m32c_opcode_pc + a);
d45a4bef
JB		 1066
1067 /** 1000 sss0 ss00 0001 JMPI.A src */
1068
1069 prefix (0, 0, 0);
1070 sc = decode_src23 (sss, ss, 3);
1071 a = get_src (sc);
1072 put_reg (pc, a);
1073
1074 /** 1101 1100 JMPS #IMM8 */
1075
1076 prefix (0, 0, 0);
1077 imm = IMM(1);
1078 a = 0xff0000 + mem_get_hi (0xfffe00 - imm * 2);
1079 put_reg (pc, a);
1080
1081 /** 1100 1111 JSR.W label */
1082
1083 prefix (0, 0, 0);
1084 imm = sign_ext (IMM(2), 16);
1085 put_reg (sp, get_reg (sp) - 4);
1086 mem_put_si (get_reg (sp), get_reg (pc));
3877a145 1087 put_reg (pc, m32c_opcode_pc + imm + 1);
d45a4bef
JB		 1088
1089 /** 1100 1101 JSR.A label */
1090
1091 prefix (0, 0, 0);
1092 imm = IMM(3);
1093 put_reg (sp, get_reg (sp) - 4);
1094 mem_put_si (get_reg (sp), get_reg (pc));
1095 put_reg (pc, imm);
1096
1097 /** 1100 sss1 ss01 1111 JSRI.W src */
1098
1099 prefix (0, 0, 0);
1100 sc = decode_src23 (sss, ss, 2);
1101 a = get_src (sc);
1102 a = sign_ext (a, 16);
1103 put_reg (sp, get_reg (sp) - 4);
1104 mem_put_si (get_reg (sp), get_reg (pc));
3877a145 1105 put_reg (pc, m32c_opcode_pc + a);
d45a4bef
JB		 1106
1107 /** 1001 sss0 ss00 0001 JSRI.A src */
1108
1109 prefix (0, 0, 0);
1110 sc = decode_src23 (sss, ss, 3);
1111 a = get_src (sc);
1112 put_reg (sp, get_reg (sp) - 4);
1113 mem_put_si (get_reg (sp), get_reg (pc));
1114 put_reg (pc, a);
1115
1116 /** 1101 1101 JSRS #IMM8 */
1117
1118 prefix (0, 0, 0);
1119 imm = IMM(1);
1120 a = 0xff0000 + mem_get_hi (0xfffe00 - imm * 2);
1121 put_reg (sp, get_reg (sp) - 4);
1122 mem_put_si (get_reg (sp), get_reg (pc));
1123 put_reg (pc, a);
1124
1125 /** 1101 0101 1010 1dst LDC #IMM16,dest */
1126
1127 imm = IMM(2);
1128 dc = decode_cr_b (dst, CR_B_DCT0);
1129 put_dest (dc, imm);
1130
1131 /** 1101 0101 0010 1dst LDC #IMM24,dest */
1132
1133 imm = IMM(3);
1134 dc = decode_cr_b (dst, CR_B_INTB);
1135 put_dest (dc, imm);
1136
1137 /** 1101 0101 0110 1dst LDC #IMM24,dest */
1138
1139 imm = IMM(3);
1140 dc = decode_cr_b (dst, CR_B_DMA0);
1141 put_dest (dc, imm);
1142
1143 /** 0000 0001 1101 sss1 ss00 1dst LDC src,dest */
1144
1145 prefix (0, 0, 0);
1146 sc = decode_src23 (sss, ss, 2);
1147 dc = decode_cr_b (dst, CR_B_DCT0);
1148 a = get_src (sc);
1149 put_dest (dc, a);
1150
1151 /** 1101 sss1 ss00 0dst LDC src,dest */
1152
1153 prefix (0, 0, 0);
1154 sc = decode_src23 (sss, ss, 3);
1155 dc = decode_cr_b (dst, CR_B_INTB);
1156 a = get_src (sc);
1157 put_dest (dc, a);
1158
1159 /** 0000 0001 1101 sss1 ss00 0dst LDC src,dest */
1160
1161 prefix (0, 0, 0);
1162 sc = decode_src23 (sss, ss, 3);
1163 dc = decode_cr_b (dst, CR_B_DMA0);
1164 a = get_src (sc);
1165 put_dest (dc, a);
1166
1167 /** 1011 0110 1100 0011 LDCTX */
1168
1169 NOTYET();
1170
1171 /** 1101 0101 1110 1imm LDIPL #IMM */
1172
1173 set_flags (0x7000, imm*0x1000);
1174
1175 /** 0000 0001 1000 ddd w dd11 1111 MAX.size #IMM,dest */
1176
1177 prefix (0, 0, 0);
1178 w++;
1179 dc = decode_dest23 (ddd, dd, w);
1180 imm = sign_ext (IMM(w), w*8);
1181 a = sign_ext (get_src (dc), w*8);
1182 tprintf ("max %d %d\n", imm, a);
1183 if (imm > a)
1184 put_dest (dc, imm);
1185
1186 /** 0000 0001 1sss ddd w dd ss 1101 MAX.size src,dest */
1187
1188 prefix (0, 0, 0);
1189 w++;
1190 sc = decode_src23 (sss, ss, w);
1191 dc = decode_dest23 (ddd, dd, w);
1192 b = sign_ext (get_src (sc), w*8);
1193 a = sign_ext (get_src (dc), w*8);
1194 tprintf ("max %d %d\n", b, a);
1195 if (b > a)
1196 put_dest (dc, b);
1197
1198 /** 0000 0001 1000 ddd w dd10 1111 MIN.size #IMM,dest */
1199
1200 prefix (0, 0, 0);
1201 w++;
1202 dc = decode_dest23 (ddd, dd, w);
1203 imm = sign_ext (IMM(w), w*8);
1204 a = sign_ext (get_src (dc), w*8);
1205 tprintf ("min %d %d\n", imm, a);
1206 if (imm < a)
1207 put_dest (dc, imm);
1208
1209 /** 0000 0001 1sss ddd w dd ss 1100 MIN.size src,dest */
1210
1211 prefix (0, 0, 0);
1212 w++;
1213 sc = decode_src23 (sss, ss, w);
1214 dc = decode_dest23 (ddd, dd, w);
1215 b = sign_ext (get_src (sc), w*8);
1216 a = sign_ext (get_src (dc), w*8);
1217 tprintf ("min %d %d\n", b, a);
1218 if (b < a)
1219 put_dest (dc, b);
1220
1221 /** 1001 ddd w dd10 1111 MOV.size:G #IMM,dest */
1222
1223 dc = decode_dest23 (ddd, dd, w+1);
1224 imm = IMM(w+1);
1225 v = imm;
1226 tprintf("%x = %x\n", v, v);
1227 set_sz(v, w+1);
1228 put_dest (dc, v);
1229
1230 /** 1011 ddd0 dd11 0001 MOV.L:G #IMM,dest */
1231
1232 dc = decode_dest23 (ddd, dd, 4);
1233 imm = IMM(4);
1234 v = imm;
1235 tprintf("%x = %x\n", v, v);
1236 set_sz(v, 4);
1237 put_dest (dc, v);
1238
1239 /** 1111 ddd w dd10 immm MOV.size:Q #IMM4,dest */
1240
1241 dc = decode_dest23 (ddd, dd, w+1);
1242 imm = sign_ext (immm, 4);
1243 v = imm;
1244 tprintf("%x = %d\n", v, v);
1245 set_sz(v, w+1);
1246 put_dest (dc, v);
1247
1248 /** 00dd 010w MOV.size:S #IMM,dest */
1249
1250 prefix (0, 1, 0);
1251 dc = decode_dest2 (dd, w+1);
1252 imm = IMM(w+1);
1253 put_dest (dc, imm);
1254 set_sz (imm, w+1);
1255
1256 /** 10w1 110d MOV.size:S #IMM,a0/a1 */
1257
1258 imm = IMM(w ? 3 : 2);
1259 put_reg (d ? a1 : a0, imm);
1260 set_sz (imm & addr_mask, w+1);
1261
1262 /** 00dd 001w MOV.size:Z #0,dest */
1263
1264 prefix (0, 1, 0);
1265 dc = decode_dest2 (dd, w+1);
1266 put_dest (dc, 0);
1267 set_sz (0, w+1);
1268
1269 /** 1sss ddd w dd ss 1011 MOV.size:G src,dest */
1270
1271 prefix (1, 1, 0);
1272 sc = decode_src23 (sss, ss, w+1);
1273 dc = decode_dest23 (ddd, dd, w+1);
1274 v = get_src (sc);
1275 put_dest (dc, v);
1276 set_sz (v, w+1);
1277
1278 /** 1sss ddd1 dd ss 0011 MOV.L:G src,dest */
1279
1280 prefix (1, 1, 0);
1281 sc = decode_src23 (sss, ss, 4);
1282 dc = decode_dest23 (ddd, dd, 4);
1283 v = get_src (sc);
1284 put_dest (dc, v);
1285 set_sz (v, 4);
1286
1287 /** VARY SS 01 10 11 */
1288 /** 00SS 100w MOV.size:S src,R0L/R0 */
1289
1290 prefix (0, 1, 0);
1291 sc = decode_dest2 (SS, w+1);
1292 v = get_src (sc);
1293 put_reg (w ? r0 : r0l, v);
1294 set_sz (v, w+1);
1295
1296 /** 01ss 111w MOV.size:S src,R1L/R1 */
1297
1298 prefix (0, 1, 0);
1299 sc = decode_dest2 (ss, w+1);
1300 v = get_src (sc);
1301 put_reg (w ? r1 : r1l, v);
1302 set_sz (v, w+1);
1303
1304 /** VARY DD 01 10 11 */
1305 /** 00DD 000w MOV.size:S R0L/R0,dest */
1306
1307 prefix (0, 1, 0);
1308 dc = decode_dest2 (DD, w+1);
1309 v = get_reg (w ? r0 : r0l);
1310 put_dest (dc, v);
1311 set_sz (v, w+1);
1312
1313 /** 01ss 100d MOV.L:S src,A0/A1 */
1314
1315 prefix (0, 1, 0);
1316 sc = decode_dest2 (ss, 4);
1317 v = get_src (sc);
1318 put_reg (d ? a1 : a0, v);
1319 set_sz (v, 4);
1320
1321 /** 1011 ddd w dd00 1111 MOV.size:G dsp:8[SP], dest */
1322
1323 prefix (0, 0, 0);
1324 imm = IMM(1);
1325 dc = decode_dest23 (ddd, dd, w+1);
1326 a = get_reg (sp) + sign_ext (imm, 8);
1327 a &= addr_mask;
1328 if (w)
1329 v = mem_get_hi (a);
1330 else
1331 v = mem_get_qi (a);
1332 put_dest (dc, v);
1333 set_sz (v, w+1);
1334
1335 /** 1010 sss w ss00 1111 MOV.size:G src,dsp:8[SP] */
1336
1337 prefix (0, 0, 0);
1338 sc = decode_dest23 (sss, ss, w+1);
1339 imm = IMM(1);
1340 a = get_reg (sp) + sign_ext (imm, 8);
1341 a &= addr_mask;
1342 v = get_src (sc);
1343 if (w)
1344 mem_put_hi (a, v);
1345 else
1346 mem_put_qi (a, v);
1347 set_sz (v, w+1);
1348
1349 /** 1101 sss1 ss01 1dst MOVA src,dest */
1350
1351 static reg_id map[8] = { r2r0, r3r1, a0, a1 };
1352 prefix (0, 0, 0);
1353 sc = decode_src23 (sss, ss, 1);
1354 if (!sc.mem || !map[dst])
1355 UNSUPPORTED();
1356 put_reg (map[dst], sc.u.addr);
1357
1358 /** 0000 0001 1011 ddd0 dd hl 1110 MOVdir R0L,dest */
1359
1360 prefix (0, 0, 0);
1361 dc = decode_dest23 (ddd, dd, 1);
1362 a = get_src (dc);
1363 b = get_reg (r0l);
1364 switch (hl)
1365 {
1366 case 0: a = (a & 0xf0) | (b & 0x0f); break;
1367 case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break;
1368 case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break;
1369 case 3: a = (a & 0x0f) | (b & 0xf0); break;
1370 }
1371 put_dest (dc, a);
1372
1373 /** 0000 0001 1010 sss0 ss hl 1110 MOVdir src,R0L */
1374
1375 prefix (0, 0, 0);
1376 sc = decode_dest23 (sss, ss, 1);
1377 a = get_reg (r0l);
1378 b = get_src (dc);
1379 switch (hl)
1380 {
1381 case 0: a = (a & 0xf0) | (b & 0x0f); break;
1382 case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break;
1383 case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break;
1384 case 3: a = (a & 0x0f) | (b & 0xf0); break;
1385 }
1386 put_reg (r0l, a);
1387
1388 /** 1011 ddd0 dd01 0001 MOVX #IMM,dest */
1389
1390 prefix (0, 1, 0);
1391 dc = decode_dest23 (ddd, dd, 4);
1392 imm = sign_ext (IMM(1), 8);
1393 put_dest (dc, imm);
1394 set_sz (imm, 1);
1395
1396 /** 1000 ddd w dd01 1111 MUL.size #IMM,dest */
1397
1398 prefix (0, 1, 0);
1399 w ++;
1400 dc = decode_dest23 (ddd, dd, w);
1401 v = sign_ext (get_src (dc), w*8);
1402 imm = sign_ext (IMM(w), w*8);
1403 tprintf("%d * %d = %d\n", v, imm, v*imm);
1404 v *= imm;
1405 dc = widen_sd (dc);
1406 put_dest (dc, v);
1407
1408 /** 1sss ddd w dd ss 1100 MUL.size src,dest */
1409
1410 prefix (1, 1, 0);
1411 w ++;
1412 sc = decode_src23 (sss, ss, w);
1413 dc = decode_dest23 (ddd, dd, w);
1414 a = sign_ext (get_src (sc), w*8);
1415 b = sign_ext (get_src (dc), w*8);
1416 tprintf("%d * %d = %d\n", a, b, a*b);
1417 v = a * b;
1418 dc = widen_sd (dc);
1419 put_dest (dc, v);
1420
1421 /** 0000 0001 1000 sss1 ss01 1111 MUL.L src,R2R0 */
1422
1423 M32C_ONLY();
1424 prefix (0, 0, 0);
1425 sc = decode_src23 (sss, ss, 4);
1426 a = sign_ext (get_src (sc), 32);
1427 b = sign_ext (get_reg (r2r0), 32);
1428 ll = (long long)a * (long long)b;
1429 tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll);
1430 if (ll < b2minsigned[4] || ll > b2maxsigned[4])
1431 set_flags (FLAGBIT_O, FLAGBIT_O);
1432 else
1433 set_flags (FLAGBIT_O, 0);
1434 put_reg (r2r0, (int)ll);
1435
1436 /** 1100 sss1 ss11 1110 MULEX src */
1437
1438 prefix (0, 1, 0);
1439 sc = decode_dest23 (sss, ss, 2);
1440 a = sign_ext (get_src (sc), 16);
1441 b = sign_ext (get_reg (r2r0), 32);
1442 ll = (long long)a * (long long)b;
1443 tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll);
1444 put_reg (r2r0, (int)ll);
1445 put_reg (r1, (int)(ll >> 32));
1446
1447 /** 1000 ddd w dd00 1111 MULU.size #IMM,dest */
1448
1449 prefix (0, 1, 0);
1450 w ++;
1451 dc = decode_dest23 (ddd, dd, w);
1452 v = get_src (dc);
1453 imm = IMM(w);
1454 tprintf("%d * %d = %d\n", v, imm, v*imm);
1455 v *= imm;
1456 dc = widen_sd (dc);
1457 put_dest (dc, v);
1458
1459 /** 1sss ddd w dd ss 0100 MULU.size src,dest */
1460
1461 prefix (1, 1, 0);
1462 w ++;
1463 sc = decode_src23 (sss, ss, w);
1464 dc = decode_dest23 (ddd, dd, w);
1465 a = get_src (sc);
1466 b = get_src (dc);
1467 tprintf("%d * %d = %d\n", a, b, a*b);
1468 v = a * b;
1469 dc = widen_sd (dc);
1470 put_dest (dc, v);
1471
1472 /** 0000 0001 1000 sss1 ss00 1111 MULU.L src,R2R0 */
1473
1474 M32C_ONLY();
1475 prefix (0, 0, 0);
1476 sc = decode_src23 (sss, ss, 4);
1477 a = get_src (sc);
1478 b = get_reg (r2r0);
1479 ll = (long long)a * (long long)b;
1480 tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll);
1481 if (ll < b2minsigned[4] || ll > b2maxsigned[4])
1482 set_flags (FLAGBIT_O, FLAGBIT_O);
1483 else
1484 set_flags (FLAGBIT_O, 0);
1485 put_reg (r2r0, (int)ll);
1486
1487 /** 1010 ddd w dd10 1111 NEG.size dest */
1488
1489 prefix (0, 1, 0);
1490 dc = decode_dest23 (ddd, dd, w+1);
1491 a = sign_ext (get_src (dc), (w+1)*8);
1492 v = -a;
1493 tprintf("%d * -1 = %d\n", a, v);
1494 set_oszc(v, w+1, v==0);
1495 put_dest (dc, v);
1496
1497 /** 1101 1110 NOP */
1498
1499 tprintf("nop\n");
1500
1501 /** 1010 ddd w dd01 1110 NOT.size dest */
1502
1503 prefix (0, 1, 0);
1504 dc = decode_dest23 (ddd, dd, w+1);
1505 a = get_src (dc);
1506 v = ~a;
1507 tprintf("~ %x = %x\n", a, v);
1508 set_sz(v, w+1);
1509 put_dest (dc, v);
1510
1511 /** 1000 ddd w dd10 1111 OR.size:G #IMM,dest */
1512
1513 prefix (0, 1, 0);
1514 dc = decode_dest23(ddd, dd, w+1);
1515 imm = IMM(w+1);
1516 LOGIC_OP (dc, imm, |);
1517
1518 /** 01dd 010w OR.size:S #IMM,dest */
1519
1520 prefix (0, 1, 0);
1521 dc = decode_dest2(dd, w+1);
1522 imm = IMM (w+1);
1523 LOGIC_OP (dc, imm, |);
1524
1525 /** 1sss ddd w dd ss 0101 OR.size:G src,dest */
1526
1527 prefix (1, 1, 0);
1528 sc = decode_src23(sss, ss, w+1);
1529 dc = decode_dest23(ddd, dd, w+1);
1530 b = get_src (sc);
1531 LOGIC_OP (dc, b, |);
1532
1533 /** 1011 ddd w dd10 1111 POP.size dest */
1534
1535 prefix (0, 1, 0);
1536 dc = decode_dest23 (ddd, dd, w+1);
1537 if (w)
1538 a = mem_get_hi (get_reg (sp));
1539 else
1540 a = mem_get_qi (get_reg (sp));
1541 put_reg (sp, get_reg (sp) + 2);
1542 tprintf("pop%s: %x\n", w ? "hi" : "qi", a);
1543 put_dest (dc, a);
1544
1545 /** 1101 0011 1010 1dst POPC dest */
1546
1547 prefix (0, 0, 0);
1548 dc = decode_cr_b (dst, CR_B_DCT0);
1549 a = mem_get_hi (get_reg (sp));
1550 put_reg (sp, get_reg (sp) + 2);
1551 tprintf("pophi: %x\n", a);
1552 put_dest (dc, a);
1553
1554 /** 1101 0011 0010 1dst POPC dest */
1555
1556 prefix (0, 0, 0);
1557 dc = decode_cr_b (dst, CR_B_INTB);
1558 a = mem_get_si (get_reg (sp));
1559 put_reg (sp, get_reg (sp) + 4);
1560 tprintf("popsi: %x\n", a);
1561 put_dest (dc, a);
1562
1563 /** 1000 1110 POPM dest */
1564
1565 static int map[] = { r0, r1, r2, r3, a0, a1, sb, fb };
1566 prefix (0, 0, 0);
1567 imm = IMM(1);
1568 tprintf("popm: %x\n", imm);
1569 for (a=0; a<4; a++)
1570 if (imm & (1<<a))
1571 {
1572 v = mem_get_hi (get_reg (sp));
1573 put_reg (map[a], v);
1574 put_reg (sp, get_reg (sp) + 2);
1575 }
1576 for (; a<8; a++)
1577 if (imm & (1<<a))
1578 {
1579 v = mem_get_si (get_reg (sp));
1580 put_reg (map[a], v);
1581 put_reg (sp, get_reg (sp) + 4);
1582 }
1583
1584 /** 1010 111w PUSH.size #IMM */
1585
1586 prefix (0, 0, 0);
1587 imm = IMM(w+1);
1588 tprintf("push%s: %x\n", w ? "hi" : "qi", imm);
1589 int a = get_reg (sp) - 2;
1590 if (w)
1591 mem_put_hi (a, imm);
1592 else
1593 mem_put_qi (a, imm);
1594 put_reg (sp, a);
1595
1596 /** 1100 sss w ss00 1110 PUSH.size src */
1597
1598 prefix (0, 1, 0);
1599 sc = decode_dest23 (sss, ss, w+1);
1600 a = get_src (sc);
1601 put_reg (sp, get_reg (sp) - 2);
1602 if (w)
1603 mem_put_hi (get_reg (sp), a);
1604 else
1605 mem_put_qi (get_reg (sp), a);
1606 tprintf("push%s: %x\n", w ? "hi" : "qi", a);
1607
1608 /** 1011 0110 0101 0011 PUSH.L #IMM32 */
1609
1610 imm = IMM(4);
1611 put_reg (sp, get_reg (sp) - 4);
1612 mem_put_si (get_reg (sp), imm);
1613
1614 /** 1010 sss0 ss00 0001 PUSH.L src */
1615
1616 prefix (0, 1, 0);
1617 sc = decode_dest23 (sss, ss, 4);
1618 a = get_src (sc);
1619 put_reg (sp, get_reg (sp) - 4);
1620 mem_put_si (get_reg (sp), a);
1621
1622 /** 1011 0sa0 ss00 0001 PUSHA src */
1623
1624 prefix (0, 0, 0);
1625 sc = decode_dest23 (sa, ss, 1);
1626 put_reg (sp, get_reg (sp) - 4);
1627 mem_put_hi (get_reg (sp), sc.u.addr);
1628 tprintf("pushsi: %x\n", sc.u.addr);
1629
1630 /** 1101 0001 1010 1src PUSHC src */
1631
1632 prefix (0, 0, 0);
1633 sc = decode_cr_b (src, CR_B_DCT0);
1634 a = get_src (sc);
1635 put_reg (sp, get_reg (sp) - 2);
1636 mem_put_hi (get_reg (sp), a);
1637 tprintf("pushhi: %x\n", a);
1638
1639 /** 1101 0001 0010 1src PUSHC src */
1640
1641 prefix (0, 0, 0);
1642 sc = decode_cr_b (src, CR_B_INTB);
1643 a = get_src (sc);
1644 put_reg (sp, get_reg (sp) - 4);
1645 mem_put_si (get_reg (sp), a);
1646 tprintf("pushsi: %x\n", a);
1647
1648 /** 1000 1111 PUSHM src */
1649
1650 static int map[] = { fb, sb, a1, a0, r3, r2, r1, r0 };
1651 imm = IMM(1);
1652 tprintf("pushm: %x\n", imm);
1653 for (a=0; a<4; a++)
1654 if (imm & (1<<a))
1655 {
1656 put_reg (sp, get_reg (sp) - 4);
1657 v = get_reg (map[a]);
1658 mem_put_si (get_reg (sp), v);
1659 }
1660 for (; a<8; a++)
1661 if (imm & (1<<a))
1662 {
1663 put_reg (sp, get_reg (sp) - 2);
1664 v = get_reg (map[a]);
1665 mem_put_hi (get_reg (sp), v);
1666 }
1667
1668 /** 1001 1110 REIT */
1669
1670 a = get_reg (sp);
1671 put_reg (pc, mem_get_si (a));
1672 a += 4;
1673 put_reg (flags, mem_get_hi (a));
1674 a += 2;
1675 put_reg (sp, a);
1676
1677 /** 1011 1000 010w 0011 RMPA.size */
1678
1679 int count = get_reg (r3);
1680 int list1 = get_reg (a0);
1681 int list2 = get_reg (a1);
1682 long long sum = get_reg_ll (r3r1r2r0) & 0xffffff;
1683
1684 while (count)
1685 {
1686 if (w)
1687 {
1688 a = sign_ext (mem_get_hi (list1), 16);
1689 b = sign_ext (mem_get_hi (list2), 16);
1690 }
1691 else
1692 {
1693 a = sign_ext (mem_get_qi (list1), 8);
1694 b = sign_ext (mem_get_qi (list2), 8);
1695 }
1696 tprintf("%lld + %d * %d = ", sum, a, b);
1697 sum += a * b;
1698 tprintf("%lld\n", sum);
1699 list1 += w ? 2 : 1;
1700 list2 += w ? 2 : 1;
1701 count --;
1702 }
1703 put_reg (r3, count);
1704 put_reg (a0, list1);
1705 put_reg (a1, list2);
1706 put_reg (r2r0, (int)(sum & 0xffffffffU));
1707 put_reg (r1, (int)(sum >> 32));
1708
1709 /** 1011 ddd w dd10 1110 ROLC.size dest */
1710
1711 prefix (0, 1, 0);
1712 dc = decode_dest23 (ddd, dd, w+1);
1713 rot_op (dc, 1, 1);
1714
1715 /** 1010 ddd w dd10 1110 RORC.size dest */
1716
1717 prefix (0, 1, 0);
1718 dc = decode_dest23 (ddd, dd, w+1);
1719 rot_op (dc, 1, -1);
1720
1721 /** 1110 ddd w dd10 immm ROT.size #IMM, dest */
1722
1723 prefix (0, 1, 0);
1724 dc = decode_dest23 (ddd, dd, w+1);
1725 rot_op (dc, IMM4(), -1);
1726
1727 /** 1010 ddd w dd11 1111 ROT.size R1H,dest */
1728
1729 prefix (0, 1, 0);
1730 dc = decode_dest23 (ddd, dd, w+1);
1731 a = sign_ext (get_reg (r1h), 8);
1732 rot_op (dc, a, -1);
1733
1734 /** 1101 1111 RTS */
1735
1736 put_reg (pc, mem_get_si (get_reg (sp)));
1737 put_reg (sp, get_reg (sp) + 4);
1738
1739 /** 0000 0001 1001 ddd w dd10 1110 SBB.size #IMM, dest */
1740
1741 prefix (0, 0, 0);
1742 dc = decode_dest23 (ddd, dd, w+1);
1743 imm = IMM (w+1);
1744 MATH_OP (dc, imm, !carry, -);
1745
1746 /** 0000 0001 1sss ddd w dd ss 0110 SBB.size src,dest */
1747
1748 prefix (0, 0, 0);
1749 sc = decode_src23 (sss, ss, w+1);
1750 dc = decode_dest23 (ddd, dd, w+1);
1751 MATH_OP (dc, get_src (sc), !carry, -);
1752
1753 /** 1101 ddd1 dd11 cond SCcond dest */
1754
1755 prefix (0, 1, 0);
1756 dc = decode_dest23 (ddd, dd, 2);
1757 if (condition_true (cond))
1758 put_dest (dc, 1);
1759 else
1760 put_dest (dc, 0);
1761
1762 /** 1011 1000 110w 0011 SCMPU.size */
1763
1764 ta0 = get_reg (a0);
1765 ta1 = get_reg (a1);
1766
1767 for (;;)
1768 {
1769 t0 = mem_get_qi (ta0);
1770 t2 = mem_get_qi (ta1);
1771 if (w)
1772 {
1773 t1 = mem_get_qi (ta0 + 1);
1774 t3 = mem_get_qi (ta1 + 1);
1775 }
1776 dif = t0 - t2;
1777 if (dif == 0 && t0 != 0 && w)
1778 dif = t1 - t3;
1779 set_oszc (dif, 1, dif > 0);
1780
1781 ta0 += w ? 2 : 1;
1782 ta1 += w ? 2 : 1;
1783
1784 if (t0 == 0 || t0 != t2)
1785 break;
1786 if (w && (t1 == 0 || t1 != t3))
1787 break;
1788 }
1789
1790 /** 1111 ddd w dd00 immm SHA.size #IMM,dest */
1791
1792 prefix (0, 1, 0);
1793 dc = decode_dest23 (ddd, dd, w+1);
1794 shift_op (dc, 1, IMM4(), 1);
1795
1796 /** 1010 ddd0 dd10 0001 SHA.L #IMM,dest */
1797
1798 prefix (0, 1, 0);
1799 dc = decode_dest23 (ddd, dd, 4);
1800 imm = sign_ext (IMM(1), 8);
1801 shift_op (dc, 1, imm, 1);
1802
1803 /** 1011 ddd w dd11 1110 SHA.size R1H,dest */
1804
1805 prefix (0, 1, 0);
1806 dc = decode_dest23 (ddd, dd, w+1);
1807 a = sign_ext (get_reg (r1h), 8);
1808 shift_op (dc, 1, a, 1);
1809
1810 /** 1100 ddd0 dd01 0001 SHA.L R1H,dest */
1811
1812 prefix (0, 1, 0);
1813 dc = decode_dest23 (ddd, dd, 4);
1814 a = sign_ext (get_reg (r1h), 8);
1815 shift_op (dc, 1, a, 1);
1816
1817 /** 1100 ddd0 dd10 0001 SHANC.L #IMM,dest */
1818
1819 M32C_ONLY();
1820 prefix (0, 1, 0);
1821 dc = decode_dest23 (ddd, dd, 4);
1822 imm = sign_ext (IMM(1), 8);
1823 shift_op (dc, 1, imm, 0);
1824
1825 /** 1110 ddd w dd00 immm SHL.size #IMM, dest */
1826
1827 prefix (0, 1, 0);
1828 dc = decode_dest23 (ddd, dd, w+1);
1829 shift_op (dc, 0, IMM4(), 1);
1830
1831 /** 1001 ddd0 dd10 0001 SHL.L #IMM, dest */
1832
1833 prefix (0, 1, 0);
1834 dc = decode_dest23 (ddd, dd, 4);
1835 imm = sign_ext (IMM(1), 8);
1836 shift_op (dc, 0, imm, 1);
1837
1838 /** 1010 ddd w dd11 1110 SHL.size R1H,dest */
1839
1840 prefix (0, 1, 0);
1841 dc = decode_dest23 (ddd, dd, w+1);
1842 a = sign_ext (get_reg (r1h), 8);
1843 shift_op (dc, 0, a, 1);
1844
1845 /** 1100 ddd0 dd00 0001 SHL.L R1H,dest */
1846
1847 prefix (0, 1, 0);
1848 dc = decode_dest23 (ddd, dd, 4);
1849 a = sign_ext (get_reg (r1h), 8);
1850 shift_op (dc, 0, a, 1);
1851
1852 /** 1000 ddd0 dd10 0001 SHLNC.L #IMM,dest */
1853
1854 M32C_ONLY();
1855 prefix (0, 1, 0);
1856 dc = decode_dest23 (ddd, dd, 4);
1857 imm = sign_ext (IMM(1), 8);
1858 shift_op (dc, 0, imm, 0);
1859
1860 /** 1011 0010 100w 0011 SIN.size */
1861
1862 v = get_reg (a0);
1863 a = get_reg (a1);
1864 b = get_reg (r3);
1865 if (b) for (;b;)
1866 {
1867 if (w)
1868 mem_put_hi(a, mem_get_hi (v));
1869 else
1870 mem_put_qi(a, mem_get_qi (v));
1871 a += w ? 2 : 1;
1872 b --;
1873 }
1874 put_reg (a0, v);
1875 put_reg (a1, a);
1876 put_reg (r3, b);
1877
1878 /** 1011 0110 100w 0011 SMOVB.size */
1879
1880 v = get_reg (a0);
1881 a = get_reg (a1);
1882 b = get_reg (r3);
1883 if (b) for (;b;)
1884 {
1885 if (w)
1886 mem_put_hi(a, mem_get_hi (v));
1887 else
1888 mem_put_qi(a, mem_get_qi (v));
1889 v -= w ? 2 : 1;
1890 a -= w ? 2 : 1;
1891 b --;
1892 }
1893 put_reg (a0, v);
1894 put_reg (a1, a);
1895 put_reg (r3, b);
1896
1897 /** 1011 0000 100w 0011 SMOVF.size */
1898
1899 v = get_reg (a0);
1900 a = get_reg (a1);
1901 b = get_reg (r3);
1902 if (b) for (;b;)
1903 {
1904 if (w)
1905 mem_put_hi(a, mem_get_hi (v));
1906 else
1907 mem_put_qi(a, mem_get_qi (v));
1908 v += w ? 2 : 1;
1909 a += w ? 2 : 1;
1910 b --;
1911 }
1912 put_reg (a0, v);
1913 put_reg (a1, a);
1914 put_reg (r3, b);
1915
1916 /** 1011 1000 100w 0011 SMOVU.size */
1917
1918 v = get_reg (a0);
1919 a = get_reg (a1);
1920 do
1921 {
1922 if (w)
1923 mem_put_hi(a, (t0 = mem_get_hi (v)));
1924 else
1925 mem_put_qi(a, (t0 = mem_get_qi (v)));
1926 v += w ? 2 : 1;
1927 a += w ? 2 : 1;
1928 if (t0 == 0
1929 || (w && ((t0 & 0xff) == 0 || (t0 & 0xff00) == 0)))
1930 break;
1931 } while (1);
1932 put_reg (a0, v);
1933 put_reg (a1, a);
1934
1935 /** 1011 0100 100w 0011 SOUT.size */
1936
1937 v = get_reg (a0);
1938 a = get_reg (a1);
1939 b = get_reg (r3);
1940 for (;b;)
1941 {
1942 if (w)
1943 mem_put_hi(a, mem_get_hi (v));
1944 else
1945 mem_put_qi(a, mem_get_qi (v));
1946 v += w ? 2 : 1;
1947 b --;
1948 }
1949 put_reg (a0, v);
1950 put_reg (a1, a);
1951 put_reg (r3, b);
1952
1953 /** 1011 1000 000w 0011 SSTR.size */
1954
1955 a = get_reg (a1);
1956 b = get_reg (r3);
3877a145 1957 v = get_reg (w ? r0 : r0l);
d45a4bef
JB		 1958 for (;b;)
1959 {
1960 if (w)
3877a145 1961 mem_put_hi(a, v);
d45a4bef 1962 else
3877a145 1963 mem_put_qi(a, v);
d45a4bef
JB		 1964 a += w ? 2 : 1;
1965 b --;
1966 }
1967 put_reg (a1, a);
1968 put_reg (r3, b);
1969
1970 /** 0000 0001 1101 ddd1 dd01 0src STC src,dest */
1971
1972 prefix (0, 0, 0);
1973 dc = decode_dest23 (ddd, dd, 4);
1974 sc = decode_cr_b (src, CR_B_DMA0);
1975 a = get_src (sc);
1976 put_dest (dc, a);
1977
1978 /** 0000 0001 1101 ddd1 dd01 1src STC src,dest */
1979
1980 prefix (0, 0, 0);
1981 dc = decode_dest23 (ddd, dd, 2);
1982 sc = decode_cr_b (src, CR_B_DCT0);
1983 a = get_src (sc);
1984 put_dest (dc, a);
1985
1986 /** 1101 ddd1 dd01 0src STC src,dest */
1987
1988 prefix (0, 0, 0);
1989 dc = decode_dest23 (ddd, dd, 4);
1990 sc = decode_cr_b (src, CR_B_INTB);
1991 a = get_src (sc);
1992 put_dest (dc, a);
1993
1994 /** 1011 0110 1101 0011 STCX abs16,abs24 */
1995
1996 NOTYET();
1997
1998 /** 1001 ddd w dd01 1111 STNZ.size #IMM,dest */
1999
2000 prefix (0, 1, 0);
2001 dc = decode_dest23 (ddd, dd, w+1);
2002 imm = IMM(w+1);
2003 if (! FLAG_Z)
2004 put_dest (dc, imm);
2005
2006 /** 1001 ddd w dd00 1111 STZ.size #IMM,dest */
2007
2008 prefix (0, 1, 0);
2009 dc = decode_dest23 (ddd, dd, w+1);
2010 imm = IMM(w+1);
2011 if (FLAG_Z)
2012 put_dest (dc, imm);
2013
2014 /** 1001 ddd w dd11 1111 STZX.size #IMM1,#IMM2,dest */
2015
2016 prefix (0, 1, 0);
2017 dc = decode_dest23 (ddd, dd, w+1);
2018 a = IMM(w+1);
2019 b = IMM(w+1);
2020 if (FLAG_Z)
2021 put_dest (dc, a);
2022 else
2023 put_dest (dc, b);
2024
2025 /** 1000 ddd w dd11 1110 SUB.size:G #IMM,dest */
2026
2027 prefix (0, 1, 0);
2028 dc = decode_dest23(ddd, dd, w+1);
2029 imm = IMM(w+1);
2030 MATH_OP (dc, imm, 0, -);
2031
2032 /** 1001 ddd0 dd11 0001 SUB.L:G #IMM,dest */
2033
2034 prefix (0, 1, 0);
2035 dc = decode_dest23(ddd, dd, 4);
2036 imm = IMM(4);
2037 MATH_OP (dc, imm, 0, -);
2038
2039 /** 00dd 111w SUB.size:S #IMM,dest */
2040
2041 prefix (0, 1, 0);
2042 dc = decode_dest2(dd, w+1);
2043 imm = IMM (w+1);
2044 MATH_OP (dc, imm, 0, -);
2045
2046 /** 1sss ddd w dd ss 1010 SUB.size:G src,dest */
2047
2048 prefix (1, 1, 0);
2049 sc = decode_src23(sss, ss, w+1);
2050 dc = decode_dest23(ddd, dd, w+1);
2051 b = get_src (sc);
2052 MATH_OP (dc, b, 0, -);
2053
2054 /** 1sss ddd1 dd ss 0000 SUB.L:G src,dest */
2055
2056 prefix (1, 1, 0);
2057 sc = decode_src23(sss, ss, 4);
2058 dc = decode_dest23(ddd, dd, 4);
2059 b = get_src (sc);
2060 MATH_OP (dc, b, 0, -);
2061
2062 /** 1001 ddd0 dd01 0001 SUBX #IMM,dest */
2063
2064 prefix (0, 1, 0);
2065 dc = decode_dest23(ddd, dd, 4);
2066 imm = sign_ext (IMM(1), 8);
2067 MATH_OP (dc, imm, 0, -);
2068
2069 /** 1sss ddd0 dd ss 0000 SUBX src,dest */
2070
2071 prefix (1, 1, 0);
2072 sc = decode_src23(sss, ss, 1);
2073 dc = decode_dest23(ddd, dd, 4);
2074 b = sign_ext (get_src (sc), 8);
2075 MATH_OP (dc, b, 0, -);
2076
2077 /** 1001 ddd w dd11 1110 TST.size:G #IMM,dest */
2078
2079 prefix (0, 0, 0);
2080 dc = decode_dest23 (ddd, dd, w+1);
2081 imm = IMM(w+1);
2082 a = get_src (dc);
2083 v = a & imm;
2084 set_sz (v, w+1);
2085
2086 /** 00dd 110w TST.size:S #IMM,dest */
2087
2088 prefix (0, 0, 0);
2089 dc = decode_dest2 (dd, w+1);
2090 imm = IMM(w+1);
2091 a = get_src (dc);
2092 v = a & imm;
2093 set_sz (v, w+1);
2094
2095 /** 0000 0001 1sss ddd w dd ss 1001 TST.size:G src,dest */
2096
2097 prefix (0, 0, 0);
2098 sc = decode_src23 (sss, ss, w+1);
2099 dc = decode_dest23 (ddd, dd, w+1);
2100 b = get_src (sc);
2101 a = get_src (dc);
2102 v = a & b;
2103 set_sz (v, w+1);
2104
2105 /** 1111 1111 UND */
2106
2107 trigger_fixed_interrupt (0xffffdc);
2108
2109 /** 1011 0010 0000 0011 WAIT */
2110
2111 ;
2112
2113 /** 1101 ddd w dd00 1src XCHG.size src,dest */
2114
2115 dc = decode_dest23 (ddd, dd, w+1);
2116 sc = decode_src3 (src, w+1);
2117 a = get_src (dc);
2118 b = get_src (sc);
2119 put_dest (dc, b);
2120 put_dest (sc, a);
2121
2122 /** 1001 ddd w dd00 1110 XOR.size #IMM,dest */
2123
2124 prefix (0, 1, 0);
2125 dc = decode_dest23(ddd, dd, w+1);
2126 imm = IMM(w+1);
2127 LOGIC_OP (dc, imm, ^);
2128
2129 /** 1sss ddd w dd ss 1001 XOR.size src,dest */
2130
2131 prefix (1, 1, 0);
2132 sc = decode_src23(sss, ss, w+1);
2133 dc = decode_dest23(ddd, dd, w+1);
2134 b = get_src (sc);
2135 LOGIC_OP (dc, b, ^);
2136
2137/** */
2138
2139 return step_result;
2140}
A mirror of the official binutils-gdb repository