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