]> Git Repo - binutils.git/blob - opcodes/s12z-opc.c
Automatic date update in version.in
[binutils.git] / opcodes / s12z-opc.c
1 /* s12z-decode.c -- Freescale S12Z disassembly
2    Copyright (C) 2018-2022 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
This page took 0.198944 seconds and 4 git commands to generate.