Change source files over to GPLv3.
[external/binutils.git] / opcodes / m10300-dis.c
1 /* Disassemble MN10300 instructions.
2    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2005, 2007
3    Free Software Foundation, Inc.
4
5    This file is part of the GNU opcodes library.
6
7    This library is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3, or (at your option)
10    any later version.
11
12    It is distributed in the hope that it will be useful, but WITHOUT
13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
15    License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21
22 #include <stdio.h>
23
24 #include "sysdep.h"
25 #include "opcode/mn10300.h"
26 #include "dis-asm.h"
27 #include "opintl.h"
28
29 #define HAVE_AM33_2 (info->mach == AM33_2)
30 #define HAVE_AM33   (info->mach == AM33 || HAVE_AM33_2)
31 #define HAVE_AM30   (info->mach == AM30)
32
33 static void
34 disassemble (bfd_vma memaddr,
35              struct disassemble_info *info,
36              unsigned long insn,
37              unsigned int size)
38 {
39   struct mn10300_opcode *op = (struct mn10300_opcode *) mn10300_opcodes;
40   const struct mn10300_operand *operand;
41   bfd_byte buffer[4];
42   unsigned long extension = 0;
43   int status, match = 0;
44
45   /* Find the opcode.  */
46   while (op->name)
47     {
48       int mysize, extra_shift;
49
50       if (op->format == FMT_S0)
51         mysize = 1;
52       else if (op->format == FMT_S1
53                || op->format == FMT_D0)
54         mysize = 2;
55       else if (op->format == FMT_S2
56                || op->format == FMT_D1)
57         mysize = 3;
58       else if (op->format == FMT_S4)
59         mysize = 5;
60       else if (op->format == FMT_D2)
61         mysize = 4;
62       else if (op->format == FMT_D3)
63         mysize = 5;
64       else if (op->format == FMT_D4)
65         mysize = 6;
66       else if (op->format == FMT_D6)
67         mysize = 3;
68       else if (op->format == FMT_D7 || op->format == FMT_D10)
69         mysize = 4;
70       else if (op->format == FMT_D8)
71         mysize = 6;
72       else if (op->format == FMT_D9)
73         mysize = 7;
74       else
75         mysize = 7;
76
77       if ((op->mask & insn) == op->opcode
78           && size == (unsigned int) mysize
79           && (op->machine == 0
80               || (op->machine == AM33_2 && HAVE_AM33_2)
81               || (op->machine == AM33 && HAVE_AM33)
82               || (op->machine == AM30 && HAVE_AM30)))
83         {
84           const unsigned char *opindex_ptr;
85           unsigned int nocomma;
86           int paren = 0;
87
88           if (op->format == FMT_D1 || op->format == FMT_S1)
89             extra_shift = 8;
90           else if (op->format == FMT_D2 || op->format == FMT_D4
91                    || op->format == FMT_S2 || op->format == FMT_S4
92                    || op->format == FMT_S6 || op->format == FMT_D5)
93             extra_shift = 16;
94           else if (op->format == FMT_D7
95                    || op->format == FMT_D8
96                    || op->format == FMT_D9)
97             extra_shift = 8;
98           else
99             extra_shift = 0;
100
101           if (size == 1 || size == 2)
102             extension = 0;
103
104           else if (size == 3
105                    && (op->format == FMT_D1
106                        || op->opcode == 0xdf0000
107                        || op->opcode == 0xde0000))
108             extension = 0;
109
110           else if (size == 3
111                    && op->format == FMT_D6)
112             extension = 0;
113
114           else if (size == 3)
115             {
116               insn &= 0xff0000;
117               status = (*info->read_memory_func) (memaddr + 1, buffer, 2, info);
118               if (status != 0)
119                 {
120                   (*info->memory_error_func) (status, memaddr, info);
121                   return;
122                 }
123
124               insn |= bfd_getl16 (buffer);
125               extension = 0;
126             }
127           else if (size == 4
128                    && (op->opcode == 0xfaf80000
129                        || op->opcode == 0xfaf00000
130                        || op->opcode == 0xfaf40000))
131             extension = 0;
132
133           else if (size == 4
134                    && (op->format == FMT_D7
135                        || op->format == FMT_D10))
136             extension = 0;
137
138           else if (size == 4)
139             {
140               insn &= 0xffff0000;
141               status = (*info->read_memory_func) (memaddr + 2, buffer, 2, info);
142               if (status != 0)
143                 {
144                   (*info->memory_error_func) (status, memaddr, info);
145                   return;
146                 }
147
148               insn |= bfd_getl16 (buffer);
149               extension = 0;
150             }
151           else if (size == 5 && op->opcode == 0xdc000000)
152             {
153               unsigned long temp = 0;
154
155               status = (*info->read_memory_func) (memaddr + 1, buffer, 4, info);
156               if (status != 0)
157                 {
158                   (*info->memory_error_func) (status, memaddr, info);
159                   return;
160                 }
161               temp |= bfd_getl32 (buffer);
162
163               insn &= 0xff000000;
164               insn |= (temp & 0xffffff00) >> 8;
165               extension = temp & 0xff;
166             }
167           else if (size == 5 && op->format == FMT_D3)
168             {
169               status = (*info->read_memory_func) (memaddr + 2, buffer, 2, info);
170               if (status != 0)
171                 {
172                   (*info->memory_error_func) (status, memaddr, info);
173                   return;
174                 }
175               insn &= 0xffff0000;
176               insn |= bfd_getl16 (buffer);
177
178               status = (*info->read_memory_func) (memaddr + 4, buffer, 1, info);
179               if (status != 0)
180                 {
181                   (*info->memory_error_func) (status, memaddr, info);
182                   return;
183                 }
184               extension = *(unsigned char *) buffer;
185             }
186           else if (size == 5)
187             {
188               unsigned long temp = 0;
189
190               status = (*info->read_memory_func) (memaddr + 1, buffer, 2, info);
191               if (status != 0)
192                 {
193                   (*info->memory_error_func) (status, memaddr, info);
194                   return;
195                 }
196               temp |= bfd_getl16 (buffer);
197
198               insn &= 0xff0000ff;
199               insn |= temp << 8;
200
201               status = (*info->read_memory_func) (memaddr + 4, buffer, 1, info);
202               if (status != 0)
203                 {
204                   (*info->memory_error_func) (status, memaddr, info);
205                   return;
206                 }
207               extension = *(unsigned char *) buffer;
208             }
209           else if (size == 6 && op->format == FMT_D8)
210             {
211               insn &= 0xffffff00;
212               status = (*info->read_memory_func) (memaddr + 5, buffer, 1, info);
213               if (status != 0)
214                 {
215                   (*info->memory_error_func) (status, memaddr, info);
216                   return;
217                 }
218               insn |= *(unsigned char *) buffer;
219
220               status = (*info->read_memory_func) (memaddr + 3, buffer, 2, info);
221               if (status != 0)
222                 {
223                   (*info->memory_error_func) (status, memaddr, info);
224                   return;
225                 }
226               extension = bfd_getl16 (buffer);
227             }
228           else if (size == 6)
229             {
230               unsigned long temp = 0;
231
232               status = (*info->read_memory_func) (memaddr + 2, buffer, 4, info);
233               if (status != 0)
234                 {
235                   (*info->memory_error_func) (status, memaddr, info);
236                   return;
237                 }
238               temp |= bfd_getl32 (buffer);
239
240               insn &= 0xffff0000;
241               insn |= (temp >> 16) & 0xffff;
242               extension = temp & 0xffff;
243             }
244           else if (size == 7 && op->format == FMT_D9)
245             {
246               insn &= 0xffffff00;
247               status = (*info->read_memory_func) (memaddr + 3, buffer, 4, info);
248               if (status != 0)
249                 {
250                   (*info->memory_error_func) (status, memaddr, info);
251                   return;
252                 }
253               extension = bfd_getl32 (buffer);
254               insn |= (extension & 0xff000000) >> 24;
255               extension &= 0xffffff;
256             }
257           else if (size == 7 && op->opcode == 0xdd000000)
258             {
259               unsigned long temp = 0;
260
261               status = (*info->read_memory_func) (memaddr + 1, buffer, 4, info);
262               if (status != 0)
263                 {
264                   (*info->memory_error_func) (status, memaddr, info);
265                   return;
266                 }
267               temp |= bfd_getl32 (buffer);
268
269               insn &= 0xff000000;
270               insn |= (temp >> 8) & 0xffffff;
271               extension = (temp & 0xff) << 16;
272
273               status = (*info->read_memory_func) (memaddr + 5, buffer, 2, info);
274               if (status != 0)
275                 {
276                   (*info->memory_error_func) (status, memaddr, info);
277                   return;
278                 }
279               extension |= bfd_getb16 (buffer);
280             }
281           else if (size == 7)
282             {
283               unsigned long temp = 0;
284
285               status = (*info->read_memory_func) (memaddr + 2, buffer, 4, info);
286               if (status != 0)
287                 {
288                   (*info->memory_error_func) (status, memaddr, info);
289                   return;
290                 }
291               temp |= bfd_getl32 (buffer);
292
293               insn &= 0xffff0000;
294               insn |= (temp >> 16) & 0xffff;
295               extension = (temp & 0xffff) << 8;
296
297               status = (*info->read_memory_func) (memaddr + 6, buffer, 1, info);
298               if (status != 0)
299                 {
300                   (*info->memory_error_func) (status, memaddr, info);
301                   return;
302                 }
303               extension |= *(unsigned char *) buffer;
304             }
305
306           match = 1;
307           (*info->fprintf_func) (info->stream, "%s\t", op->name);
308
309           /* Now print the operands.  */
310           for (opindex_ptr = op->operands, nocomma = 1;
311                *opindex_ptr != 0;
312                opindex_ptr++)
313             {
314               unsigned long value;
315
316               operand = &mn10300_operands[*opindex_ptr];
317
318               /* If this operand is a PLUS (autoincrement), then do not emit
319                  a comma before emitting the plus.  */
320               if ((operand->flags & MN10300_OPERAND_PLUS) != 0)
321                 nocomma = 1;
322
323               if ((operand->flags & MN10300_OPERAND_SPLIT) != 0)
324                 {
325                   unsigned long temp;
326
327                   value = insn & ((1 << operand->bits) - 1);
328                   value <<= (32 - operand->bits);
329                   temp = extension >> operand->shift;
330                   temp &= ((1 << (32 - operand->bits)) - 1);
331                   value |= temp;
332                   value = ((value ^ (((unsigned long) 1) << 31))
333                            - (((unsigned long) 1) << 31));
334                 }
335               else if ((operand->flags & MN10300_OPERAND_24BIT) != 0)
336                 {
337                   unsigned long temp;
338
339                   value = insn & ((1 << operand->bits) - 1);
340                   value <<= (24 - operand->bits);
341                   temp = extension >> operand->shift;
342                   temp &= ((1 << (24 - operand->bits)) - 1);
343                   value |= temp;
344                   if ((operand->flags & MN10300_OPERAND_SIGNED) != 0)
345                     value = ((value & 0xffffff) ^ 0x800000) - 0x800000;
346                 }
347               else if ((operand->flags & (MN10300_OPERAND_FSREG
348                                           | MN10300_OPERAND_FDREG)))
349                 {
350                   /* See m10300-opc.c just before #define FSM0 for an
351                      explanation of these variables.  Note that
352                      FMT-implied shifts are not taken into account for
353                      FP registers.  */
354                   unsigned long mask_low, mask_high;
355                   int shl_low, shr_high, shl_high;
356
357                   switch (operand->bits)
358                     {
359                     case 5:
360                       /* Handle regular FP registers.  */
361                       if (operand->shift >= 0)
362                         {
363                           /* This is an `m' register.  */
364                           shl_low = operand->shift;
365                           shl_high = 8 + (8 & shl_low) + (shl_low & 4) / 4;
366                         }
367                       else
368                         {
369                           /* This is an `n' register.  */
370                           shl_low = -operand->shift;
371                           shl_high = shl_low / 4;
372                         }
373                       mask_low = 0x0f;
374                       mask_high = 0x10;
375                       shr_high = 4;
376                       break;
377
378                     case 3:
379                       /* Handle accumulators.  */
380                       shl_low = -operand->shift;
381                       shl_high = 0;
382                       mask_low = 0x03;
383                       mask_high = 0x04;
384                       shr_high = 2;
385                       break;
386
387                     default:
388                       abort ();
389                     }
390                   value = ((((insn >> shl_high) << shr_high) & mask_high)
391                            | ((insn >> shl_low) & mask_low));
392                 }
393               else if ((operand->flags & MN10300_OPERAND_EXTENDED) != 0)
394                 value = ((extension >> (operand->shift))
395                          & ((1 << operand->bits) - 1));
396
397               else
398                 value = ((insn >> (operand->shift))
399                          & ((1 << operand->bits) - 1));
400
401               if ((operand->flags & MN10300_OPERAND_SIGNED) != 0
402                   /* These are properly extended by the code above.  */
403                   && ((operand->flags & MN10300_OPERAND_24BIT) == 0))
404                 value = ((value ^ (((unsigned long) 1) << (operand->bits - 1)))
405                          - (((unsigned long) 1) << (operand->bits - 1)));
406
407               if (!nocomma
408                   && (!paren
409                       || ((operand->flags & MN10300_OPERAND_PAREN) == 0)))
410                 (*info->fprintf_func) (info->stream, ",");
411
412               nocomma = 0;
413
414               if ((operand->flags & MN10300_OPERAND_DREG) != 0)
415                 {
416                   value = ((insn >> (operand->shift + extra_shift))
417                            & ((1 << operand->bits) - 1));
418                   (*info->fprintf_func) (info->stream, "d%d", (int) value);
419                 }
420
421               else if ((operand->flags & MN10300_OPERAND_AREG) != 0)
422                 {
423                   value = ((insn >> (operand->shift + extra_shift))
424                            & ((1 << operand->bits) - 1));
425                   (*info->fprintf_func) (info->stream, "a%d", (int) value);
426                 }
427
428               else if ((operand->flags & MN10300_OPERAND_SP) != 0)
429                 (*info->fprintf_func) (info->stream, "sp");
430
431               else if ((operand->flags & MN10300_OPERAND_PSW) != 0)
432                 (*info->fprintf_func) (info->stream, "psw");
433
434               else if ((operand->flags & MN10300_OPERAND_MDR) != 0)
435                 (*info->fprintf_func) (info->stream, "mdr");
436
437               else if ((operand->flags & MN10300_OPERAND_RREG) != 0)
438                 {
439                   value = ((insn >> (operand->shift + extra_shift))
440                            & ((1 << operand->bits) - 1));
441                   if (value < 8)
442                     (*info->fprintf_func) (info->stream, "r%d", (int) value);
443                   else if (value < 12)
444                     (*info->fprintf_func) (info->stream, "a%d", (int) value - 8);
445                   else
446                     (*info->fprintf_func) (info->stream, "d%d", (int) value - 12);
447                 }
448
449               else if ((operand->flags & MN10300_OPERAND_XRREG) != 0)
450                 {
451                   value = ((insn >> (operand->shift + extra_shift))
452                            & ((1 << operand->bits) - 1));
453                   if (value == 0)
454                     (*info->fprintf_func) (info->stream, "sp");
455                   else
456                     (*info->fprintf_func) (info->stream, "xr%d", (int) value);
457                 }
458
459               else if ((operand->flags & MN10300_OPERAND_FSREG) != 0)
460                 (*info->fprintf_func) (info->stream, "fs%d", (int) value);
461
462               else if ((operand->flags & MN10300_OPERAND_FDREG) != 0)
463                 (*info->fprintf_func) (info->stream, "fd%d", (int) value);
464
465               else if ((operand->flags & MN10300_OPERAND_FPCR) != 0)
466                 (*info->fprintf_func) (info->stream, "fpcr");
467
468               else if ((operand->flags & MN10300_OPERAND_USP) != 0)
469                 (*info->fprintf_func) (info->stream, "usp");
470
471               else if ((operand->flags & MN10300_OPERAND_SSP) != 0)
472                 (*info->fprintf_func) (info->stream, "ssp");
473
474               else if ((operand->flags & MN10300_OPERAND_MSP) != 0)
475                 (*info->fprintf_func) (info->stream, "msp");
476
477               else if ((operand->flags & MN10300_OPERAND_PC) != 0)
478                 (*info->fprintf_func) (info->stream, "pc");
479
480               else if ((operand->flags & MN10300_OPERAND_EPSW) != 0)
481                 (*info->fprintf_func) (info->stream, "epsw");
482
483               else if ((operand->flags & MN10300_OPERAND_PLUS) != 0)
484                 (*info->fprintf_func) (info->stream, "+");
485
486               else if ((operand->flags & MN10300_OPERAND_PAREN) != 0)
487                 {
488                   if (paren)
489                     (*info->fprintf_func) (info->stream, ")");
490                   else
491                     {
492                       (*info->fprintf_func) (info->stream, "(");
493                       nocomma = 1;
494                     }
495                   paren = !paren;
496                 }
497
498               else if ((operand->flags & MN10300_OPERAND_PCREL) != 0)
499                 (*info->print_address_func) ((long) value + memaddr, info);
500
501               else if ((operand->flags & MN10300_OPERAND_MEMADDR) != 0)
502                 (*info->print_address_func) (value, info);
503
504               else if ((operand->flags & MN10300_OPERAND_REG_LIST) != 0)
505                 {
506                   int comma = 0;
507
508                   (*info->fprintf_func) (info->stream, "[");
509                   if (value & 0x80)
510                     {
511                       (*info->fprintf_func) (info->stream, "d2");
512                       comma = 1;
513                     }
514
515                   if (value & 0x40)
516                     {
517                       if (comma)
518                         (*info->fprintf_func) (info->stream, ",");
519                       (*info->fprintf_func) (info->stream, "d3");
520                       comma = 1;
521                     }
522
523                   if (value & 0x20)
524                     {
525                       if (comma)
526                         (*info->fprintf_func) (info->stream, ",");
527                       (*info->fprintf_func) (info->stream, "a2");
528                       comma = 1;
529                     }
530
531                   if (value & 0x10)
532                     {
533                       if (comma)
534                         (*info->fprintf_func) (info->stream, ",");
535                       (*info->fprintf_func) (info->stream, "a3");
536                       comma = 1;
537                     }
538
539                   if (value & 0x08)
540                     {
541                       if (comma)
542                         (*info->fprintf_func) (info->stream, ",");
543                       (*info->fprintf_func) (info->stream, "other");
544                       comma = 1;
545                     }
546
547                   if (value & 0x04)
548                     {
549                       if (comma)
550                         (*info->fprintf_func) (info->stream, ",");
551                       (*info->fprintf_func) (info->stream, "exreg0");
552                       comma = 1;
553                     }
554                   if (value & 0x02)
555                     {
556                       if (comma)
557                         (*info->fprintf_func) (info->stream, ",");
558                       (*info->fprintf_func) (info->stream, "exreg1");
559                       comma = 1;
560                     }
561                   if (value & 0x01)
562                     {
563                       if (comma)
564                         (*info->fprintf_func) (info->stream, ",");
565                       (*info->fprintf_func) (info->stream, "exother");
566                       comma = 1;
567                     }
568                   (*info->fprintf_func) (info->stream, "]");
569                 }
570
571               else
572                 (*info->fprintf_func) (info->stream, "%ld", (long) value);
573             }
574           /* All done. */
575           break;
576         }
577       op++;
578     }
579
580   if (!match)
581     /* xgettext:c-format */
582     (*info->fprintf_func) (info->stream, _("unknown\t0x%04lx"), insn);
583 }
584
585 int
586 print_insn_mn10300 (bfd_vma memaddr, struct disassemble_info *info)
587 {
588   int status;
589   bfd_byte buffer[4];
590   unsigned long insn;
591   unsigned int consume;
592
593   /* First figure out how big the opcode is.  */
594   status = (*info->read_memory_func) (memaddr, buffer, 1, info);
595   if (status != 0)
596     {
597       (*info->memory_error_func) (status, memaddr, info);
598       return -1;
599     }
600   insn = *(unsigned char *) buffer;
601
602   /* These are one byte insns.  */
603   if ((insn & 0xf3) == 0x00
604       || (insn & 0xf0) == 0x10
605       || (insn & 0xfc) == 0x3c
606       || (insn & 0xf3) == 0x41
607       || (insn & 0xf3) == 0x40
608       || (insn & 0xfc) == 0x50
609       || (insn & 0xfc) == 0x54
610       || (insn & 0xf0) == 0x60
611       || (insn & 0xf0) == 0x70
612       || ((insn & 0xf0) == 0x80
613           && (insn & 0x0c) >> 2 != (insn & 0x03))
614       || ((insn & 0xf0) == 0x90
615           && (insn & 0x0c) >> 2 != (insn & 0x03))
616       || ((insn & 0xf0) == 0xa0
617           && (insn & 0x0c) >> 2 != (insn & 0x03))
618       || ((insn & 0xf0) == 0xb0
619           && (insn & 0x0c) >> 2 != (insn & 0x03))
620       || (insn & 0xff) == 0xcb
621       || (insn & 0xfc) == 0xd0
622       || (insn & 0xfc) == 0xd4
623       || (insn & 0xfc) == 0xd8
624       || (insn & 0xf0) == 0xe0
625       || (insn & 0xff) == 0xff)
626     {
627       consume = 1;
628     }
629
630   /* These are two byte insns.  */
631   else if ((insn & 0xf0) == 0x80
632            || (insn & 0xf0) == 0x90
633            || (insn & 0xf0) == 0xa0
634            || (insn & 0xf0) == 0xb0
635            || (insn & 0xfc) == 0x20
636            || (insn & 0xfc) == 0x28
637            || (insn & 0xf3) == 0x43
638            || (insn & 0xf3) == 0x42
639            || (insn & 0xfc) == 0x58
640            || (insn & 0xfc) == 0x5c
641            || ((insn & 0xf0) == 0xc0
642                && (insn & 0xff) != 0xcb
643                && (insn & 0xff) != 0xcc
644                && (insn & 0xff) != 0xcd)
645            || (insn & 0xff) == 0xf0
646            || (insn & 0xff) == 0xf1
647            || (insn & 0xff) == 0xf2
648            || (insn & 0xff) == 0xf3
649            || (insn & 0xff) == 0xf4
650            || (insn & 0xff) == 0xf5
651            || (insn & 0xff) == 0xf6)
652     {
653       status = (*info->read_memory_func) (memaddr, buffer, 2, info);
654       if (status != 0)
655         {
656           (*info->memory_error_func) (status, memaddr, info);
657           return -1;
658         }
659       insn = bfd_getb16 (buffer);
660       consume = 2;
661     }
662
663   /* These are three byte insns.  */
664   else if ((insn & 0xff) == 0xf8
665            || (insn & 0xff) == 0xcc
666            || (insn & 0xff) == 0xf9
667            || (insn & 0xf3) == 0x01
668            || (insn & 0xf3) == 0x02
669            || (insn & 0xf3) == 0x03
670            || (insn & 0xfc) == 0x24
671            || (insn & 0xfc) == 0x2c
672            || (insn & 0xfc) == 0x30
673            || (insn & 0xfc) == 0x34
674            || (insn & 0xfc) == 0x38
675            || (insn & 0xff) == 0xde
676            || (insn & 0xff) == 0xdf
677            || (insn & 0xff) == 0xf9
678            || (insn & 0xff) == 0xcc)
679     {
680       status = (*info->read_memory_func) (memaddr, buffer, 2, info);
681       if (status != 0)
682         {
683           (*info->memory_error_func) (status, memaddr, info);
684           return -1;
685         }
686       insn = bfd_getb16 (buffer);
687       insn <<= 8;
688       status = (*info->read_memory_func) (memaddr + 2, buffer, 1, info);
689       if (status != 0)
690         {
691           (*info->memory_error_func) (status, memaddr, info);
692           return -1;
693         }
694       insn |= *(unsigned char *) buffer;
695       consume = 3;
696     }
697
698   /* These are four byte insns.  */
699   else if ((insn & 0xff) == 0xfa
700            || (insn & 0xff) == 0xf7
701            || (insn & 0xff) == 0xfb)
702     {
703       status = (*info->read_memory_func) (memaddr, buffer, 4, info);
704       if (status != 0)
705         {
706           (*info->memory_error_func) (status, memaddr, info);
707           return -1;
708         }
709       insn = bfd_getb32 (buffer);
710       consume = 4;
711     }
712
713   /* These are five byte insns.  */
714   else if ((insn & 0xff) == 0xcd
715            || (insn & 0xff) == 0xdc)
716     {
717       status = (*info->read_memory_func) (memaddr, buffer, 4, info);
718       if (status != 0)
719         {
720           (*info->memory_error_func) (status, memaddr, info);
721           return -1;
722         }
723       insn = bfd_getb32 (buffer);
724       consume = 5;
725     }
726
727   /* These are six byte insns.  */
728   else if ((insn & 0xff) == 0xfd
729            || (insn & 0xff) == 0xfc)
730     {
731       status = (*info->read_memory_func) (memaddr, buffer, 4, info);
732       if (status != 0)
733         {
734           (*info->memory_error_func) (status, memaddr, info);
735           return -1;
736         }
737
738       insn = bfd_getb32 (buffer);
739       consume = 6;
740     }
741
742   /* Else its a seven byte insns (in theory).  */
743   else
744     {
745       status = (*info->read_memory_func) (memaddr, buffer, 4, info);
746       if (status != 0)
747         {
748           (*info->memory_error_func) (status, memaddr, info);
749           return -1;
750         }
751
752       insn = bfd_getb32 (buffer);
753       consume = 7;
754       /* Handle the 5-byte extended instruction codes.  */
755       if ((insn & 0xfff80000) == 0xfe800000)
756         consume = 5;
757     }
758
759   disassemble (memaddr, info, insn, consume);
760
761   return consume;
762 }