]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - opcodes/s12z-opc.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
MSP420 assembler: Add -m{u,U} options to enable/disable NOP warnings for unknown...
[thirdparty/binutils-gdb.git] / opcodes / s12z-opc.c
CommitLineData
ef1ad42b
JD		 1/* s12z-decode.c -- Freescale S12Z disassembly
2 Copyright (C) 2018 Free Software Foundation, Inc.
3
4 This file is part of the GNU opcodes library.
5
6 This library is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 It is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
14 License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21#include "sysdep.h"
22#include <stdio.h>
23#include <stdint.h>
24#include <stdbool.h>
25#include <assert.h>
26
27#include "opcode/s12z.h"
28
29#include "bfd.h"
30
31#include "s12z-opc.h"
32
33
34typedef int (* insn_bytes_f) (struct mem_read_abstraction_base *);
35
36typedef void (*operands_f) (struct mem_read_abstraction_base *,
37 int *n_operands, struct operand **operand);
38
e5a557ac
JD		 39typedef enum optr (*discriminator_f) (struct mem_read_abstraction_base *,
40 enum optr hint);
ef1ad42b
JD		 41
42enum OPR_MODE
43 {
44 OPR_IMMe4,
45 OPR_REG,
46 OPR_OFXYS,
47 OPR_XY_PRE_INC,
48 OPR_XY_POST_INC,
49 OPR_XY_PRE_DEC,
50 OPR_XY_POST_DEC,
51 OPR_S_PRE_DEC,
52 OPR_S_POST_INC,
53 OPR_REG_DIRECT,
54 OPR_REG_INDIRECT,
55 OPR_IDX_DIRECT,
56 OPR_IDX_INDIRECT,
57 OPR_EXT1,
58 OPR_IDX2_REG,
59 OPR_IDX3_DIRECT,
60 OPR_IDX3_INDIRECT,
61
62 OPR_EXT18,
63 OPR_IDX3_DIRECT_REG,
64 OPR_EXT3_DIRECT,
65 OPR_EXT3_INDIRECT
66 };
67
68struct opr_pb
69{
70 uint8_t mask;
71 uint8_t value;
72 int n_operands;
73 enum OPR_MODE mode;
74};
75
76static const struct opr_pb opr_pb[] = {
77 {0xF0, 0x70, 1, OPR_IMMe4},
78 {0xF8, 0xB8, 1, OPR_REG},
79 {0xC0, 0x40, 1, OPR_OFXYS},
80 {0xEF, 0xE3, 1, OPR_XY_PRE_INC},
81 {0xEF, 0xE7, 1, OPR_XY_POST_INC},
82 {0xEF, 0xC3, 1, OPR_XY_PRE_DEC},
83 {0xEF, 0xC7, 1, OPR_XY_POST_DEC},
84 {0xFF, 0xFB, 1, OPR_S_PRE_DEC},
85 {0xFF, 0xFF, 1, OPR_S_POST_INC},
86 {0xC8, 0x88, 1, OPR_REG_DIRECT},
87 {0xE8, 0xC8, 1, OPR_REG_INDIRECT},
88
89 {0xCE, 0xC0, 2, OPR_IDX_DIRECT},
90 {0xCE, 0xC4, 2, OPR_IDX_INDIRECT},
91 {0xC0, 0x00, 2, OPR_EXT1},
92
93 {0xC8, 0x80, 3, OPR_IDX2_REG},
94 {0xFA, 0xF8, 3, OPR_EXT18},
95
96 {0xCF, 0xC2, 4, OPR_IDX3_DIRECT},
97 {0xCF, 0xC6, 4, OPR_IDX3_INDIRECT},
98
99 {0xF8, 0xE8, 4, OPR_IDX3_DIRECT_REG},
100 {0xFF, 0xFA, 4, OPR_EXT3_DIRECT},
101 {0xFF, 0xFE, 4, OPR_EXT3_INDIRECT},
102};
103
104/* Return the number of bytes in a OPR operand, including the XB postbyte.
105 It does not include any preceeding opcodes. */
106static int
107x_opr_n_bytes (struct mem_read_abstraction_base *mra, int offset)
108{
109 bfd_byte xb;
110 int status = mra->read (mra, offset, 1, &xb);
111 if (status < 0)
112 return status;
113
114 size_t i;
115 for (i = 0; i < sizeof (opr_pb) / sizeof (opr_pb[0]); ++i)
116 {
117 const struct opr_pb *pb = opr_pb + i;
118 if ((xb & pb->mask) == pb->value)
119 {
120 return pb->n_operands;
121 }
122 }
123
124 return 1;
125}
126
127static int
128opr_n_bytes_p1 (struct mem_read_abstraction_base *mra)
129{
130 return 1 + x_opr_n_bytes (mra, 0);
131}
132
133static int
134opr_n_bytes2 (struct mem_read_abstraction_base *mra)
135{
136 int s = x_opr_n_bytes (mra, 0);
137 s += x_opr_n_bytes (mra, s);
138 return s + 1;
139}
140
141enum BB_MODE
142 {
143 BB_REG_REG_REG,
144 BB_REG_REG_IMM,
145 BB_REG_OPR_REG,
146 BB_OPR_REG_REG,
147 BB_REG_OPR_IMM,
148 BB_OPR_REG_IMM
149 };
150
151struct opr_bb
152{
153 uint8_t mask;
154 uint8_t value;
155 int n_operands;
156 bool opr;
157 enum BB_MODE mode;
158};
159
160static const struct opr_bb bb_modes[] =
161 {
162 {0x60, 0x00, 2, false, BB_REG_REG_REG},
163 {0x60, 0x20, 3, false, BB_REG_REG_IMM},
164 {0x70, 0x40, 2, true, BB_REG_OPR_REG},
165 {0x70, 0x50, 2, true, BB_OPR_REG_REG},
166 {0x70, 0x60, 3, true, BB_REG_OPR_IMM},
167 {0x70, 0x70, 3, true, BB_OPR_REG_IMM}
168 };
169
170static int
171bfextins_n_bytes (struct mem_read_abstraction_base *mra)
172{
173 bfd_byte bb;
174 int status = mra->read (mra, 0, 1, &bb);
175 if (status < 0)
176 return status;
177
178 size_t i;
179 const struct opr_bb *bbs = 0;
180 for (i = 0; i < sizeof (bb_modes) / sizeof (bb_modes[0]); ++i)
181 {
182 bbs = bb_modes + i;
183 if ((bb & bbs->mask) == bbs->value)
184 {
185 break;
186 }
187 }
188
189 int n = bbs->n_operands;
190 if (bbs->opr)
191 n += x_opr_n_bytes (mra, n - 1);
192
193 return n;
194}
195
196static int
197single (struct mem_read_abstraction_base *mra ATTRIBUTE_UNUSED)
198{
199 return 1;
200}
201
202static int
203two (struct mem_read_abstraction_base *mra ATTRIBUTE_UNUSED)
204{
205 return 2;
206}
207
208static int
209three (struct mem_read_abstraction_base *mra ATTRIBUTE_UNUSED)
210{
211 return 3;
212}
213
214static int
215four (struct mem_read_abstraction_base *mra ATTRIBUTE_UNUSED)
216{
217 return 4;
218}
219
220static int
221five (struct mem_read_abstraction_base *mra ATTRIBUTE_UNUSED)
222{
223 return 5;
224}
225
226static int
227pcrel_15bit (struct mem_read_abstraction_base *mra)
228{
229 bfd_byte byte;
230 int status = mra->read (mra, 0, 1, &byte);
231 if (status < 0)
232 return status;
233 return (byte & 0x80) ? 3 : 2;
234}
235
236
237\f
238static int
239xysp_reg_from_postbyte (uint8_t postbyte)
240{
241 int reg = -1;
242 switch ((postbyte & 0x30) >> 4)
243 {
244 case 0:
245 reg = REG_X;
246 break;
247 case 1:
248 reg = REG_Y;
249 break;
250 case 2:
251 reg = REG_S;
252 break;
253 default:
254 reg = REG_P;
255 }
256 return reg;
257}
258
259static struct operand * create_immediate_operand (int value)
260{
261 struct immediate_operand *op = malloc (sizeof (*op));
262
263 ((struct operand *)op)->cl = OPND_CL_IMMEDIATE;
264 op->value = value;
265 ((struct operand *)op)->osize = -1;
266
267 return (struct operand *) op;
268}
269
270static struct operand * create_bitfield_operand (int width, int offset)
271{
272 struct bitfield_operand *op = malloc (sizeof (*op));
273
274 ((struct operand *)op)->cl = OPND_CL_BIT_FIELD;
275 op->width = width;
276 op->offset = offset;
277 ((struct operand *)op)->osize = -1;
278
279 return (struct operand *) op;
280}
281
282static struct operand *
283create_register_operand_with_size (int reg, short osize)
284{
285 struct register_operand *op = malloc (sizeof (*op));
286
287 ((struct operand *)op)->cl = OPND_CL_REGISTER;
288 op->reg = reg;
289 ((struct operand *)op)->osize = osize;
290
291 return (struct operand *) op;
292}
293
294static struct operand *
295create_register_operand (int reg)
296{
297 return create_register_operand_with_size (reg, -1);
298}
299
300static struct operand * create_register_all_operand (void)
301{
302 struct register_operand *op = malloc (sizeof (*op));
303
304 ((struct operand *)op)->cl = OPND_CL_REGISTER_ALL;
305 ((struct operand *)op)->osize = -1;
306
307 return (struct operand *) op;
308}
309
310static struct operand * create_register_all16_operand (void)
311{
312 struct register_operand *op = malloc (sizeof (*op));
313
314 ((struct operand *)op)->cl = OPND_CL_REGISTER_ALL16;
315 ((struct operand *)op)->osize = -1;
316
317 return (struct operand *) op;
318}
319
320
321static struct operand *
322create_simple_memory_operand (bfd_vma addr, bfd_vma base, bool relative)
323{
324 struct simple_memory_operand *op = malloc (sizeof (*op));
325
326 ((struct operand *)op)->cl = OPND_CL_SIMPLE_MEMORY;
327 op->addr = addr;
328 op->base = base;
329 op->relative = relative;
330 ((struct operand *)op)->osize = -1;
331
332 assert (relative || base == 0);
333
334 return (struct operand *) op;
335}
336
337static struct operand *
338create_memory_operand (bool indirect, int base, int n_regs, int reg0, int reg1)
339{
340 struct memory_operand *op = malloc (sizeof (*op));
341
342 ((struct operand *)op)->cl = OPND_CL_MEMORY;
343 op->indirect = indirect;
344 op->base_offset = base;
345 op->mutation = OPND_RM_NONE;
346 op->n_regs = n_regs;
347 op->regs[0] = reg0;
348 op->regs[1] = reg1;
349 ((struct operand *)op)->osize = -1;
350
351 return (struct operand *) op;
352}
353
354static struct operand *
355create_memory_auto_operand (enum op_reg_mutation mutation, int reg)
356{
357 struct memory_operand *op = malloc (sizeof (*op));
358
359 ((struct operand *)op)->cl = OPND_CL_MEMORY;
360 op->indirect = false;
361 op->base_offset = 0;
362 op->mutation = mutation;
363 op->n_regs = 1;
364 op->regs[0] = reg;
365 op->regs[1] = -1;
366 ((struct operand *)op)->osize = -1;
367
368 return (struct operand *) op;
369}
370
371\f
372
373static void
374z_ext24_decode (struct mem_read_abstraction_base *mra, int *n_operands, struct operand **operand)
375{
376 uint8_t buffer[3];
377 int status = mra->read (mra, 0, 3, buffer);
378 if (status < 0)
379 return;
380
381 int i;
382 uint32_t addr = 0;
383 for (i = 0; i < 3; ++i)
384 {
385 addr <<= 8;
386 addr |= buffer[i];
387 }
388
389 operand[(*n_operands)++] = create_simple_memory_operand (addr, 0, false);
390}
391
392
393static uint32_t
394z_decode_signed_value (struct mem_read_abstraction_base *mra, int offset, short size)
395{
396 assert (size >0);
397 assert (size <= 4);
398 bfd_byte buffer[4];
399 if (0 > mra->read (mra, offset, size, buffer))
400 {
401 return 0;
402 }
403
404 int i;
405 uint32_t value = 0;
406 for (i = 0; i < size; ++i)
407 {
408 value |= buffer[i] << (8 * (size - i - 1));
409 }
410
411 if (buffer[0] & 0x80)
412 {
413 /* Deal with negative values */
414 value -= 0x1UL << (size * 8);
415 }
416 return value;
417}
418
419static uint32_t
420decode_signed_value (struct mem_read_abstraction_base *mra, short size)
421{
422 return z_decode_signed_value (mra, 0, size);
423}
424
425static void
426x_imm1 (struct mem_read_abstraction_base *mra,
427 int offset,
428 int *n_operands, struct operand **operand)
429{
430 bfd_byte byte;
431 int status = mra->read (mra, offset, 1, &byte);
432 if (status < 0)
433 return;
434
435 operand[(*n_operands)++] = create_immediate_operand (byte);
436}
437
438/* An eight bit immediate operand. */
439static void
440imm1_decode (struct mem_read_abstraction_base *mra,
441 int *n_operands, struct operand **operand)
442{
443 x_imm1 (mra, 0, n_operands, operand);
444}
445
446static void
447trap_decode (struct mem_read_abstraction_base *mra,
448 int *n_operands, struct operand **operand)
449{
450 x_imm1 (mra, -1, n_operands, operand);
451}
452
453
454static struct operand *
455x_opr_decode_with_size (struct mem_read_abstraction_base *mra, int offset,
456 short osize)
457{
458 bfd_byte postbyte;
459 int status = mra->read (mra, offset, 1, &postbyte);
460 if (status < 0)
461 return NULL;
462 offset++;
463
464 enum OPR_MODE mode = -1;
465 size_t i;
466 for (i = 0; i < sizeof (opr_pb) / sizeof (opr_pb[0]); ++i)
467 {
468 const struct opr_pb *pb = opr_pb + i;
469 if ((postbyte & pb->mask) == pb->value)
470 {
471 mode = pb->mode;
472 break;
473 }
474 }
475
476 struct operand *operand = NULL;
477 switch (mode)
478 {
479 case OPR_IMMe4:
480 {
481 int n;
482 uint8_t x = (postbyte & 0x0F);
483 if (x == 0)
484 n = -1;
485 else
486 n = x;
487
488 operand = create_immediate_operand (n);
489 break;
490 }
491 case OPR_REG:
492 {
493 uint8_t x = (postbyte & 0x07);
494 operand = create_register_operand (x);
495 break;
496 }
497 case OPR_OFXYS:
498 {
499 operand = create_memory_operand (false, postbyte & 0x0F, 1,
500 xysp_reg_from_postbyte (postbyte), -1);
501 break;
502 }
503 case OPR_REG_DIRECT:
504 {
505 operand = create_memory_operand (false, 0, 2, postbyte & 0x07,
506 xysp_reg_from_postbyte (postbyte));
507 break;
508 }
509 case OPR_REG_INDIRECT:
510 {
511 operand = create_memory_operand (true, 0, 2, postbyte & 0x07,
512 (postbyte & 0x10) ? REG_Y : REG_X);
513 break;
514 }
515
516 case OPR_IDX_INDIRECT:
517 {
518 uint8_t x1;
519 mra->read (mra, offset, 1, &x1);
520 int idx = x1;
521
522 if (postbyte & 0x01)
523 {
524 /* Deal with negative values */
525 idx -= 0x1UL << 8;
526 }
527
528 operand = create_memory_operand (true, idx, 1,
529 xysp_reg_from_postbyte (postbyte), -1);
530 break;
531 }
532
533 case OPR_IDX3_DIRECT:
534 {
535 uint8_t x[3];
536 mra->read (mra, offset, 3, x);
537 int idx = x[0] << 16 | x[1] << 8 | x[2];
538
539 if (x[0] & 0x80)
540 {
541 /* Deal with negative values */
542 idx -= 0x1UL << 24;
543 }
544
545 operand = create_memory_operand (false, idx, 1,
546 xysp_reg_from_postbyte (postbyte), -1);
547 break;
548 }
549
550 case OPR_IDX3_DIRECT_REG:
551 {
552 uint8_t x[3];
553 mra->read (mra, offset, 3, x);
554 int idx = x[0] << 16 | x[1] << 8 | x[2];
555
556 if (x[0] & 0x80)
557 {
558 /* Deal with negative values */
559 idx -= 0x1UL << 24;
560 }
561
562 operand = create_memory_operand (false, idx, 1, postbyte & 0x07, -1);
563 break;
564 }
565
566 case OPR_IDX3_INDIRECT:
567 {
568 uint8_t x[3];
569 mra->read (mra, offset, 3, x);
570 int idx = x[0] << 16 | x[1] << 8 | x[2];
571
572 if (x[0] & 0x80)
573 {
574 /* Deal with negative values */
575 idx -= 0x1UL << 24;
576 }
577
578 operand = create_memory_operand (true, idx, 1,
579 xysp_reg_from_postbyte (postbyte), -1);
580 break;
581 }
582
583 case OPR_IDX_DIRECT:
584 {
585 uint8_t x1;
586 mra->read (mra, offset, 1, &x1);
587 int idx = x1;
588
589 if (postbyte & 0x01)
590 {
591 /* Deal with negative values */
592 idx -= 0x1UL << 8;
593 }
594
595 operand = create_memory_operand (false, idx, 1,
596 xysp_reg_from_postbyte (postbyte), -1);
597 break;
598 }
599
600 case OPR_IDX2_REG:
601 {
602 uint8_t x[2];
603 mra->read (mra, offset, 2, x);
604 uint32_t idx = x[1] | x[0] << 8 ;
605 idx |= (postbyte & 0x30) << 12;
606
607 operand = create_memory_operand (false, idx, 1, postbyte & 0x07, -1);
608 break;
609 }
610
611 case OPR_XY_PRE_INC:
612 {
613 operand = create_memory_auto_operand (OPND_RM_PRE_INC,
614 (postbyte & 0x10) ? REG_Y: REG_X);
615 break;
616 }
617 case OPR_XY_POST_INC:
618 {
619 operand = create_memory_auto_operand (OPND_RM_POST_INC,
620 (postbyte & 0x10) ? REG_Y: REG_X);
621 break;
622 }
623 case OPR_XY_PRE_DEC:
624 {
625 operand = create_memory_auto_operand (OPND_RM_PRE_DEC,
626 (postbyte & 0x10) ? REG_Y: REG_X);
627 break;
628 }
629 case OPR_XY_POST_DEC:
630 {
631 operand = create_memory_auto_operand (OPND_RM_POST_DEC,
632 (postbyte & 0x10) ? REG_Y: REG_X);
633 break;
634 }
635 case OPR_S_PRE_DEC:
636 {
637 operand = create_memory_auto_operand (OPND_RM_PRE_DEC, REG_S);
638 break;
639 }
640 case OPR_S_POST_INC:
641 {
642 operand = create_memory_auto_operand (OPND_RM_POST_INC, REG_S);
643 break;
644 }
645
646 case OPR_EXT18:
647 {
648 const size_t size = 2;
649 bfd_byte buffer[4];
650 status = mra->read (mra, offset, size, buffer);
651 if (status < 0)
652 operand = NULL;
653
654 uint32_t ext18 = 0;
655 for (i = 0; i < size; ++i)
656 {
657 ext18 <<= 8;
658 ext18 |= buffer[i];
659 }
660
661 ext18 |= (postbyte & 0x01) << 16;
662 ext18 |= (postbyte & 0x04) << 15;
663
664 operand = create_simple_memory_operand (ext18, 0, false);
665 break;
666 }
667
668 case OPR_EXT1:
669 {
670 uint8_t x1 = 0;
671 mra->read (mra, offset, 1, &x1);
672 int16_t addr;
673 addr = x1;
674 addr |= (postbyte & 0x3f) << 8;
675
676 operand = create_simple_memory_operand (addr, 0, false);
677 break;
678 }
679
680 case OPR_EXT3_DIRECT:
681 {
682 const size_t size = 3;
683 bfd_byte buffer[4];
684 status = mra->read (mra, offset, size, buffer);
685 if (status < 0)
686 operand = NULL;
687
688 uint32_t ext24 = 0;
689 for (i = 0; i < size; ++i)
690 {
691 ext24 |= buffer[i] << (8 * (size - i - 1));
692 }
693
694 operand = create_simple_memory_operand (ext24, 0, false);
695 break;
696 }
697
698 case OPR_EXT3_INDIRECT:
699 {
700 const size_t size = 3;
701 bfd_byte buffer[4];
702 status = mra->read (mra, offset, size, buffer);
703 if (status < 0)
704 operand = NULL;
705
706 uint32_t ext24 = 0;
707 for (i = 0; i < size; ++i)
708 {
709 ext24 |= buffer[i] << (8 * (size - i - 1));
710 }
711
712 operand = create_memory_operand (true, ext24, 0, -1, -1);
713 break;
714 }
715
716 default:
717 printf ("Unknown OPR mode #0x%x (%d)", postbyte, mode);
718 abort ();
719 }
720
721 operand->osize = osize;
722
723 return operand;
724}
725
726static struct operand *
727x_opr_decode (struct mem_read_abstraction_base *mra, int offset)
728{
729 return x_opr_decode_with_size (mra, offset, -1);
730}
731
732static void
733z_opr_decode (struct mem_read_abstraction_base *mra,
734 int *n_operands, struct operand **operand)
735{
736 operand[(*n_operands)++] = x_opr_decode (mra, 0);
737}
738
739static void
740z_opr_decode2 (struct mem_read_abstraction_base *mra,
741 int *n_operands, struct operand **operand)
742{
743 int n = x_opr_n_bytes (mra, 0);
744
745 operand[(*n_operands)++] = x_opr_decode (mra, 0);
746 operand[(*n_operands)++] = x_opr_decode (mra, n);
747}
748
749static void
750imm1234 (struct mem_read_abstraction_base *mra, int base,
751 int *n_operands, struct operand **operand)
752{
753 bfd_byte opcode;
754 int status = mra->read (mra, -1, 1, &opcode);
755 if (status < 0)
756 return;
757
758 opcode -= base;
759
760 int size = registers[opcode & 0xF].bytes;
761
762 uint32_t imm = decode_signed_value (mra, size);
763
764 operand[(*n_operands)++] = create_immediate_operand (imm);
765}
766
767
768/* Special case of LD and CMP with register S and IMM operand */
769static void
770reg_s_imm (struct mem_read_abstraction_base *mra, int *n_operands,
771 struct operand **operand)
772{
773 operand[(*n_operands)++] = create_register_operand (REG_S);
774
775 uint32_t imm = decode_signed_value (mra, 3);
776 operand[(*n_operands)++] = create_immediate_operand (imm);
777}
778
779/* Special case of LD, CMP and ST with register S and OPR operand */
780static void
781reg_s_opr (struct mem_read_abstraction_base *mra, int *n_operands,
782 struct operand **operand)
783{
784 operand[(*n_operands)++] = create_register_operand (REG_S);
785 operand[(*n_operands)++] = x_opr_decode (mra, 0);
786}
787
788static void
789z_imm1234_8base (struct mem_read_abstraction_base *mra, int *n_operands,
790 struct operand **operand)
791{
792 imm1234 (mra, 8, n_operands, operand);
793}
794
795static void
796z_imm1234_0base (struct mem_read_abstraction_base *mra, int *n_operands,
797 struct operand **operand)
798{
799 imm1234 (mra, 0, n_operands, operand);
800}
801
802
803static void
804z_tfr (struct mem_read_abstraction_base *mra, int *n_operands,
805 struct operand **operand)
806{
807 bfd_byte byte;
808 int status = mra->read (mra, 0, 1, &byte);
809 if (status < 0)
810 return;
811
812 operand[(*n_operands)++] = create_register_operand (byte >> 4);
813 operand[(*n_operands)++] = create_register_operand (byte & 0x0F);
814}
815
816static void
817z_reg (struct mem_read_abstraction_base *mra, int *n_operands,
818 struct operand **operand)
819{
820 bfd_byte byte;
821 int status = mra->read (mra, -1, 1, &byte);
822 if (status < 0)
823 return;
824
825 operand[(*n_operands)++] = create_register_operand (byte & 0x07);
826}
827
828
829static void
830reg_xy (struct mem_read_abstraction_base *mra,
831 int *n_operands, struct operand **operand)
832{
833 bfd_byte byte;
834 int status = mra->read (mra, -1, 1, &byte);
835 if (status < 0)
836 return;
837
838 operand[(*n_operands)++] =
839 create_register_operand ((byte & 0x01) ? REG_Y : REG_X);
840}
841
842static void
843lea_reg_xys_opr (struct mem_read_abstraction_base *mra,
844 int *n_operands, struct operand **operand)
845{
846 bfd_byte byte;
847 int status = mra->read (mra, -1, 1, &byte);
848 if (status < 0)
849 return;
850
851 int reg_xys = -1;
852 switch (byte & 0x03)
853 {
854 case 0x00:
855 reg_xys = REG_X;
856 break;
857 case 0x01:
858 reg_xys = REG_Y;
859 break;
860 case 0x02:
861 reg_xys = REG_S;
862 break;
863 }
864
865 operand[(*n_operands)++] = create_register_operand (reg_xys);
866 operand[(*n_operands)++] = x_opr_decode (mra, 0);
867}
868
869static void
870lea_reg_xys (struct mem_read_abstraction_base *mra,
871 int *n_operands, struct operand **operand)
872{
873 bfd_byte byte;
874 int status = mra->read (mra, -1, 1, &byte);
875 if (status < 0)
876 return;
877
878 int reg_n = -1;
879 switch (byte & 0x03)
880 {
881 case 0x00:
882 reg_n = REG_X;
883 break;
884 case 0x01:
885 reg_n = REG_Y;
886 break;
887 case 0x02:
888 reg_n = REG_S;
889 break;
890 }
891
892 status = mra->read (mra, 0, 1, &byte);
893 if (status < 0)
894 return;
895
896 operand[(*n_operands)++] = create_register_operand (reg_n);
897 operand[(*n_operands)++] = create_memory_operand (false, (int8_t) byte,
898 1, reg_n, -1);
899}
900
901
902/* PC Relative offsets of size 15 or 7 bits */
903static void
904rel_15_7 (struct mem_read_abstraction_base *mra, int offset,
905 int *n_operands, struct operand **operands)
906{
907 bfd_byte upper;
908 int status = mra->read (mra, offset - 1, 1, &upper);
909 if (status < 0)
910 return;
911
912 bool rel_size = (upper & 0x80);
913
914 int16_t addr = upper;
915 if (rel_size)
916 {
917 /* 15 bits. Get the next byte */
918 bfd_byte lower;
919 status = mra->read (mra, offset, 1, &lower);
920 if (status < 0)
921 return;
922
923 addr <<= 8;
924 addr |= lower;
925 addr &= 0x7FFF;
926
927 bool negative = (addr & 0x4000);
928 addr &= 0x3FFF;
929 if (negative)
930 addr = addr - 0x4000;
931 }
932 else
933 {
934 /* 7 bits. */
935 bool negative = (addr & 0x40);
936 addr &= 0x3F;
937 if (negative)
938 addr = addr - 0x40;
939 }
940
941 operands[(*n_operands)++] =
942 create_simple_memory_operand (addr, mra->posn (mra) - 1, true);
943}
944
945
946/* PC Relative offsets of size 15 or 7 bits */
947static void
948decode_rel_15_7 (struct mem_read_abstraction_base *mra,
949 int *n_operands, struct operand **operand)
950{
951 rel_15_7 (mra, 1, n_operands, operand);
952}
953
954static int shift_n_bytes (struct mem_read_abstraction_base *);
955static int mov_imm_opr_n_bytes (struct mem_read_abstraction_base *);
956static int loop_prim_n_bytes (struct mem_read_abstraction_base *);
957static int bm_rel_n_bytes (struct mem_read_abstraction_base *);
958static int mul_n_bytes (struct mem_read_abstraction_base *);
959static int bm_n_bytes (struct mem_read_abstraction_base *);
960
961static void psh_pul_decode (struct mem_read_abstraction_base *mra, int *n_operands, struct operand **operand);
962static void shift_decode (struct mem_read_abstraction_base *mra, int *n_operands, struct operand **operand);
963static void mul_decode (struct mem_read_abstraction_base *mra, int *n_operands, struct operand **operand);
964static void bm_decode (struct mem_read_abstraction_base *mra, int *n_operands, struct operand **operand);
965static void bm_rel_decode (struct mem_read_abstraction_base *mra, int *n_operands, struct operand **operand);
966static void mov_imm_opr (struct mem_read_abstraction_base *mra, int *n_operands, struct operand **operand);
967static void loop_primitive_decode (struct mem_read_abstraction_base *mra, int *n_operands, struct operand **operands);
968static void bit_field_decode (struct mem_read_abstraction_base *mra, int *n_operands, struct operand **operands);
969static void exg_sex_decode (struct mem_read_abstraction_base *mra, int *n_operands, struct operand **operands);
970
971
e5a557ac
JD		 972static enum optr shift_discrim (struct mem_read_abstraction_base *mra, enum optr hint);
973static enum optr psh_pul_discrim (struct mem_read_abstraction_base *mra, enum optr hint);
974static enum optr mul_discrim (struct mem_read_abstraction_base *mra, enum optr hint);
975static enum optr loop_primitive_discrim (struct mem_read_abstraction_base *mra, enum optr hint);
976static enum optr bit_field_discrim (struct mem_read_abstraction_base *mra, enum optr hint);
977static enum optr exg_sex_discrim (struct mem_read_abstraction_base *mra, enum optr hint);
ef1ad42b
JD		 978
979
980static void
981cmp_xy (struct mem_read_abstraction_base *mra ATTRIBUTE_UNUSED,
982 int *n_operands, struct operand **operand)
983{
984 operand[(*n_operands)++] = create_register_operand (REG_X);
985 operand[(*n_operands)++] = create_register_operand (REG_Y);
986}
987
988static void
989sub_d6_x_y (struct mem_read_abstraction_base *mra ATTRIBUTE_UNUSED,
990 int *n_operands, struct operand **operand)
991{
992 operand[(*n_operands)++] = create_register_operand (REG_D6);
993 operand[(*n_operands)++] = create_register_operand (REG_X);
994 operand[(*n_operands)++] = create_register_operand (REG_Y);
995}
996
997static void
998sub_d6_y_x (struct mem_read_abstraction_base *mra ATTRIBUTE_UNUSED,
999 int *n_operands, struct operand **operand)
1000{
1001 operand[(*n_operands)++] = create_register_operand (REG_D6);
1002 operand[(*n_operands)++] = create_register_operand (REG_Y);
1003 operand[(*n_operands)++] = create_register_operand (REG_X);
1004}
1005
1006static void ld_18bit_decode (struct mem_read_abstraction_base *mra, int *n_operands, struct operand **operand);
1007
e5a557ac
JD		 1008static enum optr
1009mul_discrim (struct mem_read_abstraction_base *mra, enum optr hint)
ef1ad42b
JD		 1010{
1011 uint8_t mb;
1012 int status = mra->read (mra, 0, 1, &mb);
1013 if (status < 0)
1014 return OP_INVALID;
1015
1016 bool signed_op = (mb & 0x80);
1017
1018 switch (hint)
1019 {
1020 case OPBASE_mul:
1021 return signed_op ? OP_muls : OP_mulu;
1022 break;
1023 case OPBASE_div:
1024 return signed_op ? OP_divs : OP_divu;
1025 break;
1026 case OPBASE_mod:
1027 return signed_op ? OP_mods : OP_modu;
1028 break;
1029 case OPBASE_mac:
1030 return signed_op ? OP_macs : OP_macu;
1031 break;
1032 case OPBASE_qmul:
1033 return signed_op ? OP_qmuls : OP_qmulu;
1034 break;
1035 default:
1036 abort ();
1037 }
1038
1039 return OP_INVALID;
1040}
1041
1042struct opcode
1043{
1044 /* The operation that this opcode performs. */
e5a557ac 1045 enum optr operator;
ef1ad42b
JD		 1046
1047 /* The size of this operation. May be -1 if it is implied
1048 in the operands or if size is not applicable. */
1049 short osize;
1050
1051 /* Some operations need this function to work out which operation
1052 is intended. */
1053 discriminator_f discriminator;
1054
1055 /* A function returning the number of bytes in this instruction. */
1056 insn_bytes_f insn_bytes;
1057
1058 operands_f operands;
1059 operands_f operands2;
1060};
1061
1062static const struct opcode page2[] =
1063 {
1064 [0x00] = {OP_ld, -1, 0, opr_n_bytes_p1, reg_s_opr, 0},
1065 [0x01] = {OP_st, -1, 0, opr_n_bytes_p1, reg_s_opr, 0},
1066 [0x02] = {OP_cmp, -1, 0, opr_n_bytes_p1, reg_s_opr, 0},
1067 [0x03] = {OP_ld, -1, 0, four, reg_s_imm, 0},
1068 [0x04] = {OP_cmp, -1, 0, four, reg_s_imm, 0},
1069 [0x05] = {OP_stop, -1, 0, single, 0, 0},
1070 [0x06] = {OP_wai, -1, 0, single, 0, 0},
1071 [0x07] = {OP_sys, -1, 0, single, 0, 0},
1072 [0x08] = {0xFFFF, -1, bit_field_discrim, bfextins_n_bytes, bit_field_decode, 0}, /* BFEXT / BFINS */
1073 [0x09] = {0xFFFF, -1, bit_field_discrim, bfextins_n_bytes, bit_field_decode, 0},
1074 [0x0a] = {0xFFFF, -1, bit_field_discrim, bfextins_n_bytes, bit_field_decode, 0},
1075 [0x0b] = {0xFFFF, -1, bit_field_discrim, bfextins_n_bytes, bit_field_decode, 0},
1076 [0x0c] = {0xFFFF, -1, bit_field_discrim, bfextins_n_bytes, bit_field_decode, 0},
1077 [0x0d] = {0xFFFF, -1, bit_field_discrim, bfextins_n_bytes, bit_field_decode, 0},
1078 [0x0e] = {0xFFFF, -1, bit_field_discrim, bfextins_n_bytes, bit_field_decode, 0},
1079 [0x0f] = {0xFFFF, -1, bit_field_discrim, bfextins_n_bytes, bit_field_decode, 0},
1080 [0x10] = {OP_minu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1081 [0x11] = {OP_minu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1082 [0x12] = {OP_minu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1083 [0x13] = {OP_minu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1084 [0x14] = {OP_minu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1085 [0x15] = {OP_minu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1086 [0x16] = {OP_minu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1087 [0x17] = {OP_minu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1088 [0x18] = {OP_maxu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1089 [0x19] = {OP_maxu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1090 [0x1a] = {OP_maxu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1091 [0x1b] = {OP_maxu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1092 [0x1c] = {OP_maxu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1093 [0x1d] = {OP_maxu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1094 [0x1e] = {OP_maxu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1095 [0x1f] = {OP_maxu, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1096 [0x20] = {OP_mins, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1097 [0x21] = {OP_mins, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1098 [0x22] = {OP_mins, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1099 [0x23] = {OP_mins, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1100 [0x24] = {OP_mins, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1101 [0x25] = {OP_mins, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1102 [0x26] = {OP_mins, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1103 [0x27] = {OP_mins, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1104 [0x28] = {OP_maxs, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1105 [0x29] = {OP_maxs, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1106 [0x2a] = {OP_maxs, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1107 [0x2b] = {OP_maxs, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1108 [0x2c] = {OP_maxs, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1109 [0x2d] = {OP_maxs, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1110 [0x2e] = {OP_maxs, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1111 [0x2f] = {OP_maxs, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1112 [0x30] = {OPBASE_div, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1113 [0x31] = {OPBASE_div, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1114 [0x32] = {OPBASE_div, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1115 [0x33] = {OPBASE_div, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1116 [0x34] = {OPBASE_div, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1117 [0x35] = {OPBASE_div, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1118 [0x36] = {OPBASE_div, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1119 [0x37] = {OPBASE_div, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1120 [0x38] = {OPBASE_mod, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1121 [0x39] = {OPBASE_mod, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1122 [0x3a] = {OPBASE_mod, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1123 [0x3b] = {OPBASE_mod, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1124 [0x3c] = {OPBASE_mod, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1125 [0x3d] = {OPBASE_mod, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1126 [0x3e] = {OPBASE_mod, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1127 [0x3f] = {OPBASE_mod, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1128 [0x40] = {OP_abs, -1, 0, single, z_reg, 0},
1129 [0x41] = {OP_abs, -1, 0, single, z_reg, 0},
1130 [0x42] = {OP_abs, -1, 0, single, z_reg, 0},
1131 [0x43] = {OP_abs, -1, 0, single, z_reg, 0},
1132 [0x44] = {OP_abs, -1, 0, single, z_reg, 0},
1133 [0x45] = {OP_abs, -1, 0, single, z_reg, 0},
1134 [0x46] = {OP_abs, -1, 0, single, z_reg, 0},
1135 [0x47] = {OP_abs, -1, 0, single, z_reg, 0},
1136 [0x48] = {OPBASE_mac, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1137 [0x49] = {OPBASE_mac, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1138 [0x4a] = {OPBASE_mac, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1139 [0x4b] = {OPBASE_mac, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1140 [0x4c] = {OPBASE_mac, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1141 [0x4d] = {OPBASE_mac, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1142 [0x4e] = {OPBASE_mac, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1143 [0x4f] = {OPBASE_mac, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1144 [0x50] = {OP_adc, -1, 0, three, z_reg, z_imm1234_0base},
1145 [0x51] = {OP_adc, -1, 0, three, z_reg, z_imm1234_0base},
1146 [0x52] = {OP_adc, -1, 0, three, z_reg, z_imm1234_0base},
1147 [0x53] = {OP_adc, -1, 0, three, z_reg, z_imm1234_0base},
1148 [0x54] = {OP_adc, -1, 0, two, z_reg, z_imm1234_0base},
1149 [0x55] = {OP_adc, -1, 0, two, z_reg, z_imm1234_0base},
1150 [0x56] = {OP_adc, -1, 0, five, z_reg, z_imm1234_0base},
1151 [0x57] = {OP_adc, -1, 0, five, z_reg, z_imm1234_0base},
1152 [0x58] = {OP_bit, -1, 0, three, z_reg, z_imm1234_8base},
1153 [0x59] = {OP_bit, -1, 0, three, z_reg, z_imm1234_8base},
1154 [0x5a] = {OP_bit, -1, 0, three, z_reg, z_imm1234_8base},
1155 [0x5b] = {OP_bit, -1, 0, three, z_reg, z_imm1234_8base},
1156 [0x5c] = {OP_bit, -1, 0, two, z_reg, z_imm1234_8base},
1157 [0x5d] = {OP_bit, -1, 0, two, z_reg, z_imm1234_8base},
1158 [0x5e] = {OP_bit, -1, 0, five, z_reg, z_imm1234_8base},
1159 [0x5f] = {OP_bit, -1, 0, five, z_reg, z_imm1234_8base},
1160 [0x60] = {OP_adc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1161 [0x61] = {OP_adc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1162 [0x62] = {OP_adc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1163 [0x63] = {OP_adc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1164 [0x64] = {OP_adc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1165 [0x65] = {OP_adc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1166 [0x66] = {OP_adc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1167 [0x67] = {OP_adc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1168 [0x68] = {OP_bit, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1169 [0x69] = {OP_bit, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1170 [0x6a] = {OP_bit, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1171 [0x6b] = {OP_bit, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1172 [0x6c] = {OP_bit, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1173 [0x6d] = {OP_bit, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1174 [0x6e] = {OP_bit, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1175 [0x6f] = {OP_bit, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1176 [0x70] = {OP_sbc, -1, 0, three, z_reg, z_imm1234_0base},
1177 [0x71] = {OP_sbc, -1, 0, three, z_reg, z_imm1234_0base},
1178 [0x72] = {OP_sbc, -1, 0, three, z_reg, z_imm1234_0base},
1179 [0x73] = {OP_sbc, -1, 0, three, z_reg, z_imm1234_0base},
1180 [0x74] = {OP_sbc, -1, 0, two, z_reg, z_imm1234_0base},
1181 [0x75] = {OP_sbc, -1, 0, two, z_reg, z_imm1234_0base},
1182 [0x76] = {OP_sbc, -1, 0, five, z_reg, z_imm1234_0base},
1183 [0x77] = {OP_sbc, -1, 0, five, z_reg, z_imm1234_0base},
1184 [0x78] = {OP_eor, -1, 0, three, z_reg, z_imm1234_8base},
1185 [0x79] = {OP_eor, -1, 0, three, z_reg, z_imm1234_8base},
1186 [0x7a] = {OP_eor, -1, 0, three, z_reg, z_imm1234_8base},
1187 [0x7b] = {OP_eor, -1, 0, three, z_reg, z_imm1234_8base},
1188 [0x7c] = {OP_eor, -1, 0, two, z_reg, z_imm1234_8base},
1189 [0x7d] = {OP_eor, -1, 0, two, z_reg, z_imm1234_8base},
1190 [0x7e] = {OP_eor, -1, 0, five, z_reg, z_imm1234_8base},
1191 [0x7f] = {OP_eor, -1, 0, five, z_reg, z_imm1234_8base},
1192 [0x80] = {OP_sbc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1193 [0x81] = {OP_sbc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1194 [0x82] = {OP_sbc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1195 [0x83] = {OP_sbc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1196 [0x84] = {OP_sbc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1197 [0x85] = {OP_sbc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1198 [0x86] = {OP_sbc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1199 [0x87] = {OP_sbc, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1200 [0x88] = {OP_eor, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1201 [0x89] = {OP_eor, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1202 [0x8a] = {OP_eor, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1203 [0x8b] = {OP_eor, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1204 [0x8c] = {OP_eor, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1205 [0x8d] = {OP_eor, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1206 [0x8e] = {OP_eor, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1207 [0x8f] = {OP_eor, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1208 [0x90] = {OP_rti, -1, 0, single, 0, 0},
1209 [0x91] = {OP_clb, -1, 0, two, z_tfr, 0},
1210 [0x92] = {OP_trap, -1, 0, single, trap_decode, 0},
1211 [0x93] = {OP_trap, -1, 0, single, trap_decode, 0},
1212 [0x94] = {OP_trap, -1, 0, single, trap_decode, 0},
1213 [0x95] = {OP_trap, -1, 0, single, trap_decode, 0},
1214 [0x96] = {OP_trap, -1, 0, single, trap_decode, 0},
1215 [0x97] = {OP_trap, -1, 0, single, trap_decode, 0},
1216 [0x98] = {OP_trap, -1, 0, single, trap_decode, 0},
1217 [0x99] = {OP_trap, -1, 0, single, trap_decode, 0},
1218 [0x9a] = {OP_trap, -1, 0, single, trap_decode, 0},
1219 [0x9b] = {OP_trap, -1, 0, single, trap_decode, 0},
1220 [0x9c] = {OP_trap, -1, 0, single, trap_decode, 0},
1221 [0x9d] = {OP_trap, -1, 0, single, trap_decode, 0},
1222 [0x9e] = {OP_trap, -1, 0, single, trap_decode, 0},
1223 [0x9f] = {OP_trap, -1, 0, single, trap_decode, 0},
1224 [0xa0] = {OP_sat, -1, 0, single, z_reg, 0},
1225 [0xa1] = {OP_sat, -1, 0, single, z_reg, 0},
1226 [0xa2] = {OP_sat, -1, 0, single, z_reg, 0},
1227 [0xa3] = {OP_sat, -1, 0, single, z_reg, 0},
1228 [0xa4] = {OP_sat, -1, 0, single, z_reg, 0},
1229 [0xa5] = {OP_sat, -1, 0, single, z_reg, 0},
1230 [0xa6] = {OP_sat, -1, 0, single, z_reg, 0},
1231 [0xa7] = {OP_sat, -1, 0, single, z_reg, 0},
1232 [0xa8] = {OP_trap, -1, 0, single, trap_decode, 0},
1233 [0xa9] = {OP_trap, -1, 0, single, trap_decode, 0},
1234 [0xaa] = {OP_trap, -1, 0, single, trap_decode, 0},
1235 [0xab] = {OP_trap, -1, 0, single, trap_decode, 0},
1236 [0xac] = {OP_trap, -1, 0, single, trap_decode, 0},
1237 [0xad] = {OP_trap, -1, 0, single, trap_decode, 0},
1238 [0xae] = {OP_trap, -1, 0, single, trap_decode, 0},
1239 [0xaf] = {OP_trap, -1, 0, single, trap_decode, 0},
1240 [0xb0] = {OPBASE_qmul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1241 [0xb1] = {OPBASE_qmul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1242 [0xb2] = {OPBASE_qmul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1243 [0xb3] = {OPBASE_qmul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1244 [0xb4] = {OPBASE_qmul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1245 [0xb5] = {OPBASE_qmul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1246 [0xb6] = {OPBASE_qmul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1247 [0xb7] = {OPBASE_qmul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1248 [0xb8] = {OP_trap, -1, 0, single, trap_decode, 0},
1249 [0xb9] = {OP_trap, -1, 0, single, trap_decode, 0},
1250 [0xba] = {OP_trap, -1, 0, single, trap_decode, 0},
1251 [0xbb] = {OP_trap, -1, 0, single, trap_decode, 0},
1252 [0xbc] = {OP_trap, -1, 0, single, trap_decode, 0},
1253 [0xbd] = {OP_trap, -1, 0, single, trap_decode, 0},
1254 [0xbe] = {OP_trap, -1, 0, single, trap_decode, 0},
1255 [0xbf] = {OP_trap, -1, 0, single, trap_decode, 0},
1256 [0xc0] = {OP_trap, -1, 0, single, trap_decode, 0},
1257 [0xc1] = {OP_trap, -1, 0, single, trap_decode, 0},
1258 [0xc2] = {OP_trap, -1, 0, single, trap_decode, 0},
1259 [0xc3] = {OP_trap, -1, 0, single, trap_decode, 0},
1260 [0xc4] = {OP_trap, -1, 0, single, trap_decode, 0},
1261 [0xc5] = {OP_trap, -1, 0, single, trap_decode, 0},
1262 [0xc6] = {OP_trap, -1, 0, single, trap_decode, 0},
1263 [0xc7] = {OP_trap, -1, 0, single, trap_decode, 0},
1264 [0xc8] = {OP_trap, -1, 0, single, trap_decode, 0},
1265 [0xc9] = {OP_trap, -1, 0, single, trap_decode, 0},
1266 [0xca] = {OP_trap, -1, 0, single, trap_decode, 0},
1267 [0xcb] = {OP_trap, -1, 0, single, trap_decode, 0},
1268 [0xcc] = {OP_trap, -1, 0, single, trap_decode, 0},
1269 [0xcd] = {OP_trap, -1, 0, single, trap_decode, 0},
1270 [0xce] = {OP_trap, -1, 0, single, trap_decode, 0},
1271 [0xcf] = {OP_trap, -1, 0, single, trap_decode, 0},
1272 [0xd0] = {OP_trap, -1, 0, single, trap_decode, 0},
1273 [0xd1] = {OP_trap, -1, 0, single, trap_decode, 0},
1274 [0xd2] = {OP_trap, -1, 0, single, trap_decode, 0},
1275 [0xd3] = {OP_trap, -1, 0, single, trap_decode, 0},
1276 [0xd4] = {OP_trap, -1, 0, single, trap_decode, 0},
1277 [0xd5] = {OP_trap, -1, 0, single, trap_decode, 0},
1278 [0xd6] = {OP_trap, -1, 0, single, trap_decode, 0},
1279 [0xd7] = {OP_trap, -1, 0, single, trap_decode, 0},
1280 [0xd8] = {OP_trap, -1, 0, single, trap_decode, 0},
1281 [0xd9] = {OP_trap, -1, 0, single, trap_decode, 0},
1282 [0xda] = {OP_trap, -1, 0, single, trap_decode, 0},
1283 [0xdb] = {OP_trap, -1, 0, single, trap_decode, 0},
1284 [0xdc] = {OP_trap, -1, 0, single, trap_decode, 0},
1285 [0xdd] = {OP_trap, -1, 0, single, trap_decode, 0},
1286 [0xde] = {OP_trap, -1, 0, single, trap_decode, 0},
1287 [0xdf] = {OP_trap, -1, 0, single, trap_decode, 0},
1288 [0xe0] = {OP_trap, -1, 0, single, trap_decode, 0},
1289 [0xe1] = {OP_trap, -1, 0, single, trap_decode, 0},
1290 [0xe2] = {OP_trap, -1, 0, single, trap_decode, 0},
1291 [0xe3] = {OP_trap, -1, 0, single, trap_decode, 0},
1292 [0xe4] = {OP_trap, -1, 0, single, trap_decode, 0},
1293 [0xe5] = {OP_trap, -1, 0, single, trap_decode, 0},
1294 [0xe6] = {OP_trap, -1, 0, single, trap_decode, 0},
1295 [0xe7] = {OP_trap, -1, 0, single, trap_decode, 0},
1296 [0xe8] = {OP_trap, -1, 0, single, trap_decode, 0},
1297 [0xe9] = {OP_trap, -1, 0, single, trap_decode, 0},
1298 [0xea] = {OP_trap, -1, 0, single, trap_decode, 0},
1299 [0xeb] = {OP_trap, -1, 0, single, trap_decode, 0},
1300 [0xec] = {OP_trap, -1, 0, single, trap_decode, 0},
1301 [0xed] = {OP_trap, -1, 0, single, trap_decode, 0},
1302 [0xee] = {OP_trap, -1, 0, single, trap_decode, 0},
1303 [0xef] = {OP_trap, -1, 0, single, trap_decode, 0},
1304 [0xf0] = {OP_trap, -1, 0, single, trap_decode, 0},
1305 [0xf1] = {OP_trap, -1, 0, single, trap_decode, 0},
1306 [0xf2] = {OP_trap, -1, 0, single, trap_decode, 0},
1307 [0xf3] = {OP_trap, -1, 0, single, trap_decode, 0},
1308 [0xf4] = {OP_trap, -1, 0, single, trap_decode, 0},
1309 [0xf5] = {OP_trap, -1, 0, single, trap_decode, 0},
1310 [0xf6] = {OP_trap, -1, 0, single, trap_decode, 0},
1311 [0xf7] = {OP_trap, -1, 0, single, trap_decode, 0},
1312 [0xf8] = {OP_trap, -1, 0, single, trap_decode, 0},
1313 [0xf9] = {OP_trap, -1, 0, single, trap_decode, 0},
1314 [0xfa] = {OP_trap, -1, 0, single, trap_decode, 0},
1315 [0xfb] = {OP_trap, -1, 0, single, trap_decode, 0},
1316 [0xfc] = {OP_trap, -1, 0, single, trap_decode, 0},
1317 [0xfd] = {OP_trap, -1, 0, single, trap_decode, 0},
1318 [0xfe] = {OP_trap, -1, 0, single, trap_decode, 0},
1319 [0xff] = {OP_trap, -1, 0, single, trap_decode, 0},
1320 };
1321
1322static const struct opcode page1[] =
1323 {
1324 [0x00] = {OP_bgnd, -1, 0, single, 0, 0},
1325 [0x01] = {OP_nop, -1, 0, single, 0, 0},
1326 [0x02] = {OP_brclr, -1, 0, bm_rel_n_bytes, bm_rel_decode, 0},
1327 [0x03] = {OP_brset, -1, 0, bm_rel_n_bytes, bm_rel_decode, 0},
1328 [0x04] = {0xFFFF, -1, psh_pul_discrim, two, psh_pul_decode, 0}, /* psh/pul */
1329 [0x05] = {OP_rts, -1, 0, single, 0, 0},
1330 [0x06] = {OP_lea, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1331 [0x07] = {OP_lea, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1332 [0x08] = {OP_lea, -1, 0, opr_n_bytes_p1, lea_reg_xys_opr, 0},
1333 [0x09] = {OP_lea, -1, 0, opr_n_bytes_p1, lea_reg_xys_opr, 0},
1334 [0x0a] = {OP_lea, -1, 0, opr_n_bytes_p1, lea_reg_xys_opr, 0},
1335 [0x0b] = {0xFFFF, -1, loop_primitive_discrim, loop_prim_n_bytes, loop_primitive_decode, 0}, /* Loop primitives TBcc / DBcc */
1336 [0x0c] = {OP_mov, 0, 0, mov_imm_opr_n_bytes, mov_imm_opr, 0},
1337 [0x0d] = {OP_mov, 1, 0, mov_imm_opr_n_bytes, mov_imm_opr, 0},
1338 [0x0e] = {OP_mov, 2, 0, mov_imm_opr_n_bytes, mov_imm_opr, 0},
1339 [0x0f] = {OP_mov, 3, 0, mov_imm_opr_n_bytes, mov_imm_opr, 0},
1340 [0x10] = {0xFFFF, -1, shift_discrim, shift_n_bytes, shift_decode, 0}, /* lsr/lsl/asl/asr/rol/ror */
1341 [0x11] = {0xFFFF, -1, shift_discrim, shift_n_bytes, shift_decode, 0},
1342 [0x12] = {0xFFFF, -1, shift_discrim, shift_n_bytes, shift_decode, 0},
1343 [0x13] = {0xFFFF, -1, shift_discrim, shift_n_bytes, shift_decode, 0},
1344 [0x14] = {0xFFFF, -1, shift_discrim, shift_n_bytes, shift_decode, 0},
1345 [0x15] = {0xFFFF, -1, shift_discrim, shift_n_bytes, shift_decode, 0},
1346 [0x16] = {0xFFFF, -1, shift_discrim, shift_n_bytes, shift_decode, 0},
1347 [0x17] = {0xFFFF, -1, shift_discrim, shift_n_bytes, shift_decode, 0},
1348 [0x18] = {OP_lea, -1, 0, two, lea_reg_xys, NULL},
1349 [0x19] = {OP_lea, -1, 0, two, lea_reg_xys, NULL},
1350 [0x1a] = {OP_lea, -1, 0, two, lea_reg_xys, NULL},
1351 /* 0x1b PG2 */
1352 [0x1c] = {OP_mov, 0, 0, opr_n_bytes2, z_opr_decode2, 0},
1353 [0x1d] = {OP_mov, 1, 0, opr_n_bytes2, z_opr_decode2, 0},
1354 [0x1e] = {OP_mov, 2, 0, opr_n_bytes2, z_opr_decode2, 0},
1355 [0x1f] = {OP_mov, 3, 0, opr_n_bytes2, z_opr_decode2, 0},
1356 [0x20] = {OP_bra, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1357 [0x21] = {OP_bsr, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1358 [0x22] = {OP_bhi, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1359 [0x23] = {OP_bls, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1360 [0x24] = {OP_bcc, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1361 [0x25] = {OP_bcs, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1362 [0x26] = {OP_bne, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1363 [0x27] = {OP_beq, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1364 [0x28] = {OP_bvc, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1365 [0x29] = {OP_bvs, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1366 [0x2a] = {OP_bpl, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1367 [0x2b] = {OP_bmi, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1368 [0x2c] = {OP_bge, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1369 [0x2d] = {OP_blt, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1370 [0x2e] = {OP_bgt, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1371 [0x2f] = {OP_ble, -1, 0, pcrel_15bit, decode_rel_15_7, 0},
1372 [0x30] = {OP_inc, -1, 0, single, z_reg, 0},
1373 [0x31] = {OP_inc, -1, 0, single, z_reg, 0},
1374 [0x32] = {OP_inc, -1, 0, single, z_reg, 0},
1375 [0x33] = {OP_inc, -1, 0, single, z_reg, 0},
1376 [0x34] = {OP_inc, -1, 0, single, z_reg, 0},
1377 [0x35] = {OP_inc, -1, 0, single, z_reg, 0},
1378 [0x36] = {OP_inc, -1, 0, single, z_reg, 0},
1379 [0x37] = {OP_inc, -1, 0, single, z_reg, 0},
1380 [0x38] = {OP_clr, -1, 0, single, z_reg, 0},
1381 [0x39] = {OP_clr, -1, 0, single, z_reg, 0},
1382 [0x3a] = {OP_clr, -1, 0, single, z_reg, 0},
1383 [0x3b] = {OP_clr, -1, 0, single, z_reg, 0},
1384 [0x3c] = {OP_clr, -1, 0, single, z_reg, 0},
1385 [0x3d] = {OP_clr, -1, 0, single, z_reg, 0},
1386 [0x3e] = {OP_clr, -1, 0, single, z_reg, 0},
1387 [0x3f] = {OP_clr, -1, 0, single, z_reg, 0},
1388 [0x40] = {OP_dec, -1, 0, single, z_reg, 0},
1389 [0x41] = {OP_dec, -1, 0, single, z_reg, 0},
1390 [0x42] = {OP_dec, -1, 0, single, z_reg, 0},
1391 [0x43] = {OP_dec, -1, 0, single, z_reg, 0},
1392 [0x44] = {OP_dec, -1, 0, single, z_reg, 0},
1393 [0x45] = {OP_dec, -1, 0, single, z_reg, 0},
1394 [0x46] = {OP_dec, -1, 0, single, z_reg, 0},
1395 [0x47] = {OP_dec, -1, 0, single, z_reg, 0},
1396 [0x48] = {OPBASE_mul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1397 [0x49] = {OPBASE_mul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1398 [0x4a] = {OPBASE_mul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1399 [0x4b] = {OPBASE_mul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1400 [0x4c] = {OPBASE_mul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1401 [0x4d] = {OPBASE_mul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1402 [0x4e] = {OPBASE_mul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1403 [0x4f] = {OPBASE_mul, -1, mul_discrim, mul_n_bytes, mul_decode, 0},
1404 [0x50] = {OP_add, -1, 0, three, z_reg, z_imm1234_0base},
1405 [0x51] = {OP_add, -1, 0, three, z_reg, z_imm1234_0base},
1406 [0x52] = {OP_add, -1, 0, three, z_reg, z_imm1234_0base},
1407 [0x53] = {OP_add, -1, 0, three, z_reg, z_imm1234_0base},
1408 [0x54] = {OP_add, -1, 0, two, z_reg, z_imm1234_0base},
1409 [0x55] = {OP_add, -1, 0, two, z_reg, z_imm1234_0base},
1410 [0x56] = {OP_add, -1, 0, five, z_reg, z_imm1234_0base},
1411 [0x57] = {OP_add, -1, 0, five, z_reg, z_imm1234_0base},
1412 [0x58] = {OP_and, -1, 0, three, z_reg, z_imm1234_8base},
1413 [0x59] = {OP_and, -1, 0, three, z_reg, z_imm1234_8base},
1414 [0x5a] = {OP_and, -1, 0, three, z_reg, z_imm1234_8base},
1415 [0x5b] = {OP_and, -1, 0, three, z_reg, z_imm1234_8base},
1416 [0x5c] = {OP_and, -1, 0, two, z_reg, z_imm1234_8base},
1417 [0x5d] = {OP_and, -1, 0, two, z_reg, z_imm1234_8base},
1418 [0x5e] = {OP_and, -1, 0, five, z_reg, z_imm1234_8base},
1419 [0x5f] = {OP_and, -1, 0, five, z_reg, z_imm1234_8base},
1420 [0x60] = {OP_add, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1421 [0x61] = {OP_add, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1422 [0x62] = {OP_add, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1423 [0x63] = {OP_add, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1424 [0x64] = {OP_add, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1425 [0x65] = {OP_add, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1426 [0x66] = {OP_add, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1427 [0x67] = {OP_add, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1428 [0x68] = {OP_and, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1429 [0x69] = {OP_and, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1430 [0x6a] = {OP_and, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1431 [0x6b] = {OP_and, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1432 [0x6c] = {OP_and, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1433 [0x6d] = {OP_and, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1434 [0x6e] = {OP_and, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1435 [0x6f] = {OP_and, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1436 [0x70] = {OP_sub, -1, 0, three, z_reg, z_imm1234_0base},
1437 [0x71] = {OP_sub, -1, 0, three, z_reg, z_imm1234_0base},
1438 [0x72] = {OP_sub, -1, 0, three, z_reg, z_imm1234_0base},
1439 [0x73] = {OP_sub, -1, 0, three, z_reg, z_imm1234_0base},
1440 [0x74] = {OP_sub, -1, 0, two, z_reg, z_imm1234_0base},
1441 [0x75] = {OP_sub, -1, 0, two, z_reg, z_imm1234_0base},
1442 [0x76] = {OP_sub, -1, 0, five, z_reg, z_imm1234_0base},
1443 [0x77] = {OP_sub, -1, 0, five, z_reg, z_imm1234_0base},
1444 [0x78] = {OP_or, -1, 0, three, z_reg, z_imm1234_8base},
1445 [0x79] = {OP_or, -1, 0, three, z_reg, z_imm1234_8base},
1446 [0x7a] = {OP_or, -1, 0, three, z_reg, z_imm1234_8base},
1447 [0x7b] = {OP_or, -1, 0, three, z_reg, z_imm1234_8base},
1448 [0x7c] = {OP_or, -1, 0, two, z_reg, z_imm1234_8base},
1449 [0x7d] = {OP_or, -1, 0, two, z_reg, z_imm1234_8base},
1450 [0x7e] = {OP_or, -1, 0, five, z_reg, z_imm1234_8base},
1451 [0x7f] = {OP_or, -1, 0, five, z_reg, z_imm1234_8base},
1452 [0x80] = {OP_sub, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1453 [0x81] = {OP_sub, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1454 [0x82] = {OP_sub, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1455 [0x83] = {OP_sub, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1456 [0x84] = {OP_sub, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1457 [0x85] = {OP_sub, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1458 [0x86] = {OP_sub, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1459 [0x87] = {OP_sub, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1460 [0x88] = {OP_or, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1461 [0x89] = {OP_or, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1462 [0x8a] = {OP_or, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1463 [0x8b] = {OP_or, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1464 [0x8c] = {OP_or, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1465 [0x8d] = {OP_or, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1466 [0x8e] = {OP_or, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1467 [0x8f] = {OP_or, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1468 [0x90] = {OP_ld, -1, 0, three, z_reg, z_imm1234_0base},
1469 [0x91] = {OP_ld, -1, 0, three, z_reg, z_imm1234_0base},
1470 [0x92] = {OP_ld, -1, 0, three, z_reg, z_imm1234_0base},
1471 [0x93] = {OP_ld, -1, 0, three, z_reg, z_imm1234_0base},
1472 [0x94] = {OP_ld, -1, 0, two, z_reg, z_imm1234_0base},
1473 [0x95] = {OP_ld, -1, 0, two, z_reg, z_imm1234_0base},
1474 [0x96] = {OP_ld, -1, 0, five, z_reg, z_imm1234_0base},
1475 [0x97] = {OP_ld, -1, 0, five, z_reg, z_imm1234_0base},
1476 [0x98] = {OP_ld, -1, 0, four, reg_xy, z_imm1234_0base},
1477 [0x99] = {OP_ld, -1, 0, four, reg_xy, z_imm1234_0base},
1478 [0x9a] = {OP_clr, -1, 0, single, reg_xy, 0},
1479 [0x9b] = {OP_clr, -1, 0, single, reg_xy, 0},
1480 [0x9c] = {OP_inc, 0, 0, opr_n_bytes_p1, z_opr_decode, 0},
1481 [0x9d] = {OP_inc, 1, 0, opr_n_bytes_p1, z_opr_decode, 0},
1482 [0x9e] = {OP_tfr, -1, 0, two, z_tfr, NULL},
1483 [0x9f] = {OP_inc, 3, 0, opr_n_bytes_p1, z_opr_decode, 0},
1484 [0xa0] = {OP_ld, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1485 [0xa1] = {OP_ld, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1486 [0xa2] = {OP_ld, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1487 [0xa3] = {OP_ld, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1488 [0xa4] = {OP_ld, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1489 [0xa5] = {OP_ld, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1490 [0xa6] = {OP_ld, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1491 [0xa7] = {OP_ld, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1492 [0xa8] = {OP_ld, -1, 0, opr_n_bytes_p1, reg_xy, z_opr_decode},
1493 [0xa9] = {OP_ld, -1, 0, opr_n_bytes_p1, reg_xy, z_opr_decode},
1494 [0xaa] = {OP_jmp, -1, 0, opr_n_bytes_p1, z_opr_decode, 0},
1495 [0xab] = {OP_jsr, -1, 0, opr_n_bytes_p1, z_opr_decode, 0},
1496 [0xac] = {OP_dec, 0, 0, opr_n_bytes_p1, z_opr_decode, 0},
1497 [0xad] = {OP_dec, 1, 0, opr_n_bytes_p1, z_opr_decode, 0},
1498 [0xae] = {0xFFFF, -1, exg_sex_discrim, two, exg_sex_decode, 0}, /* EXG / SEX */
1499 [0xaf] = {OP_dec, 3, 0, opr_n_bytes_p1, 0, z_opr_decode},
1500 [0xb0] = {OP_ld, -1, 0, four, z_reg, z_ext24_decode},
1501 [0xb1] = {OP_ld, -1, 0, four, z_reg, z_ext24_decode},
1502 [0xb2] = {OP_ld, -1, 0, four, z_reg, z_ext24_decode},
1503 [0xb3] = {OP_ld, -1, 0, four, z_reg, z_ext24_decode},
1504 [0xb4] = {OP_ld, -1, 0, four, z_reg, z_ext24_decode},
1505 [0xb5] = {OP_ld, -1, 0, four, z_reg, z_ext24_decode},
1506 [0xb6] = {OP_ld, -1, 0, four, z_reg, z_ext24_decode},
1507 [0xb7] = {OP_ld, -1, 0, four, z_reg, z_ext24_decode},
1508 [0xb8] = {OP_ld, -1, 0, four, reg_xy, z_ext24_decode},
1509 [0xb9] = {OP_ld, -1, 0, four, reg_xy, z_ext24_decode},
1510 [0xba] = {OP_jmp, -1, 0, four, z_ext24_decode, 0},
1511 [0xbb] = {OP_jsr, -1, 0, four, z_ext24_decode, 0},
1512 [0xbc] = {OP_clr, 0, 0, opr_n_bytes_p1, z_opr_decode, 0},
1513 [0xbd] = {OP_clr, 1, 0, opr_n_bytes_p1, z_opr_decode, 0},
1514 [0xbe] = {OP_clr, 2, 0, opr_n_bytes_p1, z_opr_decode, 0},
1515 [0xbf] = {OP_clr, 3, 0, opr_n_bytes_p1, z_opr_decode, 0},
1516 [0xc0] = {OP_st, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1517 [0xc1] = {OP_st, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1518 [0xc2] = {OP_st, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1519 [0xc3] = {OP_st, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1520 [0xc4] = {OP_st, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1521 [0xc5] = {OP_st, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1522 [0xc6] = {OP_st, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1523 [0xc7] = {OP_st, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1524 [0xc8] = {OP_st, -1, 0, opr_n_bytes_p1, reg_xy, z_opr_decode},
1525 [0xc9] = {OP_st, -1, 0, opr_n_bytes_p1, reg_xy, z_opr_decode},
1526 [0xca] = {OP_ld, -1, 0, three, reg_xy, ld_18bit_decode},
1527 [0xcb] = {OP_ld, -1, 0, three, reg_xy, ld_18bit_decode},
1528 [0xcc] = {OP_com, 0, 0, opr_n_bytes_p1, NULL, z_opr_decode},
1529 [0xcd] = {OP_com, 1, 0, opr_n_bytes_p1, NULL, z_opr_decode},
1530 [0xce] = {OP_andcc, -1, 0, two, imm1_decode, 0},
1531 [0xcf] = {OP_com, 3, 0, opr_n_bytes_p1, NULL, z_opr_decode},
1532 [0xd0] = {OP_st, -1, 0, four, z_reg, z_ext24_decode},
1533 [0xd1] = {OP_st, -1, 0, four, z_reg, z_ext24_decode},
1534 [0xd2] = {OP_st, -1, 0, four, z_reg, z_ext24_decode},
1535 [0xd3] = {OP_st, -1, 0, four, z_reg, z_ext24_decode},
1536 [0xd4] = {OP_st, -1, 0, four, z_reg, z_ext24_decode},
1537 [0xd5] = {OP_st, -1, 0, four, z_reg, z_ext24_decode},
1538 [0xd6] = {OP_st, -1, 0, four, z_reg, z_ext24_decode},
1539 [0xd7] = {OP_st, -1, 0, four, z_reg, z_ext24_decode},
1540 [0xd8] = {OP_st, -1, 0, four, reg_xy, z_ext24_decode},
1541 [0xd9] = {OP_st, -1, 0, four, reg_xy, z_ext24_decode},
1542 [0xda] = {OP_ld, -1, 0, three, reg_xy, ld_18bit_decode},
1543 [0xdb] = {OP_ld, -1, 0, three, reg_xy, ld_18bit_decode},
1544 [0xdc] = {OP_neg, 0, 0, opr_n_bytes_p1, NULL, z_opr_decode},
1545 [0xdd] = {OP_neg, 1, 0, opr_n_bytes_p1, NULL, z_opr_decode},
1546 [0xde] = {OP_orcc, -1, 0, two, imm1_decode, 0},
1547 [0xdf] = {OP_neg, 3, 0, opr_n_bytes_p1, NULL, z_opr_decode},
1548 [0xe0] = {OP_cmp, -1, 0, three, z_reg, z_imm1234_0base},
1549 [0xe1] = {OP_cmp, -1, 0, three, z_reg, z_imm1234_0base},
1550 [0xe2] = {OP_cmp, -1, 0, three, z_reg, z_imm1234_0base},
1551 [0xe3] = {OP_cmp, -1, 0, three, z_reg, z_imm1234_0base},
1552 [0xe4] = {OP_cmp, -1, 0, two, z_reg, z_imm1234_0base},
1553 [0xe5] = {OP_cmp, -1, 0, two, z_reg, z_imm1234_0base},
1554 [0xe6] = {OP_cmp, -1, 0, five, z_reg, z_imm1234_0base},
1555 [0xe7] = {OP_cmp, -1, 0, five, z_reg, z_imm1234_0base},
1556 [0xe8] = {OP_cmp, -1, 0, four, reg_xy, z_imm1234_0base},
1557 [0xe9] = {OP_cmp, -1, 0, four, reg_xy, z_imm1234_0base},
1558 [0xea] = {OP_ld, -1, 0, three, reg_xy, ld_18bit_decode},
1559 [0xeb] = {OP_ld, -1, 0, three, reg_xy, ld_18bit_decode},
1560 [0xec] = {OP_bclr, -1, 0, bm_n_bytes, bm_decode, 0},
1561 [0xed] = {OP_bset, -1, 0, bm_n_bytes, bm_decode, 0},
1562 [0xee] = {OP_btgl, -1, 0, bm_n_bytes, bm_decode, 0},
1563 [0xef] = {OP_INVALID, -1, 0, NULL, NULL, NULL}, /* SPARE */
1564 [0xf0] = {OP_cmp, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1565 [0xf1] = {OP_cmp, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1566 [0xf2] = {OP_cmp, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1567 [0xf3] = {OP_cmp, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1568 [0xf4] = {OP_cmp, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1569 [0xf5] = {OP_cmp, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1570 [0xf6] = {OP_cmp, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1571 [0xf7] = {OP_cmp, -1, 0, opr_n_bytes_p1, z_reg, z_opr_decode},
1572 [0xf8] = {OP_cmp, -1, 0, opr_n_bytes_p1, reg_xy, z_opr_decode},
1573 [0xf9] = {OP_cmp, -1, 0, opr_n_bytes_p1, reg_xy, z_opr_decode},
1574 [0xfa] = {OP_ld, -1, 0, three, reg_xy, ld_18bit_decode},
1575 [0xfb] = {OP_ld, -1, 0, three, reg_xy, ld_18bit_decode},
1576 [0xfc] = {OP_cmp, -1, 0, single, cmp_xy, 0},
1577 [0xfd] = {OP_sub, -1, 0, single, sub_d6_x_y, 0},
1578 [0xfe] = {OP_sub, -1, 0, single, sub_d6_y_x, 0},
1579 [0xff] = {OP_swi, -1, 0, single, 0, 0}
1580 };
1581
1582static const int oprregs1[] =
1583 {
1584 REG_D3, REG_D2, REG_D1, REG_D0, REG_CCL, REG_CCH
1585 };
1586
1587static const int oprregs2[] =
1588 {
1589 REG_Y, REG_X, REG_D7, REG_D6, REG_D5, REG_D4
1590 };
1591
1592
1593\f
1594
1595enum MUL_MODE
1596 {
1597 MUL_REG_REG,
1598 MUL_REG_OPR,
1599 MUL_REG_IMM,
1600 MUL_OPR_OPR
1601 };
1602
1603struct mb
1604{
1605 uint8_t mask;
1606 uint8_t value;
1607 enum MUL_MODE mode;
1608};
1609
1610static const struct mb mul_table[] = {
1611 {0x40, 0x00, MUL_REG_REG},
1612
1613 {0x47, 0x40, MUL_REG_OPR},
1614 {0x47, 0x41, MUL_REG_OPR},
1615 {0x47, 0x43, MUL_REG_OPR},
1616
1617 {0x47, 0x44, MUL_REG_IMM},
1618 {0x47, 0x45, MUL_REG_IMM},
1619 {0x47, 0x47, MUL_REG_IMM},
1620
1621 {0x43, 0x42, MUL_OPR_OPR},
1622};
1623
1624
1625static void
1626mul_decode (struct mem_read_abstraction_base *mra,
1627 int *n_operands, struct operand **operand)
1628{
1629 uint8_t mb;
1630 int status = mra->read (mra, 0, 1, &mb);
1631 if (status < 0)
1632 return;
1633
1634 uint8_t byte;
1635 status = mra->read (mra, -1, 1, &byte);
1636 if (status < 0)
1637 return;
1638
1639 enum MUL_MODE mode = -1;
1640 size_t i;
1641 for (i = 0; i < sizeof (mul_table) / sizeof (mul_table[0]); ++i)
1642 {
1643 const struct mb *mm = mul_table + i;
1644 if ((mb & mm->mask) == mm->value)
1645 {
1646 mode = mm->mode;
1647 break;
1648 }
1649 }
1650 operand[(*n_operands)++] = create_register_operand (byte & 0x07);
1651
1652 switch (mode)
1653 {
1654 case MUL_REG_IMM:
1655 {
1656 int size = (mb & 0x3);
1657 operand[(*n_operands)++] =
1658 create_register_operand_with_size ((mb & 0x38) >> 3, size);
1659 uint32_t imm = z_decode_signed_value (mra, 1, size + 1);
1660 operand[(*n_operands)++] = create_immediate_operand (imm);
1661 }
1662 break;
1663 case MUL_REG_REG:
1664 operand[(*n_operands)++] = create_register_operand ((mb & 0x38) >> 3);
1665 operand[(*n_operands)++] = create_register_operand (mb & 0x07);
1666 break;
1667 case MUL_REG_OPR:
1668 operand[(*n_operands)++] = create_register_operand ((mb & 0x38) >> 3);
1669 operand[(*n_operands)++] = x_opr_decode_with_size (mra, 1, mb & 0x3);
1670 break;
1671 case MUL_OPR_OPR:
1672 {
1673 int first = x_opr_n_bytes (mra, 1);
1674 operand[(*n_operands)++] = x_opr_decode_with_size (mra, 1,
1675 (mb & 0x30) >> 4);
1676 operand[(*n_operands)++] = x_opr_decode_with_size (mra, first + 1,
1677 (mb & 0x0c) >> 2);
1678 break;
1679 }
1680 }
1681}
1682
1683
1684static int
1685mul_n_bytes (struct mem_read_abstraction_base *mra)
1686{
1687 int nx = 2;
1688 uint8_t mb;
1689 int status = mra->read (mra, 0, 1, &mb);
1690 if (status < 0)
1691 return 0;
1692
1693 enum MUL_MODE mode = -1;
1694 size_t i;
1695 for (i = 0; i < sizeof (mul_table) / sizeof (mul_table[0]); ++i)
1696 {
1697 const struct mb *mm = mul_table + i;
1698 if ((mb & mm->mask) == mm->value)
1699 {
1700 mode = mm->mode;
1701 break;
1702 }
1703 }
1704
1705 int size = (mb & 0x3) + 1;
1706
1707 switch (mode)
1708 {
1709 case MUL_REG_IMM:
1710 nx += size;
1711 break;
1712 case MUL_REG_REG:
1713 break;
1714 case MUL_REG_OPR:
1715 nx += x_opr_n_bytes (mra, 1);
1716 break;
1717 case MUL_OPR_OPR:
1718 {
1719 int first = x_opr_n_bytes (mra, nx - 1);
1720 nx += first;
1721 int second = x_opr_n_bytes (mra, nx - 1);
1722 nx += second;
1723 }
1724 break;
1725 }
1726
1727 return nx;
1728}
1729
1730\f
1731/* The NXP documentation is vague about BM_RESERVED0 and BM_RESERVED1,
1732 and contains obvious typos.
1733 However the Freescale tools and experiments with the chip itself
1734 seem to indicate that they behave like BM_REG_IMM and BM_OPR_REG
1735 respectively. */
1736
1737enum BM_MODE
1738{
1739 BM_REG_IMM,
1740 BM_RESERVED0,
1741 BM_OPR_B,
1742 BM_OPR_W,
1743 BM_OPR_L,
1744 BM_OPR_REG,
1745 BM_RESERVED1
1746};
1747
1748struct bm
1749{
1750 uint8_t mask;
1751 uint8_t value;
1752 enum BM_MODE mode;
1753};
1754
1755static const struct bm bm_table[] = {
1756 { 0xC6, 0x04, BM_REG_IMM},
1757 { 0x84, 0x00, BM_REG_IMM},
1758 { 0x06, 0x06, BM_REG_IMM},
1759 { 0xC6, 0x44, BM_RESERVED0},
1760 // 00
1761 { 0x8F, 0x80, BM_OPR_B},
1762 { 0x8E, 0x82, BM_OPR_W},
1763 { 0x8C, 0x88, BM_OPR_L},
1764
1765 { 0x83, 0x81, BM_OPR_REG},
1766 { 0x87, 0x84, BM_RESERVED1},
1767};
1768
1769static void
1770bm_decode (struct mem_read_abstraction_base *mra,
1771 int *n_operands, struct operand **operand)
1772{
1773 uint8_t bm;
1774 int status = mra->read (mra, 0, 1, &bm);
1775 if (status < 0)
1776 return;
1777
1778 size_t i;
1779 enum BM_MODE mode = -1;
1780 for (i = 0; i < sizeof (bm_table) / sizeof (bm_table[0]); ++i)
1781 {
1782 const struct bm *bme = bm_table + i;
1783 if ((bm & bme->mask) == bme->value)
1784 {
1785 mode = bme->mode;
1786 break;
1787 }
1788 }
1789
1790 switch (mode)
1791 {
1792 case BM_REG_IMM:
1793 case BM_RESERVED0:
1794 operand[(*n_operands)++] = create_register_operand (bm & 0x07);
1795 break;
1796 case BM_OPR_B:
1797 operand[(*n_operands)++] = x_opr_decode_with_size (mra, 1, 0);
1798 break;
1799 case BM_OPR_W:
1800 operand[(*n_operands)++] = x_opr_decode_with_size (mra, 1, 1);
1801 break;
1802 case BM_OPR_L:
1803 operand[(*n_operands)++] = x_opr_decode_with_size (mra, 1, 3);
1804 break;
1805 case BM_OPR_REG:
1806 case BM_RESERVED1:
1807 {
1808 uint8_t xb;
1809 mra->read (mra, 1, 1, &xb);
1810 /* Don't emit a size suffix for register operands */
1811 if ((xb & 0xF8) != 0xB8)
1812 operand[(*n_operands)++] =
1813 x_opr_decode_with_size (mra, 1, (bm & 0x0c) >> 2);
1814 else
1815 operand[(*n_operands)++] = x_opr_decode (mra, 1);
1816 }
1817 break;
1818 }
1819
1820 uint8_t imm = 0;
1821 switch (mode)
1822 {
1823 case BM_REG_IMM:
1824 imm = (bm & 0x38) >> 3;
1825 operand[(*n_operands)++] = create_immediate_operand (imm);
1826 break;
1827 case BM_OPR_L:
1828 imm |= (bm & 0x03) << 3;
1829 /* fallthrough */
1830 case BM_OPR_W:
1831 imm |= (bm & 0x01) << 3;
1832 /* fallthrough */
1833 case BM_OPR_B:
1834 imm |= (bm & 0x70) >> 4;
1835 operand[(*n_operands)++] = create_immediate_operand (imm);
1836 break;
1837 case BM_OPR_REG:
1838 case BM_RESERVED1:
1839 operand[(*n_operands)++] = create_register_operand ((bm & 0x70) >> 4);
1840 break;
1841 case BM_RESERVED0:
1842 assert (0);
1843 break;
1844 }
1845}
1846
1847
1848static void
1849bm_rel_decode (struct mem_read_abstraction_base *mra,
1850 int *n_operands, struct operand **operand)
1851{
1852 uint8_t bm;
1853 int status = mra->read (mra, 0, 1, &bm);
1854 if (status < 0)
1855 return;
1856
1857 size_t i;
1858 enum BM_MODE mode = -1;
1859 for (i = 0; i < sizeof (bm_table) / sizeof (bm_table[0]); ++i)
1860 {
1861 const struct bm *bme = bm_table + i;
1862 if ((bm & bme->mask) == bme->value)
1863 {
1864 mode = bme->mode;
1865 break;
1866 }
1867 }
1868
1869 int n = 1;
1870 switch (mode)
1871 {
1872 case BM_REG_IMM:
1873 case BM_RESERVED0:
1874 operand[(*n_operands)++] = create_register_operand (bm & 0x07);
1875 break;
1876 case BM_OPR_B:
1877 operand[(*n_operands)++] = x_opr_decode_with_size (mra, 1, 0);
1878 n = 1 + x_opr_n_bytes (mra, 1);
1879 break;
1880 case BM_OPR_W:
1881 operand[(*n_operands)++] = x_opr_decode_with_size (mra, 1, 1);
1882 n = 1 + x_opr_n_bytes (mra, 1);
1883 break;
1884 case BM_OPR_L:
1885 operand[(*n_operands)++] = x_opr_decode_with_size (mra, 1, 3);
1886 n = 1 + x_opr_n_bytes (mra, 1);
1887 break;
1888 case BM_OPR_REG:
1889 case BM_RESERVED1:
1890 {
1891 uint8_t xb;
1892 mra->read (mra, +1, 1, &xb);
1893 /* Don't emit a size suffix for register operands */
1894 if ((xb & 0xF8) != 0xB8)
1895 {
1896 short os = (bm & 0x0c) >> 2;
1897 operand[(*n_operands)++] = x_opr_decode_with_size (mra, 1, os);
1898 }
1899 else
1900 operand[(*n_operands)++] = x_opr_decode (mra, 1);
1901
1902 }
1903 break;
1904 }
1905
1906 int imm = 0;
1907 switch (mode)
1908 {
1909 case BM_OPR_L:
1910 imm |= (bm & 0x02) << 3;
1911 /* fall through */
1912 case BM_OPR_W:
1913 imm |= (bm & 0x01) << 3;
1914 /* fall through */
1915 case BM_OPR_B:
1916 imm |= (bm & 0x70) >> 4;
1917 operand[(*n_operands)++] = create_immediate_operand (imm);
1918 break;
1919 case BM_RESERVED0:
1920 imm = (bm & 0x38) >> 3;
1921 operand[(*n_operands)++] = create_immediate_operand (imm);
1922 break;
1923 case BM_REG_IMM:
1924 imm = (bm & 0xF8) >> 3;
1925 operand[(*n_operands)++] = create_immediate_operand (imm);
1926 break;
1927 case BM_OPR_REG:
1928 case BM_RESERVED1:
1929 operand[(*n_operands)++] = create_register_operand ((bm & 0x70) >> 4);
1930 n += x_opr_n_bytes (mra, 1);
1931 break;
1932 }
1933
1934 rel_15_7 (mra, n + 1, n_operands, operand);
1935}
1936
1937static int
1938bm_n_bytes (struct mem_read_abstraction_base *mra)
1939{
1940 uint8_t bm;
1941 int status = mra->read (mra, 0, 1, &bm);
1942 if (status < 0)
1943 return status;
1944
1945 size_t i;
1946 enum BM_MODE mode = -1;
1947 for (i = 0; i < sizeof (bm_table) / sizeof (bm_table[0]); ++i)
1948 {
1949 const struct bm *bme = bm_table + i;
1950 if ((bm & bme->mask) == bme->value)
1951 {
1952 mode = bme->mode;
1953 break;
1954 }
1955 }
1956
1957 int n = 2;
1958 switch (mode)
1959 {
1960 case BM_REG_IMM:
1961 case BM_RESERVED0:
1962 break;
1963
1964 case BM_OPR_B:
1965 case BM_OPR_W:
1966 case BM_OPR_L:
1967 n += x_opr_n_bytes (mra, 1);
1968 break;
1969 case BM_OPR_REG:
1970 case BM_RESERVED1:
1971 n += x_opr_n_bytes (mra, 1);
1972 break;
1973 }
1974
1975 return n;
1976}
1977
1978static int
1979bm_rel_n_bytes (struct mem_read_abstraction_base *mra)
1980{
1981 int n = 1 + bm_n_bytes (mra);
1982
1983 bfd_byte rb;
1984 int status = mra->read (mra, n - 2, 1, &rb);
1985 if (status != 0)
1986 return status;
1987
1988 if (rb & 0x80)
1989 n++;
1990
1991 return n;
1992}
1993
1994
1995\f
1996
1997
1998/* shift direction */
1999enum SB_DIR
2000 {
2001 SB_LEFT,
2002 SB_RIGHT
2003 };
2004
2005enum SB_TYPE
2006 {
2007 SB_ARITHMETIC,
2008 SB_LOGICAL
2009 };
2010
2011
2012enum SB_MODE
2013 {
2014 SB_REG_REG_N_EFF,
2015 SB_REG_REG_N,
2016 SB_REG_OPR_EFF,
2017 SB_ROT,
2018 SB_REG_OPR_OPR,
2019 SB_OPR_N
2020 };
2021
2022struct sb
2023{
2024 uint8_t mask;
2025 uint8_t value;
2026 enum SB_MODE mode;
2027};
2028
2029static const struct sb sb_table[] = {
2030 {0x30, 0x00, SB_REG_REG_N_EFF},
2031 {0x30, 0x10, SB_REG_REG_N},
2032 {0x34, 0x20, SB_REG_OPR_EFF},
2033 {0x34, 0x24, SB_ROT},
2034 {0x34, 0x30, SB_REG_OPR_OPR},
2035 {0x34, 0x34, SB_OPR_N},
2036};
2037
2038static int
2039shift_n_bytes (struct mem_read_abstraction_base *mra)
2040{
2041 bfd_byte sb;
2042 int status = mra->read (mra, 0, 1, &sb);
2043 if (status != 0)
2044 return status;
2045
2046 size_t i;
2047 enum SB_MODE mode = -1;
2048 for (i = 0; i < sizeof (sb_table) / sizeof (sb_table[0]); ++i)
2049 {
2050 const struct sb *sbe = sb_table + i;
2051 if ((sb & sbe->mask) == sbe->value)
2052 mode = sbe->mode;
2053 }
2054
2055 switch (mode)
2056 {
2057 case SB_REG_REG_N_EFF:
2058 return 2;
2059 break;
2060 case SB_REG_OPR_EFF:
2061 case SB_ROT:
2062 return 2 + x_opr_n_bytes (mra, 1);
2063 break;
2064 case SB_REG_OPR_OPR:
2065 {
2066 int opr1 = x_opr_n_bytes (mra, 1);
2067 int opr2 = 0;
2068 if ((sb & 0x30) != 0x20)
2069 opr2 = x_opr_n_bytes (mra, opr1 + 1);
2070 return 2 + opr1 + opr2;
2071 }
2072 break;
2073 default:
2074 return 3;
2075 }
2076
2077 /* not reached */
2078 return -1;
2079}
2080\f
2081
2082static int
2083
2084mov_imm_opr_n_bytes (struct mem_read_abstraction_base *mra)
2085{
2086 bfd_byte byte;
2087 int status = mra->read (mra, -1, 1, &byte);
2088 if (status < 0)
2089 return status;
2090
2091 int size = byte - 0x0c + 1;
2092
2093 return size + x_opr_n_bytes (mra, size) + 1;
2094}
2095
2096static void
2097mov_imm_opr (struct mem_read_abstraction_base *mra,
2098 int *n_operands, struct operand **operand)
2099{
2100 bfd_byte byte;
2101 int status = mra->read (mra, -1, 1, &byte);
2102 if (status < 0)
2103 return ;
2104
2105 int size = byte - 0x0c + 1;
2106 uint32_t imm = decode_signed_value (mra, size);
2107
2108 operand[(*n_operands)++] = create_immediate_operand (imm);
2109 operand[(*n_operands)++] = x_opr_decode (mra, size);
2110}
2111
2112\f
2113
2114static void
2115ld_18bit_decode (struct mem_read_abstraction_base *mra,
2116 int *n_operands, struct operand **operand)
2117{
2118 size_t size = 3;
2119 bfd_byte buffer[3];
2120 int status = mra->read (mra, 0, 2, buffer + 1);
2121 if (status < 0)
2122 return ;
2123
2124 status = mra->read (mra, -1, 1, buffer);
2125 if (status < 0)
2126 return ;
2127
2128 buffer[0] = (buffer[0] & 0x30) >> 4;
2129
2130 size_t i;
2131 uint32_t imm = 0;
2132 for (i = 0; i < size; ++i)
2133 {
2134 imm |= buffer[i] << (8 * (size - i - 1));
2135 }
2136
2137 operand[(*n_operands)++] = create_immediate_operand (imm);
2138}
2139
2140\f
2141
2142/* Loop Primitives */
2143
2144enum LP_MODE {
2145 LP_REG,
2146 LP_XY,
2147 LP_OPR
2148};
2149
2150struct lp
2151{
2152 uint8_t mask;
2153 uint8_t value;
2154 enum LP_MODE mode;
2155};
2156
2157static const struct lp lp_mode[] = {
2158 {0x08, 0x00, LP_REG},
2159 {0x0C, 0x08, LP_XY},
2160 {0x0C, 0x0C, LP_OPR},
2161};
2162
2163
2164static int
2165loop_prim_n_bytes (struct mem_read_abstraction_base *mra)
2166{
2167 int mx = 0;
2168 uint8_t lb;
2169 mra->read (mra, mx++, 1, &lb);
2170
2171 enum LP_MODE mode = -1;
2172 size_t i;
2173 for (i = 0; i < sizeof (lp_mode) / sizeof (lp_mode[0]); ++i)
2174 {
2175 const struct lp *pb = lp_mode + i;
2176 if ((lb & pb->mask) == pb->value)
2177 {
2178 mode = pb->mode;
2179 break;
2180 }
2181 }
2182
2183 if (mode == LP_OPR)
2184 {
2185 mx += x_opr_n_bytes (mra, mx) ;
2186 }
2187
2188 uint8_t rb;
2189 mra->read (mra, mx++, 1, &rb);
2190 if (rb & 0x80)
2191 mx++;
2192
2193 return mx + 1;
2194}
2195
2196
2197\f
2198
e5a557ac
JD		 2199static enum optr
2200exg_sex_discrim (struct mem_read_abstraction_base *mra, enum optr hint ATTRIBUTE_UNUSED)
ef1ad42b
JD		 2201{
2202 uint8_t eb;
2203 int status = mra->read (mra, 0, 1, &eb);
2204 if (status < 0)
2205 return OP_INVALID;
2206
2207 struct operand *op0 = create_register_operand ((eb & 0xf0) >> 4);
2208 struct operand *op1 = create_register_operand (eb & 0xf);
2209
2210 const struct reg *r0 = registers + ((struct register_operand *) op0)->reg;
2211 const struct reg *r1 = registers + ((struct register_operand *) op1)->reg;
2212
e5a557ac 2213 enum optr operator = (r0->bytes < r1->bytes) ? OP_sex : OP_exg;
ef1ad42b
JD		 2214
2215 free (op0);
2216 free (op1);
2217
2218 return operator;
2219}
2220
2221
2222static void
2223exg_sex_decode (struct mem_read_abstraction_base *mra,
2224 int *n_operands, struct operand **operands)
2225{
2226 uint8_t eb;
2227 int status = mra->read (mra, 0, 1, &eb);
2228 if (status < 0)
2229 return;
2230
2231 /* Ship out the operands. */
2232 operands[(*n_operands)++] = create_register_operand ((eb & 0xf0) >> 4);
2233 operands[(*n_operands)++] = create_register_operand (eb & 0xf);
2234}
2235
e5a557ac 2236static enum optr
ef1ad42b 2237loop_primitive_discrim (struct mem_read_abstraction_base *mra,
e5a557ac 2238 enum optr hint ATTRIBUTE_UNUSED)
ef1ad42b
JD		 2239{
2240 uint8_t lb;
2241 int status = mra->read (mra, 0, 1, &lb);
2242 if (status < 0)
2243 return OP_INVALID;
2244
e5a557ac 2245 enum optr opbase = (lb & 0x80) ? OP_dbNE : OP_tbNE;
ef1ad42b
JD		 2246 return opbase + ((lb & 0x70) >> 4);
2247}
2248
2249static void
2250loop_primitive_decode (struct mem_read_abstraction_base *mra,
2251 int *n_operands, struct operand **operands)
2252{
2253 int offs = 1;
2254 uint8_t lb;
2255 int status = mra->read (mra, 0, 1, &lb);
2256 if (status < 0)
2257 return ;
2258
2259 enum LP_MODE mode = -1;
2260 size_t i;
2261 for (i = 0; i < sizeof (lp_mode) / sizeof (lp_mode[0]); ++i)
2262 {
2263 const struct lp *pb = lp_mode + i;
2264 if ((lb & pb->mask) == pb->value)
2265 {
2266 mode = pb->mode;
2267 break;
2268 }
2269 }
2270
2271 switch (mode)
2272 {
2273 case LP_REG:
2274 operands[(*n_operands)++] = create_register_operand (lb & 0x07);
2275 break;
2276 case LP_XY:
2277 operands[(*n_operands)++] =
2278 create_register_operand ((lb & 0x01) + REG_X);
2279 break;
2280 case LP_OPR:
2281 offs += x_opr_n_bytes (mra, 1);
2282 operands[(*n_operands)++] = x_opr_decode_with_size (mra, 1, lb & 0x03);
2283 break;
2284 }
2285
2286 rel_15_7 (mra, offs + 1, n_operands, operands);
2287}
2288
2289
e5a557ac
JD		 2290static enum optr
2291shift_discrim (struct mem_read_abstraction_base *mra, enum optr hint ATTRIBUTE_UNUSED)
ef1ad42b
JD		 2292{
2293 size_t i;
2294 uint8_t sb;
2295 int status = mra->read (mra, 0, 1, &sb);
2296 if (status < 0)
2297 return status;
2298
2299 enum SB_DIR dir = (sb & 0x40) ? SB_LEFT : SB_RIGHT;
2300 enum SB_TYPE type = (sb & 0x80) ? SB_ARITHMETIC : SB_LOGICAL;
2301 enum SB_MODE mode = -1;
2302 for (i = 0; i < sizeof (sb_table) / sizeof (sb_table[0]); ++i)
2303 {
2304 const struct sb *sbe = sb_table + i;
2305 if ((sb & sbe->mask) == sbe->value)
2306 mode = sbe->mode;
2307 }
2308
2309 if (mode == SB_ROT)
2310 return (dir == SB_LEFT) ? OP_rol : OP_ror;
2311
2312 if (type == SB_LOGICAL)
2313 return (dir == SB_LEFT) ? OP_lsl : OP_lsr;
2314
2315 return (dir == SB_LEFT) ? OP_asl : OP_asr;
2316}
2317
2318
2319static void
2320shift_decode (struct mem_read_abstraction_base *mra, int *n_operands, struct operand **operands)
2321{
2322 size_t i;
2323
2324 uint8_t byte;
2325 int status = mra->read (mra, -1, 1, &byte);
2326 if (status < 0)
2327 return ;
2328
2329 uint8_t sb;
2330 status = mra->read (mra, 0, 1, &sb);
2331 if (status < 0)
2332 return ;
2333
2334 enum SB_MODE mode = -1;
2335 for (i = 0; i < sizeof (sb_table) / sizeof (sb_table[0]); ++i)
2336 {
2337 const struct sb *sbe = sb_table + i;
2338 if ((sb & sbe->mask) == sbe->value)
2339 mode = sbe->mode;
2340 }
2341
2342 short osize = -1;
2343 switch (mode)
2344 {
2345 case SB_REG_OPR_EFF:
2346 case SB_ROT:
2347 case SB_REG_OPR_OPR:
2348 osize = sb & 0x03;
2349 break;
2350 case SB_OPR_N:
2351 {
2352 uint8_t xb;
2353 mra->read (mra, 1, 1, &xb);
2354 /* The size suffix is not printed if the OPR operand refers
2355 directly to a register, because the size is implied by the
2356 size of that register. */
2357 if ((xb & 0xF8) != 0xB8)
2358 osize = sb & 0x03;
2359 }
2360 break;
2361 default:
2362 break;
2363 };
2364
2365 /* Destination register */
2366 switch (mode)
2367 {
2368 case SB_REG_REG_N_EFF:
2369 case SB_REG_REG_N:
2370 operands[(*n_operands)++] = create_register_operand (byte & 0x07);
2371 break;
2372 case SB_REG_OPR_EFF:
2373 case SB_REG_OPR_OPR:
2374 operands[(*n_operands)++] = create_register_operand (byte & 0x07);
2375 break;
2376
2377 case SB_ROT:
2378 operands[(*n_operands)++] = x_opr_decode_with_size (mra, 1, osize);
2379 break;
2380
2381 default:
2382 break;
2383 }
2384
2385 /* Source register */
2386 switch (mode)
2387 {
2388 case SB_REG_REG_N_EFF:
2389 case SB_REG_REG_N:
2390 operands[(*n_operands)++] =
2391 create_register_operand_with_size (sb & 0x07, osize);
2392 break;
2393
2394 case SB_REG_OPR_OPR:
2395 operands[(*n_operands)++] = x_opr_decode_with_size (mra, 1, osize);
2396 break;
2397
2398 default:
2399 break;
2400 }
2401
2402 /* 3rd arg */
2403 switch (mode)
2404 {
2405 case SB_REG_OPR_EFF:
2406 case SB_OPR_N:
2407 operands[(*n_operands)++] = x_opr_decode_with_size (mra, 1, osize);
2408 break;
2409
2410 case SB_REG_REG_N:
2411 {
2412 uint8_t xb;
2413 mra->read (mra, 1, 1, &xb);
2414
2415 /* This case is slightly unusual.
2416 If XB matches the binary pattern 0111XXXX, then instead of
2417 interpreting this as a general OPR postbyte in the IMMe4 mode,
2418 the XB byte is interpreted in s special way. */
2419 if ((xb & 0xF0) == 0x70)
2420 {
2421 if (byte & 0x10)
2422 {
2423 int shift = ((sb & 0x08) >> 3) | ((xb & 0x0f) << 1);
2424 operands[(*n_operands)++] = create_immediate_operand (shift);
2425 }
2426 else
2427 {
2428 /* This should not happen. */
2429 abort ();
2430 }
2431 }
2432 else
2433 {
2434 operands[(*n_operands)++] = x_opr_decode (mra, 1);
2435 }
2436 }
2437 break;
2438 case SB_REG_OPR_OPR:
2439 {
2440 uint8_t xb;
2441 int n = x_opr_n_bytes (mra, 1);
2442 mra->read (mra, 1 + n, 1, &xb);
2443
2444 if ((xb & 0xF0) == 0x70)
2445 {
2446 int imm = xb & 0x0F;
2447 imm <<= 1;
2448 imm |= (sb & 0x08) >> 3;
2449 operands[(*n_operands)++] = create_immediate_operand (imm);
2450 }
2451 else
2452 {
2453 operands[(*n_operands)++] = x_opr_decode (mra, 1 + n);
2454 }
2455 }
2456 break;
2457 default:
2458 break;
2459 }
2460
2461 switch (mode)
2462 {
2463 case SB_REG_REG_N_EFF:
2464 case SB_REG_OPR_EFF:
2465 case SB_OPR_N:
2466 {
2467 int imm = (sb & 0x08) ? 2 : 1;
2468 operands[(*n_operands)++] = create_immediate_operand (imm);
2469 }
2470 break;
2471
2472 default:
2473 break;
2474 }
2475}
2476
e5a557ac 2477static enum optr
ef1ad42b 2478psh_pul_discrim (struct mem_read_abstraction_base *mra,
e5a557ac 2479 enum optr hint ATTRIBUTE_UNUSED)
ef1ad42b
JD		 2480{
2481 uint8_t byte;
2482 int status = mra->read (mra, 0, 1, &byte);
2483 if (status != 0)
2484 return OP_INVALID;
2485
2486 return (byte & 0x80) ? OP_pull: OP_push;
2487}
2488
2489
2490static void
2491psh_pul_decode (struct mem_read_abstraction_base *mra,
2492 int *n_operands, struct operand **operand)
2493{
2494 uint8_t byte;
2495 int status = mra->read (mra, 0, 1, &byte);
2496 if (status != 0)
2497 return;
2498 int bit;
2499 if (byte & 0x40)
2500 {
2501 if ((byte & 0x3F) == 0)
2502 {
2503 operand[(*n_operands)++] = create_register_all16_operand ();
2504 }
2505 else
2506 for (bit = 5; bit >= 0; --bit)
2507 {
2508 if (byte & (0x1 << bit))
2509 {
2510 operand[(*n_operands)++] = create_register_operand (oprregs2[bit]);
2511 }
2512 }
2513 }
2514 else
2515 {
2516 if ((byte & 0x3F) == 0)
2517 {
2518 operand[(*n_operands)++] = create_register_all_operand ();
2519 }
2520 else
2521 for (bit = 5; bit >= 0; --bit)
2522 {
2523 if (byte & (0x1 << bit))
2524 {
2525 operand[(*n_operands)++] = create_register_operand (oprregs1[bit]);
2526 }
2527 }
2528 }
2529}
2530
e5a557ac
JD		 2531static enum optr
2532bit_field_discrim (struct mem_read_abstraction_base *mra, enum optr hint ATTRIBUTE_UNUSED)
ef1ad42b
JD		 2533{
2534 int status;
2535 bfd_byte bb;
2536 status = mra->read (mra, 0, 1, &bb);
2537 if (status != 0)
2538 return OP_INVALID;
2539
2540 return (bb & 0x80) ? OP_bfins : OP_bfext;
2541}
2542
2543static void
2544bit_field_decode (struct mem_read_abstraction_base *mra,
2545 int *n_operands, struct operand **operands)
2546{
2547 int status;
2548
2549 bfd_byte byte2;
2550 status = mra->read (mra, -1, 1, &byte2);
2551 if (status != 0)
2552 return;
2553
2554 bfd_byte bb;
2555 status = mra->read (mra, 0, 1, &bb);
2556 if (status != 0)
2557 return;
2558
2559 enum BB_MODE mode = -1;
2560 size_t i;
2561 const struct opr_bb *bbs = 0;
2562 for (i = 0; i < sizeof (bb_modes) / sizeof (bb_modes[0]); ++i)
2563 {
2564 bbs = bb_modes + i;
2565 if ((bb & bbs->mask) == bbs->value)
2566 {
2567 mode = bbs->mode;
2568 break;
2569 }
2570 }
2571 int reg1 = byte2 & 0x07;
2572 /* First operand */
2573 switch (mode)
2574 {
2575 case BB_REG_REG_REG:
2576 case BB_REG_REG_IMM:
2577 case BB_REG_OPR_REG:
2578 case BB_REG_OPR_IMM:
2579 operands[(*n_operands)++] = create_register_operand (reg1);
2580 break;
2581 case BB_OPR_REG_REG:
2582 operands[(*n_operands)++] = x_opr_decode_with_size (mra, 1,
2583 (bb >> 2) & 0x03);
2584 break;
2585 case BB_OPR_REG_IMM:
2586 operands[(*n_operands)++] = x_opr_decode_with_size (mra, 2,
2587 (bb >> 2) & 0x03);
2588 break;
2589 }
2590
2591 /* Second operand */
2592 switch (mode)
2593 {
2594 case BB_REG_REG_REG:
2595 case BB_REG_REG_IMM:
2596 {
2597 int reg_src = (bb >> 2) & 0x07;
2598 operands[(*n_operands)++] = create_register_operand (reg_src);
2599 }
2600 break;
2601 case BB_OPR_REG_REG:
2602 case BB_OPR_REG_IMM:
2603 {
2604 int reg_src = (byte2 & 0x07);
2605 operands[(*n_operands)++] = create_register_operand (reg_src);
2606 }
2607 break;
2608 case BB_REG_OPR_REG:
2609 operands[(*n_operands)++] = x_opr_decode_with_size (mra, 1,
2610 (bb >> 2) & 0x03);
2611 break;
2612 case BB_REG_OPR_IMM:
2613 operands[(*n_operands)++] = x_opr_decode_with_size (mra, 2,
2614 (bb >> 2) & 0x03);
2615 break;
2616 }
2617
2618 /* Third operand */
2619 switch (mode)
2620 {
2621 case BB_REG_REG_REG:
2622 case BB_OPR_REG_REG:
2623 case BB_REG_OPR_REG:
2624 {
2625 int reg_parm = bb & 0x03;
2626 operands[(*n_operands)++] = create_register_operand (reg_parm);
2627 }
2628 break;
2629 case BB_REG_REG_IMM:
2630 case BB_OPR_REG_IMM:
2631 case BB_REG_OPR_IMM:
2632 {
2633 bfd_byte i1;
2634 mra->read (mra, 1, 1, &i1);
2635 int offset = i1 & 0x1f;
2636 int width = bb & 0x03;
2637 width <<= 3;
2638 width |= i1 >> 5;
2639 operands[(*n_operands)++] = create_bitfield_operand (width, offset);
2640 }
2641 break;
2642 }
2643}
2644
2645
2646/* Decode the next instruction at MRA, according to OPC.
2647 The operation to be performed is returned.
2648 The number of operands, will be placed in N_OPERANDS.
2649 The operands themselved into OPERANDS. */
e5a557ac 2650static enum optr
ef1ad42b
JD		 2651decode_operation (const struct opcode *opc,
2652 struct mem_read_abstraction_base *mra,
2653 int *n_operands, struct operand **operands)
2654{
e5a557ac 2655 enum optr op = opc->operator;
ef1ad42b
JD		 2656 if (opc->discriminator)
2657 op = opc->discriminator (mra, opc->operator);
2658
2659 if (opc->operands)
2660 opc->operands (mra, n_operands, operands);
2661
2662 if (opc->operands2)
2663 opc->operands2 (mra, n_operands, operands);
2664
2665 return op;
2666}
2667
2668int
e5a557ac 2669decode_s12z (enum optr *myoperator, short *osize,
ef1ad42b
JD		 2670 int *n_operands, struct operand **operands,
2671 struct mem_read_abstraction_base *mra)
2672{
2673 int n_bytes = 0;
2674 bfd_byte byte;
2675
2676 int status = mra->read (mra, 0, 1, &byte);
2677 if (status != 0)
2678 return status;
2679
2680 mra->advance (mra);
2681
2682 const struct opcode *opc = page1 + byte;
2683 if (byte == PAGE2_PREBYTE)
2684 {
2685 /* Opcodes in page2 have an additional byte */
2686 n_bytes++;
2687
2688 bfd_byte byte2;
2689 mra->read (mra, 0, 1, &byte2);
2690 mra->advance (mra);
2691 opc = page2 + byte2;
2692 }
2693 *myoperator = decode_operation (opc, mra, n_operands, operands);
2694 *osize = opc->osize;
2695
2696 /* Return the number of bytes in the instruction. */
2697 n_bytes += (opc && opc->insn_bytes) ? opc->insn_bytes (mra) : 0;
2698
2699 return n_bytes;
2700}
2701
A mirror of the official binutils-gdb repository