Hardcode host-specific name for LTO plugin
[platform/upstream/binutils.git] / opcodes / v850-dis.c
1 /* Disassemble V850 instructions.
2    Copyright (C) 1996-2014 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
22 #include "sysdep.h"
23 #include <stdio.h>
24 #include <string.h>
25 #include "opcode/v850.h"
26 #include "dis-asm.h"
27 #include "opintl.h"
28
29 static const char *const v850_reg_names[] =
30 {
31   "r0", "r1", "r2", "sp", "gp", "r5", "r6", "r7",
32   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
33   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
34   "r24", "r25", "r26", "r27", "r28", "r29", "ep", "lp"
35 };
36
37 static const char *const v850_sreg_names[] =
38 {
39   "eipc/vip/mpm", "eipsw/mpc", "fepc/tid", "fepsw/ppa", "ecr/vmecr", "psw/vmtid",
40   "sr6/fpsr/vmadr/dcc", "sr7/fpepc/dc0",
41   "sr8/fpst/vpecr/dcv1", "sr9/fpcc/vptid", "sr10/fpcfg/vpadr/spal", "sr11/spau",
42   "sr12/vdecr/ipa0l", "eiic/vdtid/ipa0u", "feic/ipa1l", "dbic/ipa1u",
43   "ctpc/ipa2l", "ctpsw/ipa2u", "dbpc/ipa3l", "dbpsw/ipa3u", "ctbp/dpa0l",
44   "dir/dpa0u", "bpc/dpa0u", "asid/dpa1l",
45   "bpav/dpa1u", "bpam/dpa2l", "bpdv/dpa2u", "bpdm/dpa3l", "eiwr/dpa3u",
46   "fewr", "dbwr", "bsel"
47 };
48
49 static const char *const v850_cc_names[] =
50 {
51   "v", "c/l", "z", "nh", "s/n", "t", "lt", "le",
52   "nv", "nc/nl", "nz", "h", "ns/p", "sa", "ge", "gt"
53 };
54
55 static const char *const v850_float_cc_names[] =
56 {
57   "f/t", "un/or", "eq/neq", "ueq/ogl", "olt/uge", "ult/oge", "ole/ugt", "ule/ogt",
58   "sf/st", "ngle/gle", "seq/sne", "ngl/gl", "lt/nlt", "nge/ge", "le/nle", "ngt/gt"
59 };
60
61
62 static const char *const v850_vreg_names[] =
63 {
64   "vr0", "vr1", "vr2", "vr3", "vr4", "vr5", "vr6", "vr7", "vr8", "vr9",
65   "vr10", "vr11", "vr12", "vr13", "vr14", "vr15", "vr16", "vr17", "vr18",
66   "vr19", "vr20", "vr21", "vr22", "vr23", "vr24", "vr25", "vr26", "vr27",
67   "vr28", "vr29", "vr30", "vr31"
68 };
69
70 static const char *const v850_cacheop_names[] =
71 {
72   "chbii", "cibii", "cfali", "cisti", "cildi", "chbid", "chbiwbd",
73   "chbwbd", "cibid", "cibiwbd", "cibwbd", "cfald", "cistd", "cildd"
74 };
75
76 static const int v850_cacheop_codes[] =
77 {
78   0x00, 0x20, 0x40, 0x60, 0x61, 0x04, 0x06,
79   0x07, 0x24, 0x26, 0x27, 0x44, 0x64, 0x65, -1
80 };
81
82 static const char *const v850_prefop_names[] =
83 { "prefi", "prefd" };
84
85 static const int v850_prefop_codes[] =
86 { 0x00, 0x04, -1};
87
88 static void
89 print_value (int flags,
90              bfd_vma memaddr,
91              struct disassemble_info *info,
92              long value)
93 {
94   if (flags & V850_PCREL)
95     {
96       bfd_vma addr = value + memaddr;
97
98       if (flags & V850_INVERSE_PCREL)
99         addr = memaddr - value;
100       info->print_address_func (addr, info);
101     }
102   else if (flags & V850_OPERAND_DISP)
103     {
104       if (flags & V850_OPERAND_SIGNED)
105         {
106           info->fprintf_func (info->stream, "%ld", value);
107         }
108       else
109         {
110           info->fprintf_func (info->stream, "%lu", value);
111         }
112     }
113   else if ((flags & V850E_IMMEDIATE32)
114            || (flags & V850E_IMMEDIATE16HI))
115     {
116       info->fprintf_func (info->stream, "0x%lx", value);
117     }
118   else
119     {
120       if (flags & V850_OPERAND_SIGNED)
121         {
122           info->fprintf_func (info->stream, "%ld", value);
123         }
124       else
125         {
126           info->fprintf_func (info->stream, "%lu", value);
127         }
128     }
129 }
130
131 static long
132 get_operand_value (const struct v850_operand *operand,
133                    unsigned long insn,
134                    int bytes_read,
135                    bfd_vma memaddr,
136                    struct disassemble_info * info,
137                    bfd_boolean noerror,
138                    int *invalid)
139 {
140   long value;
141   bfd_byte buffer[4];
142
143   if ((operand->flags & V850E_IMMEDIATE16)
144       || (operand->flags & V850E_IMMEDIATE16HI))
145     {
146       int status = info->read_memory_func (memaddr + bytes_read, buffer, 2, info);
147
148       if (status == 0)
149         {
150           value = bfd_getl16 (buffer);
151
152           if (operand->flags & V850E_IMMEDIATE16HI)
153             value <<= 16;
154           else if (value & 0x8000)
155             value |= (-1L << 16);
156
157           return value;
158         }
159
160       if (!noerror)
161         info->memory_error_func (status, memaddr + bytes_read, info);
162
163       return 0;
164     }
165
166   if (operand->flags & V850E_IMMEDIATE23)
167     {
168       int status = info->read_memory_func (memaddr + 2, buffer, 4, info);
169
170       if (status == 0)
171         {
172           value = bfd_getl32 (buffer);
173
174           value = (operand->extract) (value, invalid);
175
176           return value;
177         }
178
179       if (!noerror)
180         info->memory_error_func (status, memaddr + bytes_read, info);
181
182       return 0;
183     }
184
185   if (operand->flags & V850E_IMMEDIATE32)
186     {
187       int status = info->read_memory_func (memaddr + bytes_read, buffer, 4, info);
188
189       if (status == 0)
190         {
191           bytes_read += 4;
192           value = bfd_getl32 (buffer);
193
194           return value;
195         }
196
197       if (!noerror)
198         info->memory_error_func (status, memaddr + bytes_read, info);
199
200       return 0;
201     }
202
203   if (operand->extract)
204     value = (operand->extract) (insn, invalid);
205   else
206     {
207       if (operand->bits == -1)
208         value = (insn & operand->shift);
209       else
210         value = (insn >> operand->shift) & ((1 << operand->bits) - 1);
211
212       if (operand->flags & V850_OPERAND_SIGNED)
213         value = ((long)(value << (sizeof (long)*8 - operand->bits))
214                  >> (sizeof (long)*8 - operand->bits));
215     }
216
217   return value;
218 }
219
220
221 static int
222 disassemble (bfd_vma memaddr,
223              struct disassemble_info *info,
224              int bytes_read,
225              unsigned long insn)
226 {
227   struct v850_opcode *op = (struct v850_opcode *) v850_opcodes;
228   const struct v850_operand *operand;
229   int match = 0;
230   int target_processor;
231
232   switch (info->mach)
233     {
234     case 0:
235     default:
236       target_processor = PROCESSOR_V850;
237       break;
238
239     case bfd_mach_v850e:
240       target_processor = PROCESSOR_V850E;
241       break;
242
243     case bfd_mach_v850e1:
244       target_processor = PROCESSOR_V850E;
245       break;
246
247     case bfd_mach_v850e2:
248       target_processor = PROCESSOR_V850E2;
249       break;
250
251     case bfd_mach_v850e2v3:
252       target_processor = PROCESSOR_V850E2V3;
253       break;
254
255     case bfd_mach_v850e3v5:
256       target_processor = PROCESSOR_V850E3V5;
257       break;
258     }
259
260   /* If this is a two byte insn, then mask off the high bits.  */
261   if (bytes_read == 2)
262     insn &= 0xffff;
263
264   /* Find the opcode.  */
265   while (op->name)
266     {
267       if ((op->mask & insn) == op->opcode
268           && (op->processors & target_processor)
269           && !(op->processors & PROCESSOR_OPTION_ALIAS))
270         {
271           /* Code check start.  */
272           const unsigned char *opindex_ptr;
273           unsigned int opnum;
274           unsigned int memop;
275
276           for (opindex_ptr = op->operands, opnum = 1;
277                *opindex_ptr != 0;
278                opindex_ptr++, opnum++)
279             {
280               int invalid = 0;
281               long value;
282
283               operand = &v850_operands[*opindex_ptr];
284
285               value = get_operand_value (operand, insn, bytes_read, memaddr,
286                                          info, 1, &invalid);
287
288               if (invalid)
289                 goto next_opcode;
290
291               if ((operand->flags & V850_NOT_R0) && value == 0 && (op->memop) <=2)
292                 goto next_opcode;
293
294               if ((operand->flags & V850_NOT_SA) && value == 0xd)
295                 goto next_opcode;
296
297               if ((operand->flags & V850_NOT_IMM0) && value == 0)
298                 goto next_opcode;
299             }
300
301           /* Code check end.  */
302
303           match = 1;
304           (*info->fprintf_func) (info->stream, "%s\t", op->name);
305 #if 0
306           fprintf (stderr, "match: insn: %lx, mask: %lx, opcode: %lx, name: %s\n",
307                    insn, op->mask, op->opcode, op->name );
308 #endif
309
310           memop = op->memop;
311           /* Now print the operands.
312
313              MEMOP is the operand number at which a memory
314              address specification starts, or zero if this
315              instruction has no memory addresses.
316
317              A memory address is always two arguments.
318
319              This information allows us to determine when to
320              insert commas into the output stream as well as
321              when to insert disp[reg] expressions onto the
322              output stream.  */
323
324           for (opindex_ptr = op->operands, opnum = 1;
325                *opindex_ptr != 0;
326                opindex_ptr++, opnum++)
327             {
328               bfd_boolean square = FALSE;
329               long value;
330               int flag;
331               char *prefix;
332
333               operand = &v850_operands[*opindex_ptr];
334
335               value = get_operand_value (operand, insn, bytes_read, memaddr,
336                                          info, 0, 0);
337
338               /* The first operand is always output without any
339                  special handling.
340
341                  For the following arguments:
342
343                    If memop && opnum == memop + 1, then we need '[' since
344                    we're about to output the register used in a memory
345                    reference.
346
347                    If memop && opnum == memop + 2, then we need ']' since
348                    we just finished the register in a memory reference.  We
349                    also need a ',' before this operand.
350
351                    Else we just need a comma.
352
353                    We may need to output a trailing ']' if the last operand
354                    in an instruction is the register for a memory address.
355
356                    The exception (and there's always an exception) are the
357                    "jmp" insn which needs square brackets around it's only
358                    register argument, and the clr1/not1/set1/tst1 insns
359                    which [...] around their second register argument.  */
360
361               prefix = "";
362               if (operand->flags & V850_OPERAND_BANG)
363                 {
364                   prefix = "!";
365                 }
366               else if (operand->flags & V850_OPERAND_PERCENT)
367                 {
368                   prefix = "%";
369                 }
370
371               if (opnum == 1 && opnum == memop)
372                 {
373                   info->fprintf_func (info->stream, "%s[", prefix);
374                   square = TRUE;
375                 }
376               else if (   (strcmp ("stc.w", op->name) == 0
377                         || strcmp ("cache", op->name) == 0
378                         || strcmp ("pref",  op->name) == 0)
379                        && opnum == 2 && opnum == memop)
380                 {
381                   info->fprintf_func (info->stream, ", [");
382                   square = TRUE;
383                 }
384               else if (   (strcmp (op->name, "pushsp") == 0
385                         || strcmp (op->name, "popsp") == 0
386                         || strcmp (op->name, "dbpush" ) == 0)
387                        && opnum == 2)
388                 {
389                   info->fprintf_func (info->stream, "-");
390                 }
391               else if (opnum > 1
392                        && (v850_operands[*(opindex_ptr - 1)].flags
393                            & V850_OPERAND_DISP) != 0
394                        && opnum == memop)
395                 {
396                   info->fprintf_func (info->stream, "%s[", prefix);
397                   square = TRUE;
398                 }
399               else if (opnum == 2
400                        && (   op->opcode == 0x00e407e0 /* clr1 */
401                            || op->opcode == 0x00e207e0 /* not1 */
402                            || op->opcode == 0x00e007e0 /* set1 */
403                            || op->opcode == 0x00e607e0 /* tst1 */
404                            ))
405                 {
406                   info->fprintf_func (info->stream, ", %s[", prefix);
407                   square = TRUE;
408                 }
409               else if (opnum > 1)
410                 info->fprintf_func (info->stream, ", %s", prefix);
411
412               /* Extract the flags, ignoring ones which do not
413                  effect disassembly output.  */
414               flag = operand->flags & (V850_OPERAND_REG
415                                        | V850_REG_EVEN
416                                        | V850_OPERAND_EP
417                                        | V850_OPERAND_SRG
418                                        | V850E_OPERAND_REG_LIST
419                                        | V850_OPERAND_CC
420                                        | V850_OPERAND_VREG
421                                        | V850_OPERAND_CACHEOP
422                                        | V850_OPERAND_PREFOP
423                                        | V850_OPERAND_FLOAT_CC);
424
425               switch (flag)
426                 {
427                 case V850_OPERAND_REG:
428                   info->fprintf_func (info->stream, "%s", v850_reg_names[value]);
429                   break;
430                 case (V850_OPERAND_REG|V850_REG_EVEN):
431                   info->fprintf_func (info->stream, "%s", v850_reg_names[value * 2]);
432                   break;
433                 case V850_OPERAND_EP:
434                   info->fprintf_func (info->stream, "ep");
435                   break;
436                 case V850_OPERAND_SRG:
437                   info->fprintf_func (info->stream, "%s", v850_sreg_names[value]);
438                   break;
439                 case V850E_OPERAND_REG_LIST:
440                   {
441                     static int list12_regs[32]   = { 30, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
442                                                      0,  0, 0, 0, 0, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24 };
443                     int *regs;
444                     int i;
445                     unsigned long int mask = 0;
446                     int pc = 0;
447
448                     switch (operand->shift)
449                       {
450                       case 0xffe00001: regs = list12_regs; break;
451                       default:
452                         /* xgettext:c-format */
453                         fprintf (stderr, _("unknown operand shift: %x\n"), operand->shift);
454                         abort ();
455                       }
456
457                     for (i = 0; i < 32; i++)
458                       {
459                         if (value & (1 << i))
460                           {
461                             switch (regs[ i ])
462                               {
463                               default: mask |= (1 << regs[ i ]); break;
464                                 /* xgettext:c-format */
465                               case 0:  fprintf (stderr, _("unknown reg: %d\n"), i ); abort ();
466                               case -1: pc = 1; break;
467                               }
468                           }
469                       }
470
471                     info->fprintf_func (info->stream, "{");
472
473                     if (mask || pc)
474                       {
475                         if (mask)
476                           {
477                             unsigned int bit;
478                             int shown_one = 0;
479
480                             for (bit = 0; bit < 32; bit++)
481                               if (mask & (1 << bit))
482                                 {
483                                   unsigned long int first = bit;
484                                   unsigned long int last;
485
486                                   if (shown_one)
487                                     info->fprintf_func (info->stream, ", ");
488                                   else
489                                     shown_one = 1;
490
491                                   info->fprintf_func (info->stream, "%s", v850_reg_names[first]);
492
493                                   for (bit++; bit < 32; bit++)
494                                     if ((mask & (1 << bit)) == 0)
495                                       break;
496
497                                   last = bit;
498
499                                   if (last > first + 1)
500                                     {
501                                       info->fprintf_func (info->stream, " - %s", v850_reg_names[ last - 1 ]);
502                                     }
503                                 }
504                           }
505
506                         if (pc)
507                           info->fprintf_func (info->stream, "%sPC", mask ? ", " : "");
508                       }
509
510                     info->fprintf_func (info->stream, "}");
511                   }
512                   break;
513
514                 case V850_OPERAND_CC:
515                   info->fprintf_func (info->stream, "%s", v850_cc_names[value]);
516                   break;
517
518                 case V850_OPERAND_FLOAT_CC:
519                   info->fprintf_func (info->stream, "%s", v850_float_cc_names[value]);
520                   break;
521
522                 case V850_OPERAND_CACHEOP:
523                   {
524                     int idx;
525
526                     for (idx = 0; v850_cacheop_codes[idx] != -1; idx++)
527                       {
528                         if (value == v850_cacheop_codes[idx])
529                           {
530                             info->fprintf_func (info->stream, "%s",
531                                                 v850_cacheop_names[idx]);
532                             goto MATCH_CACHEOP_CODE;
533                           }
534                       }
535                     info->fprintf_func (info->stream, "%d", (int) value);
536                   }
537                 MATCH_CACHEOP_CODE:
538                   break;
539
540                 case V850_OPERAND_PREFOP:
541                   {
542                     int idx;
543
544                     for (idx = 0; v850_prefop_codes[idx] != -1; idx++)
545                       {
546                         if (value == v850_prefop_codes[idx])
547                           {
548                             info->fprintf_func (info->stream, "%s",
549                               v850_prefop_names[idx]);
550                             goto MATCH_PREFOP_CODE;
551                           }
552                       }
553                     info->fprintf_func (info->stream, "%d", (int) value);
554                   }
555                 MATCH_PREFOP_CODE:
556                   break;
557
558                 case V850_OPERAND_VREG:
559                   info->fprintf_func (info->stream, "%s", v850_vreg_names[value]);
560                   break;
561
562                 default:
563                   print_value (operand->flags, memaddr, info, value);
564                   break;
565                 }
566
567               if (square)
568                 (*info->fprintf_func) (info->stream, "]");
569             }
570
571           /* All done. */
572           break;
573         }
574     next_opcode:
575       op++;
576     }
577
578   return match;
579 }
580
581 int
582 print_insn_v850 (bfd_vma memaddr, struct disassemble_info * info)
583 {
584   int status, status2, match;
585   bfd_byte buffer[8];
586   int length = 0, code_length = 0;
587   unsigned long insn = 0, insn2 = 0;
588   int target_processor;
589
590   switch (info->mach)
591     {
592     case 0:
593     default:
594       target_processor = PROCESSOR_V850;
595       break;
596
597     case bfd_mach_v850e:
598       target_processor = PROCESSOR_V850E;
599       break;
600
601     case bfd_mach_v850e1:
602       target_processor = PROCESSOR_V850E;
603       break;
604
605     case bfd_mach_v850e2:
606       target_processor = PROCESSOR_V850E2;
607       break;
608
609     case bfd_mach_v850e2v3:
610       target_processor = PROCESSOR_V850E2V3;
611       break;
612
613     case bfd_mach_v850e3v5:
614       target_processor = PROCESSOR_V850E3V5;
615       break;
616     }
617
618   status = info->read_memory_func (memaddr, buffer, 2, info);
619
620   if (status)
621     {
622       info->memory_error_func (status, memaddr, info);
623       return -1;
624     }
625
626   insn = bfd_getl16 (buffer);
627
628   status2 = info->read_memory_func (memaddr+2, buffer, 2 , info);
629
630   if (!status2)
631     {
632       insn2 = bfd_getl16 (buffer);
633       /* fprintf (stderr, "insn2 0x%08lx\n", insn2); */
634     }
635
636   /* Special case.  */
637   if (length == 0
638       && ((target_processor & PROCESSOR_V850E2_UP) != 0))
639     {
640       if ((insn & 0xffff) == 0x02e0             /* jr 32bit */
641           && !status2 && (insn2 & 0x1) == 0)
642         {
643           length = 2;
644           code_length = 6;
645         }
646       else if ((insn & 0xffe0) == 0x02e0        /* jarl 32bit */
647                && !status2 && (insn2 & 0x1) == 0)
648         {
649           length = 2;
650           code_length = 6;
651         }
652       else if ((insn & 0xffe0) == 0x06e0        /* jmp 32bit */
653                && !status2 && (insn2 & 0x1) == 0)
654         {
655           length = 2;
656           code_length = 6;
657         }
658     }
659
660   if (length == 0
661       && ((target_processor & PROCESSOR_V850E3V5_UP) != 0))
662     {
663       if (   ((insn & 0xffe0) == 0x07a0         /* ld.dw 23bit (v850e3v5) */
664               && !status2 && (insn2 & 0x000f) == 0x0009)
665           || ((insn & 0xffe0) == 0x07a0         /* st.dw 23bit (v850e3v5) */
666               && !status2 && (insn2 & 0x000f) == 0x000f))
667         {
668           length = 4;
669           code_length = 6;
670         }
671     }
672
673   if (length == 0
674       && ((target_processor & PROCESSOR_V850E2V3_UP) != 0))
675     {
676       if (((insn & 0xffe0) == 0x0780            /* ld.b 23bit */
677            && !status2 && (insn2 & 0x000f) == 0x0005)
678           || ((insn & 0xffe0) == 0x07a0         /* ld.bu 23bit */
679               && !status2 && (insn2 & 0x000f) == 0x0005)
680           || ((insn & 0xffe0) == 0x0780         /* ld.h 23bit */
681               && !status2 && (insn2 & 0x000f) == 0x0007)
682           || ((insn & 0xffe0) == 0x07a0         /* ld.hu 23bit */
683               && !status2 && (insn2 & 0x000f) == 0x0007)
684           || ((insn & 0xffe0) == 0x0780         /* ld.w 23bit */
685               && !status2 && (insn2 & 0x000f) == 0x0009))
686         {
687           length = 4;
688           code_length = 6;
689         }
690       else if (((insn & 0xffe0) == 0x0780       /* st.b 23bit */
691                && !status2 && (insn2 & 0x000f) == 0x000d)
692               || ((insn & 0xffe0) == 0x07a0     /* st.h 23bit */
693                   && !status2 && (insn2 & 0x000f) == 0x000d)
694               || ((insn & 0xffe0) == 0x0780     /* st.w 23bit */
695                   && !status2 && (insn2 & 0x000f) == 0x000f))
696         {
697           length = 4;
698           code_length = 6;
699         }
700     }
701
702   if (length == 0
703       && target_processor != PROCESSOR_V850)
704     {
705       if ((insn & 0xffe0) == 0x0620)            /* 32 bit MOV */
706         {
707           length = 2;
708           code_length = 6;
709         }
710       else if ((insn & 0xffc0) == 0x0780        /* prepare {list}, imm5, imm16<<16 */
711                && !status2 && (insn2 & 0x001f) == 0x0013)
712         {
713           length = 4;
714           code_length = 6;
715         }
716       else if ((insn & 0xffc0) == 0x0780        /* prepare {list}, imm5, imm16 */
717                && !status2 && (insn2 & 0x001f) == 0x000b)
718         {
719           length = 4;
720           code_length = 6;
721         }
722       else if ((insn & 0xffc0) == 0x0780        /* prepare {list}, imm5, imm32 */
723                && !status2 && (insn2 & 0x001f) == 0x001b)
724         {
725           length = 4;
726           code_length = 8;
727         }
728     }
729
730   if (length == 4
731       || (length == 0
732           && (insn & 0x0600) == 0x0600))
733     {
734       /* This is a 4 byte insn.  */
735       status = info->read_memory_func (memaddr, buffer, 4, info);
736       if (!status)
737         {
738           insn = bfd_getl32 (buffer);
739
740           if (!length)
741             length = code_length = 4;
742         }
743     }
744
745   if (code_length > length)
746     {
747       status = info->read_memory_func (memaddr + length, buffer, code_length - length, info);
748       if (status)
749         length = 0;
750     }
751
752   if (length == 0 && !status)
753     length = code_length = 2;
754
755   if (length == 2)
756     insn &= 0xffff;
757
758   /* when the last 2 bytes of section is 0xffff, length will be 0 and cause infinitive loop */
759   if (length == 0)
760     return -1;
761
762   match = disassemble (memaddr, info, length, insn);
763
764   if (!match)
765     {
766       int l = 0;
767
768       status = info->read_memory_func (memaddr, buffer, code_length, info);
769
770       while (l < code_length)
771         {
772           if (code_length - l == 2)
773             {
774               insn = bfd_getl16 (buffer + l) & 0xffff;
775               info->fprintf_func (info->stream, ".short\t0x%04lx", insn);
776               l += 2;
777             }
778           else
779             {
780               insn = bfd_getl32 (buffer + l);
781               info->fprintf_func (info->stream, ".long\t0x%08lx", insn);
782               l += 4;
783             }
784         }
785     }
786
787   return code_length;
788 }