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