arc: Swap highbyte and lowbyte in print_insn_arc
[external/binutils.git] / opcodes / arc-dis.c
1 /* Instruction printing code for the ARC.
2    Copyright (C) 1994-2016 Free Software Foundation, Inc.
3
4    Contributed by Claudiu Zissulescu (claziss@synopsys.com)
5
6    This file is part of libopcodes.
7
8    This library is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3, or (at your option)
11    any later version.
12
13    It is distributed in the hope that it will be useful, but WITHOUT
14    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
16    License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21    MA 02110-1301, USA.  */
22
23 #include "sysdep.h"
24 #include <stdio.h>
25 #include <assert.h>
26 #include "dis-asm.h"
27 #include "opcode/arc.h"
28 #include "elf/arc.h"
29 #include "arc-dis.h"
30 #include "arc-ext.h"
31 #include "elf-bfd.h"
32 #include "libiberty.h"
33 #include "opintl.h"
34
35 /* Structure used to iterate over, and extract the values for, operands of
36    an opcode.  */
37
38 struct arc_operand_iterator
39 {
40   enum
41     {
42       OPERAND_ITERATOR_STANDARD,
43       OPERAND_ITERATOR_LONG
44     } mode;
45
46   /* The array of 32-bit values that make up this instruction.  All
47      required values have been pre-loaded into this array during the
48      find_format call.  */
49   unsigned *insn;
50
51   union
52   {
53     struct
54     {
55       /* The opcode this iterator is operating on.  */
56       const struct arc_opcode *opcode;
57
58       /* The index into the opcodes operand index list.  */
59       const unsigned char *opidx;
60     } standard;
61
62     struct
63     {
64       /* The long instruction opcode this iterator is operating on.  */
65       const struct arc_long_opcode *long_opcode;
66
67       /* Two indexes into the opcodes operand index lists.  */
68       const unsigned char *opidx_base, *opidx_limm;
69     } long_insn;
70   } state;
71 };
72
73 /* Globals variables.  */
74
75 static const char * const regnames[64] =
76 {
77   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
78   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
79   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
80   "r24", "r25", "gp", "fp", "sp", "ilink", "r30", "blink",
81
82   "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39",
83   "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47",
84   "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55",
85   "r56", "r57", "ACCL", "ACCH", "lp_count", "rezerved", "LIMM", "pcl"
86 };
87
88 static const char * const addrtypenames[ARC_NUM_ADDRTYPES] =
89 {
90   "bd", "jid", "lbd", "mbd", "sd", "sm", "xa", "xd",
91   "cd", "cbd", "cjid", "clbd", "cm", "csd", "cxa", "cxd"
92 };
93
94 static int addrtypenames_max = ARC_NUM_ADDRTYPES - 1;
95
96 static const char * const addrtypeunknown = "unknown";
97
98 /* This structure keeps track which instruction class(es)
99    should be ignored durring disassembling.  */
100
101 typedef struct skipclass
102 {
103   insn_class_t     insn_class;
104   insn_subclass_t  subclass;
105   struct skipclass *nxt;
106 } skipclass_t, *linkclass;
107
108 /* Intial classes of instructions to be consider first when
109    disassembling.  */
110 static linkclass decodelist = NULL;
111
112 /* Macros section.  */
113
114 #ifdef DEBUG
115 # define pr_debug(fmt, args...) fprintf (stderr, fmt, ##args)
116 #else
117 # define pr_debug(fmt, args...)
118 #endif
119
120 #define ARRANGE_ENDIAN(info, buf)                                       \
121   (info->endian == BFD_ENDIAN_LITTLE ? bfd_getm32 (bfd_getl32 (buf))    \
122    : bfd_getb32 (buf))
123
124 #define BITS(word,s,e)  (((word) << (sizeof (word) * 8 - 1 - e)) >>     \
125                          (s + (sizeof (word) * 8 - 1 - e)))
126 #define OPCODE(word)    (BITS ((word), 27, 31))
127
128 #define OPCODE_AC(word)   (BITS ((word), 11, 15))
129
130 /* Functions implementation.  */
131
132 /* Return TRUE when two classes are not opcode conflicting.  */
133
134 static bfd_boolean
135 is_compatible_p (insn_class_t     classA,
136                  insn_subclass_t  sclassA,
137                  insn_class_t     classB,
138                  insn_subclass_t  sclassB)
139 {
140   if (classA == DSP && sclassB == DPX)
141     return FALSE;
142   if (sclassA == DPX && classB == DSP)
143     return FALSE;
144   return TRUE;
145 }
146
147 /* Add a new element to the decode list.  */
148
149 static void
150 add_to_decodelist (insn_class_t     insn_class,
151                    insn_subclass_t  subclass)
152 {
153   linkclass t = (linkclass) xmalloc (sizeof (skipclass_t));
154
155   t->insn_class = insn_class;
156   t->subclass = subclass;
157   t->nxt = decodelist;
158   decodelist = t;
159 }
160
161 /* Return TRUE if we need to skip the opcode from being
162    disassembled.  */
163
164 static bfd_boolean
165 skip_this_opcode (const struct arc_opcode *  opcode,
166                   struct disassemble_info *  info)
167 {
168   linkclass t = decodelist;
169   bfd_boolean addme = TRUE;
170
171   /* Check opcode for major 0x06, return if it is not in.  */
172   if (OPCODE (opcode->opcode) != 0x06)
173     return FALSE;
174
175   while (t != NULL
176          && is_compatible_p (t->insn_class, t->subclass,
177                              opcode->insn_class, opcode->subclass))
178     {
179       if ((t->insn_class == opcode->insn_class)
180           && (t->subclass == opcode->subclass))
181         addme = FALSE;
182       t = t->nxt;
183     }
184
185   /* If we found an incompatibility then we must skip.  */
186   if (t != NULL)
187     return TRUE;
188
189   /* Even if we do not precisely know the if the right mnemonics
190      is correctly displayed, keep the disassmbled code class
191      consistent.  */
192   if (addme)
193     {
194       switch (opcode->insn_class)
195         {
196         case DSP:
197         case FLOAT:
198           /* Add to the conflict list only the classes which
199              counts.  */
200           add_to_decodelist (opcode->insn_class, opcode->subclass);
201           /* Warn if we have to decode an opcode and no preferred
202              classes have been chosen.  */
203           info->fprintf_func (info->stream, _("\n\
204 Warning: disassembly may be wrong due to guessed opcode class choice.\n\
205  Use -M<class[,class]> to select the correct opcode class(es).\n\t\t\t\t"));
206           break;
207         default:
208           break;
209         }
210     }
211   return FALSE;
212 }
213
214 static bfd_vma
215 bfd_getm32 (unsigned int data)
216 {
217   bfd_vma value = 0;
218
219   value = ((data & 0xff00) | (data & 0xff)) << 16;
220   value |= ((data & 0xff0000) | (data & 0xff000000)) >> 16;
221   return value;
222 }
223
224 static bfd_boolean
225 special_flag_p (const char *opname,
226                 const char *flgname)
227 {
228   const struct arc_flag_special *flg_spec;
229   unsigned i, j, flgidx;
230
231   for (i = 0; i < arc_num_flag_special; i++)
232     {
233       flg_spec = &arc_flag_special_cases[i];
234
235       if (strcmp (opname, flg_spec->name))
236         continue;
237
238       /* Found potential special case instruction.  */
239       for (j=0;; ++j)
240         {
241           flgidx = flg_spec->flags[j];
242           if (flgidx == 0)
243             break; /* End of the array.  */
244
245           if (strcmp (flgname, arc_flag_operands[flgidx].name) == 0)
246             return TRUE;
247         }
248     }
249   return FALSE;
250 }
251
252 /* Find opcode from ARC_TABLE given the instruction described by INSN and
253    INSNLEN.  The ISA_MASK restricts the possible matches in ARC_TABLE.  */
254
255 static const struct arc_opcode *
256 find_format_from_table (struct disassemble_info *info,
257                         const struct arc_opcode *arc_table,
258                         unsigned *insn,
259                         unsigned int insn_len,
260                         unsigned isa_mask,
261                         bfd_boolean *has_limm,
262                         bfd_boolean overlaps)
263 {
264   unsigned int i = 0;
265   const struct arc_opcode *opcode = NULL;
266   const unsigned char *opidx;
267   const unsigned char *flgidx;
268
269   do
270     {
271       bfd_boolean invalid = FALSE;
272
273       opcode = &arc_table[i++];
274
275       if ((arc_opcode_len (opcode) == 2) && (insn_len == 2))
276         {
277           if (OPCODE_AC (opcode->opcode) != OPCODE_AC (insn[0]))
278             continue;
279         }
280       else if ((arc_opcode_len (opcode) == 4) && (insn_len == 4))
281         {
282           if (OPCODE (opcode->opcode) != OPCODE (insn[0]))
283             continue;
284         }
285       else
286         continue;
287
288       if ((insn[0] ^ opcode->opcode) & opcode->mask)
289         continue;
290
291       if (!(opcode->cpu & isa_mask))
292         continue;
293
294       *has_limm = FALSE;
295
296       /* Possible candidate, check the operands.  */
297       for (opidx = opcode->operands; *opidx; opidx++)
298         {
299           int value, limmind;
300           const struct arc_operand *operand = &arc_operands[*opidx];
301
302           if (operand->flags & ARC_OPERAND_FAKE)
303             continue;
304
305           if (operand->extract)
306             value = (*operand->extract) (insn[0], &invalid);
307           else
308             value = (insn[0] >> operand->shift) & ((1 << operand->bits) - 1);
309
310           /* Check for LIMM indicator.  If it is there, then make sure
311              we pick the right format.  */
312           limmind = (isa_mask & ARC_OPCODE_ARCV2) ? 0x1E : 0x3E;
313           if (operand->flags & ARC_OPERAND_IR
314               && !(operand->flags & ARC_OPERAND_LIMM))
315             {
316               if ((value == 0x3E && insn_len == 4)
317                   || (value == limmind && insn_len == 2))
318                 {
319                   invalid = TRUE;
320                   break;
321                 }
322             }
323
324           if (operand->flags & ARC_OPERAND_LIMM
325               && !(operand->flags & ARC_OPERAND_DUPLICATE))
326             *has_limm = TRUE;
327         }
328
329       /* Check the flags.  */
330       for (flgidx = opcode->flags; *flgidx; flgidx++)
331         {
332           /* Get a valid flag class.  */
333           const struct arc_flag_class *cl_flags = &arc_flag_classes[*flgidx];
334           const unsigned *flgopridx;
335           int foundA = 0, foundB = 0;
336           unsigned int value;
337
338           /* Check first the extensions.  */
339           if (cl_flags->flag_class & F_CLASS_EXTEND)
340             {
341               value = (insn[0] & 0x1F);
342               if (arcExtMap_condCodeName (value))
343                 continue;
344             }
345
346           for (flgopridx = cl_flags->flags; *flgopridx; ++flgopridx)
347             {
348               const struct arc_flag_operand *flg_operand =
349                 &arc_flag_operands[*flgopridx];
350
351               value = (insn[0] >> flg_operand->shift)
352                 & ((1 << flg_operand->bits) - 1);
353               if (value == flg_operand->code)
354                 foundA = 1;
355               if (value)
356                 foundB = 1;
357             }
358
359           if (!foundA && foundB)
360             {
361               invalid = TRUE;
362               break;
363             }
364         }
365
366       if (invalid)
367         continue;
368
369       if (insn_len == 4
370           && overlaps
371           && skip_this_opcode (opcode, info))
372         continue;
373
374       /* The instruction is valid.  */
375       return opcode;
376     }
377   while (opcode->mask);
378
379   return NULL;
380 }
381
382 /* Find long instructions matching values in INSN array.  */
383
384 static const struct arc_long_opcode *
385 find_format_long_instructions (unsigned *insn,
386                                unsigned int *insn_len,
387                                unsigned isa_mask,
388                                bfd_vma memaddr,
389                                struct disassemble_info *info)
390 {
391   unsigned int i;
392   unsigned limm = 0;
393   bfd_boolean limm_loaded = FALSE;
394
395   for (i = 0; i < arc_num_long_opcodes; ++i)
396     {
397       bfd_byte buffer[4];
398       int status;
399       const struct arc_opcode *opcode;
400
401       opcode = &arc_long_opcodes[i].base_opcode;
402
403       if ((arc_opcode_len (opcode) == 2) && (*insn_len == 2))
404         {
405           if (OPCODE_AC (opcode->opcode) != OPCODE_AC (insn[0]))
406             continue;
407         }
408       else if ((arc_opcode_len (opcode) == 4) && (*insn_len == 4))
409         {
410           if (OPCODE (opcode->opcode) != OPCODE (insn[0]))
411             continue;
412         }
413       else
414         continue;
415
416       if ((insn[0] ^ opcode->opcode) & opcode->mask)
417         continue;
418
419       if (!(opcode->cpu & isa_mask))
420         continue;
421
422       if (!limm_loaded)
423         {
424           status = (*info->read_memory_func) (memaddr + *insn_len, buffer,
425                                               4, info);
426           if (status != 0)
427             return NULL;
428
429           limm = ARRANGE_ENDIAN (info, buffer);
430           limm_loaded = TRUE;
431         }
432
433       /* Check the second word using the mask and template.  */
434       if ((limm & arc_long_opcodes[i].limm_mask)
435           != arc_long_opcodes[i].limm_template)
436         continue;
437
438       (*insn_len) += 4;
439       insn[1] = limm;
440       return &arc_long_opcodes[i];
441     }
442
443   return NULL;
444 }
445
446 /* Find opcode for INSN, trying various different sources.  The instruction
447    length in INSN_LEN will be updated if the instruction requires a LIMM
448    extension, and the additional values loaded into the INSN array (which
449    must be big enough).
450
451    A pointer to the opcode is placed into OPCODE_RESULT, and ITER is
452    initialised, ready to iterate over the operands of the found opcode.
453
454    This function returns TRUE in almost all cases, FALSE is reserved to
455    indicate an error (failing to find an opcode is not an error) a
456    returned result of FALSE would indicate that the disassembler can't
457    continue.
458
459    If no matching opcode is found then the returned result will be TRUE,
460    the value placed into OPCODE_RESULT will be NULL, ITER will be
461    undefined, and INSN_LEN will be unchanged.
462
463    If a matching opcode is found, then the returned result will be TRUE,
464    the opcode pointer is placed into OPCODE_RESULT, INSN_LEN will be
465    increased by 4 if the instruction requires a LIMM, and the LIMM value
466    will have been loaded into the INSN[1].  Finally, ITER will have been
467    initialised so that calls to OPERAND_ITERATOR_NEXT will iterate over
468    the opcode's operands.  */
469
470 static bfd_boolean
471 find_format (bfd_vma                       memaddr,
472              unsigned *                    insn,
473              unsigned int *                insn_len,
474              unsigned                      isa_mask,
475              struct disassemble_info *     info,
476              const struct arc_opcode **    opcode_result,
477              struct arc_operand_iterator * iter)
478 {
479   const struct arc_opcode *opcode = NULL;
480   bfd_boolean needs_limm;
481   const extInstruction_t *einsn, *i;
482
483   /* First, try the extension instructions.  */
484   einsn = arcExtMap_insn (OPCODE (insn[0]), insn[0]);
485   for (i = einsn; (i != NULL) && (opcode == NULL); i = i->next)
486     {
487       const char *errmsg = NULL;
488
489       opcode = arcExtMap_genOpcode (i, isa_mask, &errmsg);
490       if (opcode == NULL)
491         {
492           (*info->fprintf_func) (info->stream, "\
493 An error occured while generating the extension instruction operations");
494           *opcode_result = NULL;
495           return FALSE;
496         }
497
498       opcode = find_format_from_table (info, opcode, insn, *insn_len,
499                                        isa_mask, &needs_limm, FALSE);
500     }
501
502   /* Then, try finding the first match in the opcode table.  */
503   if (opcode == NULL)
504     opcode = find_format_from_table (info, arc_opcodes, insn, *insn_len,
505                                      isa_mask, &needs_limm, TRUE);
506
507   if (needs_limm && opcode != NULL)
508     {
509       bfd_byte buffer[4];
510       int status;
511
512       status = (*info->read_memory_func) (memaddr + *insn_len, buffer,
513                                           4, info);
514       if (status != 0)
515         {
516           opcode = NULL;
517         }
518       else
519         {
520           insn[1] = ARRANGE_ENDIAN (info, buffer);
521           *insn_len += 4;
522         }
523     }
524
525   if (opcode == NULL)
526     {
527       const struct arc_long_opcode *long_opcode;
528
529       /* No instruction found yet, try the long instructions.  */
530       long_opcode =
531         find_format_long_instructions (insn, insn_len, isa_mask,
532                                        memaddr, info);
533
534       if (long_opcode != NULL)
535         {
536           iter->mode = OPERAND_ITERATOR_LONG;
537           iter->insn = insn;
538           iter->state.long_insn.long_opcode = long_opcode;
539           iter->state.long_insn.opidx_base =
540             long_opcode->base_opcode.operands;
541           iter->state.long_insn.opidx_limm =
542             long_opcode->operands;
543           opcode = &long_opcode->base_opcode;
544         }
545     }
546   else
547     {
548       iter->mode = OPERAND_ITERATOR_STANDARD;
549       iter->insn = insn;
550       iter->state.standard.opcode = opcode;
551       iter->state.standard.opidx = opcode->operands;
552     }
553
554   *opcode_result = opcode;
555   return TRUE;
556 }
557
558 static void
559 print_flags (const struct arc_opcode *opcode,
560              unsigned *insn,
561              struct disassemble_info *info)
562 {
563   const unsigned char *flgidx;
564   unsigned int value;
565
566   /* Now extract and print the flags.  */
567   for (flgidx = opcode->flags; *flgidx; flgidx++)
568     {
569       /* Get a valid flag class.  */
570       const struct arc_flag_class *cl_flags = &arc_flag_classes[*flgidx];
571       const unsigned *flgopridx;
572
573       /* Check first the extensions.  */
574       if (cl_flags->flag_class & F_CLASS_EXTEND)
575         {
576           const char *name;
577           value = (insn[0] & 0x1F);
578
579           name = arcExtMap_condCodeName (value);
580           if (name)
581             {
582               (*info->fprintf_func) (info->stream, ".%s", name);
583               continue;
584             }
585         }
586
587       for (flgopridx = cl_flags->flags; *flgopridx; ++flgopridx)
588         {
589           const struct arc_flag_operand *flg_operand =
590             &arc_flag_operands[*flgopridx];
591
592           if (!flg_operand->favail)
593             continue;
594
595           value = (insn[0] >> flg_operand->shift)
596             & ((1 << flg_operand->bits) - 1);
597           if (value == flg_operand->code)
598             {
599                /* FIXME!: print correctly nt/t flag.  */
600               if (!special_flag_p (opcode->name, flg_operand->name))
601                 (*info->fprintf_func) (info->stream, ".");
602               else if (info->insn_type == dis_dref)
603                 {
604                   switch (flg_operand->name[0])
605                     {
606                     case 'b':
607                       info->data_size = 1;
608                       break;
609                     case 'h':
610                     case 'w':
611                       info->data_size = 2;
612                       break;
613                     default:
614                       info->data_size = 4;
615                       break;
616                     }
617                 }
618               if (flg_operand->name[0] == 'd'
619                   && flg_operand->name[1] == 0)
620                 info->branch_delay_insns = 1;
621
622               /* Check if it is a conditional flag.  */
623               if (cl_flags->flag_class & F_CLASS_COND)
624                 {
625                   if (info->insn_type == dis_jsr)
626                     info->insn_type = dis_condjsr;
627                   else if (info->insn_type == dis_branch)
628                     info->insn_type = dis_condbranch;
629                 }
630
631               (*info->fprintf_func) (info->stream, "%s", flg_operand->name);
632             }
633         }
634     }
635 }
636
637 static const char *
638 get_auxreg (const struct arc_opcode *opcode,
639             int value,
640             unsigned isa_mask)
641 {
642   const char *name;
643   unsigned int i;
644   const struct arc_aux_reg *auxr = &arc_aux_regs[0];
645
646   if (opcode->insn_class != AUXREG)
647     return NULL;
648
649   name = arcExtMap_auxRegName (value);
650   if (name)
651     return name;
652
653   for (i = 0; i < arc_num_aux_regs; i++, auxr++)
654     {
655       if (!(auxr->cpu & isa_mask))
656         continue;
657
658       if (auxr->subclass != NONE)
659         return NULL;
660
661       if (auxr->address == value)
662         return auxr->name;
663     }
664   return NULL;
665 }
666
667 /* Convert a value representing an address type to a string used to refer to
668    the address type in assembly code.  */
669
670 static const char *
671 get_addrtype (int value)
672 {
673   if (value < 0 || value > addrtypenames_max)
674     return addrtypeunknown;
675
676   return addrtypenames[value];
677 }
678
679 /* Calculate the instruction length for an instruction starting with MSB
680    and LSB, the most and least significant byte.  The ISA_MASK is used to
681    filter the instructions considered to only those that are part of the
682    current architecture.
683
684    The instruction lengths are calculated from the ARC_OPCODE table, and
685    cached for later use.  */
686
687 static unsigned int
688 arc_insn_length (bfd_byte msb, bfd_byte lsb, struct disassemble_info *info)
689 {
690   bfd_byte major_opcode = msb >> 3;
691
692   switch (info->mach)
693     {
694     case bfd_mach_arc_arc700:
695       /* The nps400 extension set requires this special casing of the
696          instruction length calculation.  Right now this is not causing any
697          problems as none of the known extensions overlap in opcode space,
698          but, if they ever do then we might need to start carrying
699          information around in the elf about which extensions are in use.  */
700       if (major_opcode == 0xb)
701         {
702           bfd_byte minor_opcode = lsb & 0x1f;
703
704           if (minor_opcode < 4)
705             return 2;
706         }
707       /* Fall through.  */
708     case bfd_mach_arc_arc600:
709       return (major_opcode > 0xb) ? 2 : 4;
710       break;
711
712     case bfd_mach_arc_arcv2:
713       return (major_opcode > 0x7) ? 2 : 4;
714       break;
715
716     default:
717       abort ();
718     }
719 }
720
721 /* Extract and return the value of OPERAND from the instruction whose value
722    is held in the array INSN.  */
723
724 static int
725 extract_operand_value (const struct arc_operand *operand, unsigned *insn)
726 {
727   int value;
728
729   /* Read the limm operand, if required.  */
730   if (operand->flags & ARC_OPERAND_LIMM)
731     /* The second part of the instruction value will have been loaded as
732        part of the find_format call made earlier.  */
733     value = insn[1];
734   else
735     {
736       if (operand->extract)
737         value = (*operand->extract) (insn[0], (int *) NULL);
738       else
739         {
740           if (operand->flags & ARC_OPERAND_ALIGNED32)
741             {
742               value = (insn[0] >> operand->shift)
743                 & ((1 << (operand->bits - 2)) - 1);
744               value = value << 2;
745             }
746           else
747             {
748               value = (insn[0] >> operand->shift) & ((1 << operand->bits) - 1);
749             }
750           if (operand->flags & ARC_OPERAND_SIGNED)
751             {
752               int signbit = 1 << (operand->bits - 1);
753               value = (value ^ signbit) - signbit;
754             }
755         }
756     }
757
758   return value;
759 }
760
761 /* Find the next operand, and the operands value from ITER.  Return TRUE if
762    there is another operand, otherwise return FALSE.  If there is an
763    operand returned then the operand is placed into OPERAND, and the value
764    into VALUE.  If there is no operand returned then OPERAND and VALUE are
765    unchanged.  */
766
767 static bfd_boolean
768 operand_iterator_next (struct arc_operand_iterator *iter,
769                        const struct arc_operand **operand,
770                        int *value)
771 {
772   if (iter->mode == OPERAND_ITERATOR_STANDARD)
773     {
774       if (*iter->state.standard.opidx == 0)
775         {
776           *operand = NULL;
777           return FALSE;
778         }
779
780       *operand = &arc_operands[*iter->state.standard.opidx];
781       *value = extract_operand_value (*operand, iter->insn);
782       iter->state.standard.opidx++;
783     }
784   else
785     {
786       const struct arc_operand *operand_base, *operand_limm;
787       int value_base, value_limm;
788
789       if (*iter->state.long_insn.opidx_limm == 0)
790         {
791           *operand = NULL;
792           return FALSE;
793         }
794
795       operand_base = &arc_operands[*iter->state.long_insn.opidx_base];
796       operand_limm = &arc_operands[*iter->state.long_insn.opidx_limm];
797
798       if (operand_base->flags & ARC_OPERAND_LIMM)
799         {
800           /* We've reached the end of the operand list.  */
801           *operand = NULL;
802           return FALSE;
803         }
804
805       value_base = value_limm = 0;
806       if (!(operand_limm->flags & ARC_OPERAND_IGNORE))
807         {
808           /* This should never happen.  If it does then the use of
809              extract_operand_value below will access memory beyond
810              the insn array.  */
811           assert ((operand_limm->flags & ARC_OPERAND_LIMM) == 0);
812
813           *operand = operand_limm;
814           value_limm = extract_operand_value (*operand, &iter->insn[1]);
815         }
816
817       if (!(operand_base->flags & ARC_OPERAND_IGNORE))
818         {
819           *operand = operand_base;
820           value_base = extract_operand_value (*operand, iter->insn);
821         }
822
823       /* This is a bit of a fudge.  There's no reason why simply ORing
824          together the two values is the right thing to do, however, for all
825          the cases we currently have, it is the right thing, so, for now,
826          I've put off solving the more complex problem.  */
827       *value = value_base | value_limm;
828
829       iter->state.long_insn.opidx_base++;
830       iter->state.long_insn.opidx_limm++;
831     }
832   return TRUE;
833 }
834
835 /* Helper for parsing the options.  */
836
837 static void
838 parse_option (char *option)
839 {
840   if (CONST_STRNEQ (option, "dsp"))
841     add_to_decodelist (DSP, NONE);
842
843   else if (CONST_STRNEQ (option, "spfp"))
844     add_to_decodelist (FLOAT, SPX);
845
846   else if (CONST_STRNEQ (option, "dpfp"))
847     add_to_decodelist (FLOAT, DPX);
848
849   else if (CONST_STRNEQ (option, "quarkse_em"))
850     add_to_decodelist (FLOAT, QUARKSE);
851
852   else if (CONST_STRNEQ (option, "fpuda"))
853     add_to_decodelist (FLOAT, DPA);
854
855   else if (CONST_STRNEQ (option, "fpud"))
856     {
857       add_to_decodelist (FLOAT, SP);
858       add_to_decodelist (FLOAT, CVT);
859     }
860
861   else if (CONST_STRNEQ (option, "fpus"))
862     {
863       add_to_decodelist (FLOAT, DP);
864       add_to_decodelist (FLOAT, CVT);
865     }
866   else
867     fprintf (stderr, _("Unrecognised disassembler option: %s\n"), option);
868 }
869
870 /* Go over the options list and parse it.  */
871
872 static void
873 parse_disassembler_options (char *options)
874 {
875   if (options == NULL)
876     return;
877
878   while (*options)
879     {
880       /* Skip empty options.  */
881       if (*options == ',')
882         {
883           ++ options;
884           continue;
885         }
886
887       parse_option (options);
888
889       while (*options != ',' && *options != '\0')
890         ++ options;
891     }
892 }
893
894 /* Disassemble ARC instructions.  */
895
896 static int
897 print_insn_arc (bfd_vma memaddr,
898                 struct disassemble_info *info)
899 {
900   bfd_byte buffer[4];
901   unsigned int lowbyte, highbyte;
902   int status;
903   unsigned int insn_len;
904   unsigned insn[2] = { 0, 0 };
905   unsigned isa_mask;
906   const struct arc_opcode *opcode;
907   bfd_boolean need_comma;
908   bfd_boolean open_braket;
909   int size;
910   const struct arc_operand *operand;
911   int value;
912   struct arc_operand_iterator iter;
913   Elf_Internal_Ehdr *header = NULL;
914
915   if (info->disassembler_options)
916     {
917       parse_disassembler_options (info->disassembler_options);
918
919       /* Avoid repeated parsing of the options.  */
920       info->disassembler_options = NULL;
921     }
922
923   memset (&iter, 0, sizeof (iter));
924   highbyte  = ((info->endian == BFD_ENDIAN_LITTLE) ? 1 : 0);
925   lowbyte = ((info->endian == BFD_ENDIAN_LITTLE) ? 0 : 1);
926
927   if (info->section && info->section->owner)
928     header = elf_elfheader (info->section->owner);
929
930   switch (info->mach)
931     {
932     case bfd_mach_arc_arc700:
933       isa_mask = ARC_OPCODE_ARC700;
934       break;
935
936     case bfd_mach_arc_arc600:
937       isa_mask = ARC_OPCODE_ARC600;
938       break;
939
940     case bfd_mach_arc_arcv2:
941     default:
942       isa_mask = ARC_OPCODE_ARCv2EM;
943       /* TODO: Perhaps remove defitinion of header since it is only used at
944          this location.  */
945       if (header != NULL
946           && (header->e_flags & EF_ARC_MACH_MSK) == EF_ARC_CPU_ARCV2HS)
947         {
948           isa_mask = ARC_OPCODE_ARCv2HS;
949           /* FPU instructions are not extensions for HS.  */
950           add_to_decodelist (FLOAT, SP);
951           add_to_decodelist (FLOAT, DP);
952           add_to_decodelist (FLOAT, CVT);
953         }
954       break;
955     }
956
957   /* This variable may be set by the instruction decoder.  It suggests
958      the number of bytes objdump should display on a single line.  If
959      the instruction decoder sets this, it should always set it to
960      the same value in order to get reasonable looking output.  */
961
962   info->bytes_per_line  = 8;
963
964   /* In the next lines, we set two info variables control the way
965      objdump displays the raw data.  For example, if bytes_per_line is
966      8 and bytes_per_chunk is 4, the output will look like this:
967      00:   00000000 00000000
968      with the chunks displayed according to "display_endian".  */
969
970   if (info->section
971       && !(info->section->flags & SEC_CODE))
972     {
973       /* This is not a CODE section.  */
974       switch (info->section->size)
975         {
976         case 1:
977         case 2:
978         case 4:
979           size = info->section->size;
980           break;
981         default:
982           size = (info->section->size & 0x01) ? 1 : 4;
983           break;
984         }
985       info->bytes_per_chunk = 1;
986       info->display_endian = info->endian;
987     }
988   else
989     {
990       size = 2;
991       info->bytes_per_chunk = 2;
992       info->display_endian = info->endian;
993     }
994
995   /* Read the insn into a host word.  */
996   status = (*info->read_memory_func) (memaddr, buffer, size, info);
997   if (status != 0)
998     {
999       (*info->memory_error_func) (status, memaddr, info);
1000       return -1;
1001     }
1002
1003   if (info->section
1004       && !(info->section->flags & SEC_CODE))
1005     {
1006       /* Data section.  */
1007       unsigned long data;
1008
1009       data = bfd_get_bits (buffer, size * 8,
1010                            info->display_endian == BFD_ENDIAN_BIG);
1011       switch (size)
1012         {
1013         case 1:
1014           (*info->fprintf_func) (info->stream, ".byte\t0x%02lx", data);
1015           break;
1016         case 2:
1017           (*info->fprintf_func) (info->stream, ".short\t0x%04lx", data);
1018           break;
1019         case 4:
1020           (*info->fprintf_func) (info->stream, ".word\t0x%08lx", data);
1021           break;
1022         default:
1023           abort ();
1024         }
1025       return size;
1026     }
1027
1028   insn_len = arc_insn_length (buffer[highbyte], buffer[lowbyte], info);
1029   pr_debug ("instruction length = %d bytes\n", insn_len);
1030
1031   switch (insn_len)
1032     {
1033     case 2:
1034       insn[0] = (buffer[highbyte] << 8) | buffer[lowbyte];
1035       break;
1036
1037     default:
1038       /* An unknown instruction is treated as being length 4.  This is
1039          possibly not the best solution, but matches the behaviour that was
1040          in place before the table based instruction length look-up was
1041          introduced.  */
1042     case 4:
1043       /* This is a long instruction: Read the remaning 2 bytes.  */
1044       status = (*info->read_memory_func) (memaddr + 2, &buffer[2], 2, info);
1045       if (status != 0)
1046         {
1047           (*info->memory_error_func) (status, memaddr + 2, info);
1048           return -1;
1049         }
1050       insn[0] = ARRANGE_ENDIAN (info, buffer);
1051       break;
1052     }
1053
1054   /* Set some defaults for the insn info.  */
1055   info->insn_info_valid    = 1;
1056   info->branch_delay_insns = 0;
1057   info->data_size          = 0;
1058   info->insn_type          = dis_nonbranch;
1059   info->target             = 0;
1060   info->target2            = 0;
1061
1062   /* FIXME to be moved in dissasemble_init_for_target.  */
1063   info->disassembler_needs_relocs = TRUE;
1064
1065   /* Find the first match in the opcode table.  */
1066   if (!find_format (memaddr, insn, &insn_len, isa_mask, info, &opcode, &iter))
1067     return -1;
1068
1069   if (!opcode)
1070     {
1071       if (insn_len == 2)
1072         (*info->fprintf_func) (info->stream, ".long %#04x", insn[0]);
1073       else
1074         (*info->fprintf_func) (info->stream, ".long %#08x", insn[0]);
1075
1076       info->insn_type = dis_noninsn;
1077       return insn_len;
1078     }
1079
1080   /* Print the mnemonic.  */
1081   (*info->fprintf_func) (info->stream, "%s", opcode->name);
1082
1083   /* Preselect the insn class.  */
1084   switch (opcode->insn_class)
1085     {
1086     case BRANCH:
1087     case JUMP:
1088       if (!strncmp (opcode->name, "bl", 2)
1089           || !strncmp (opcode->name, "jl", 2))
1090         {
1091           if (opcode->subclass == COND)
1092             info->insn_type = dis_condjsr;
1093           else
1094             info->insn_type = dis_jsr;
1095         }
1096       else
1097         {
1098           if (opcode->subclass == COND)
1099             info->insn_type = dis_condbranch;
1100           else
1101             info->insn_type = dis_branch;
1102         }
1103       break;
1104     case MEMORY:
1105       info->insn_type = dis_dref; /* FIXME! DB indicates mov as memory! */
1106       break;
1107     default:
1108       info->insn_type = dis_nonbranch;
1109       break;
1110     }
1111
1112   pr_debug ("%s: 0x%08x\n", opcode->name, opcode->opcode);
1113
1114   print_flags (opcode, insn, info);
1115
1116   if (opcode->operands[0] != 0)
1117     (*info->fprintf_func) (info->stream, "\t");
1118
1119   need_comma = FALSE;
1120   open_braket = FALSE;
1121
1122   /* Now extract and print the operands.  */
1123   operand = NULL;
1124   while (operand_iterator_next (&iter, &operand, &value))
1125     {
1126       if (open_braket && (operand->flags & ARC_OPERAND_BRAKET))
1127         {
1128           (*info->fprintf_func) (info->stream, "]");
1129           open_braket = FALSE;
1130           continue;
1131         }
1132
1133       /* Only take input from real operands.  */
1134       if (ARC_OPERAND_IS_FAKE (operand))
1135         continue;
1136
1137       if ((operand->flags & ARC_OPERAND_IGNORE)
1138           && (operand->flags & ARC_OPERAND_IR)
1139           && value == -1)
1140         continue;
1141
1142       if (operand->flags & ARC_OPERAND_COLON)
1143         {
1144           (*info->fprintf_func) (info->stream, ":");
1145           continue;
1146         }
1147
1148       if (need_comma)
1149         (*info->fprintf_func) (info->stream, ",");
1150
1151       if (!open_braket && (operand->flags & ARC_OPERAND_BRAKET))
1152         {
1153           (*info->fprintf_func) (info->stream, "[");
1154           open_braket = TRUE;
1155           need_comma = FALSE;
1156           continue;
1157         }
1158
1159       need_comma = TRUE;
1160
1161       /* Print the operand as directed by the flags.  */
1162       if (operand->flags & ARC_OPERAND_IR)
1163         {
1164           const char *rname;
1165
1166           assert (value >=0 && value < 64);
1167           rname = arcExtMap_coreRegName (value);
1168           if (!rname)
1169             rname = regnames[value];
1170           (*info->fprintf_func) (info->stream, "%s", rname);
1171           if (operand->flags & ARC_OPERAND_TRUNCATE)
1172             {
1173               rname = arcExtMap_coreRegName (value + 1);
1174               if (!rname)
1175                 rname = regnames[value + 1];
1176               (*info->fprintf_func) (info->stream, "%s", rname);
1177             }
1178         }
1179       else if (operand->flags & ARC_OPERAND_LIMM)
1180         {
1181           const char *rname = get_auxreg (opcode, value, isa_mask);
1182
1183           if (rname && open_braket)
1184             (*info->fprintf_func) (info->stream, "%s", rname);
1185           else
1186             {
1187               (*info->fprintf_func) (info->stream, "%#x", value);
1188               if (info->insn_type == dis_branch
1189                   || info->insn_type == dis_jsr)
1190                 info->target = (bfd_vma) value;
1191             }
1192         }
1193       else if (operand->flags & ARC_OPERAND_PCREL)
1194         {
1195            /* PCL relative.  */
1196           if (info->flags & INSN_HAS_RELOC)
1197             memaddr = 0;
1198           (*info->print_address_func) ((memaddr & ~3) + value, info);
1199
1200           info->target = (bfd_vma) (memaddr & ~3) + value;
1201         }
1202       else if (operand->flags & ARC_OPERAND_SIGNED)
1203         {
1204           const char *rname = get_auxreg (opcode, value, isa_mask);
1205           if (rname && open_braket)
1206             (*info->fprintf_func) (info->stream, "%s", rname);
1207           else
1208             (*info->fprintf_func) (info->stream, "%d", value);
1209         }
1210       else if (operand->flags & ARC_OPERAND_ADDRTYPE)
1211         {
1212           const char *addrtype = get_addrtype (value);
1213           (*info->fprintf_func) (info->stream, "%s", addrtype);
1214           /* A colon follow an address type.  */
1215           need_comma = FALSE;
1216         }
1217       else
1218         {
1219           if (operand->flags & ARC_OPERAND_TRUNCATE
1220               && !(operand->flags & ARC_OPERAND_ALIGNED32)
1221               && !(operand->flags & ARC_OPERAND_ALIGNED16)
1222               && value > 0 && value <= 14)
1223             (*info->fprintf_func) (info->stream, "r13-%s",
1224                                    regnames[13 + value - 1]);
1225           else
1226             {
1227               const char *rname = get_auxreg (opcode, value, isa_mask);
1228               if (rname && open_braket)
1229                 (*info->fprintf_func) (info->stream, "%s", rname);
1230               else
1231                 (*info->fprintf_func) (info->stream, "%#x", value);
1232             }
1233         }
1234     }
1235
1236   return insn_len;
1237 }
1238
1239
1240 disassembler_ftype
1241 arc_get_disassembler (bfd *abfd)
1242 {
1243   /* BFD my be absent, if opcodes is invoked from the debugger that
1244      has connected to remote target and doesn't have an ELF file.  */
1245   if (abfd != NULL)
1246     {
1247       /* Read the extension insns and registers, if any.  */
1248       build_ARC_extmap (abfd);
1249 #ifdef DEBUG
1250       dump_ARC_extmap ();
1251 #endif
1252     }
1253
1254   return print_insn_arc;
1255 }
1256
1257 /* Disassemble ARC instructions.  Used by debugger.  */
1258
1259 struct arcDisState
1260 arcAnalyzeInstr (bfd_vma memaddr,
1261                  struct disassemble_info *info)
1262 {
1263   struct arcDisState ret;
1264   memset (&ret, 0, sizeof (struct arcDisState));
1265
1266   ret.instructionLen = print_insn_arc (memaddr, info);
1267
1268 #if 0
1269   ret.words[0] = insn[0];
1270   ret.words[1] = insn[1];
1271   ret._this = &ret;
1272   ret.coreRegName = _coreRegName;
1273   ret.auxRegName = _auxRegName;
1274   ret.condCodeName = _condCodeName;
1275   ret.instName = _instName;
1276 #endif
1277
1278   return ret;
1279 }
1280
1281 void
1282 print_arc_disassembler_options (FILE *stream)
1283 {
1284   fprintf (stream, _("\n\
1285 The following ARC specific disassembler options are supported for use \n\
1286 with -M switch (multiple options should be separated by commas):\n"));
1287
1288   fprintf (stream, _("\
1289   dsp             Recognize DSP instructions.\n"));
1290   fprintf (stream, _("\
1291   spfp            Recognize FPX SP instructions.\n"));
1292   fprintf (stream, _("\
1293   dpfp            Recognize FPX DP instructions.\n"));
1294   fprintf (stream, _("\
1295   quarkse_em      Recognize FPU QuarkSE-EM instructions.\n"));
1296   fprintf (stream, _("\
1297   fpuda           Recognize double assist FPU instructions.\n"));
1298   fprintf (stream, _("\
1299   fpus            Recognize single precision FPU instructions.\n"));
1300   fprintf (stream, _("\
1301   fpud            Recognize double precision FPU instructions.\n"));
1302 }
1303
1304
1305 /* Local variables:
1306    eval: (c-set-style "gnu")
1307    indent-tabs-mode: t
1308    End:  */