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