opcodes error messages
[external/binutils.git] / opcodes / epiphany-dis.c
1 /* DO NOT EDIT!  -*- buffer-read-only: t -*- vi:set ro:  */
2 /* Disassembler interface for targets using CGEN. -*- C -*-
3    CGEN: Cpu tools GENerator
4
5    THIS FILE IS MACHINE GENERATED WITH CGEN.
6    - the resultant file is machine generated, cgen-dis.in isn't
7
8    Copyright (C) 1996-2018 Free Software Foundation, Inc.
9
10    This file is part of libopcodes.
11
12    This library is free software; you can redistribute it and/or modify
13    it under the terms of the GNU General Public License as published by
14    the Free Software Foundation; either version 3, or (at your option)
15    any later version.
16
17    It is distributed in the hope that it will be useful, but WITHOUT
18    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
19    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
20    License for more details.
21
22    You should have received a copy of the GNU General Public License
23    along with this program; if not, write to the Free Software Foundation, Inc.,
24    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
25
26 /* ??? Eventually more and more of this stuff can go to cpu-independent files.
27    Keep that in mind.  */
28
29 #include "sysdep.h"
30 #include <stdio.h>
31 #include "ansidecl.h"
32 #include "disassemble.h"
33 #include "bfd.h"
34 #include "symcat.h"
35 #include "libiberty.h"
36 #include "epiphany-desc.h"
37 #include "epiphany-opc.h"
38 #include "opintl.h"
39
40 /* Default text to print if an instruction isn't recognized.  */
41 #define UNKNOWN_INSN_MSG _("*unknown*")
42
43 static void print_normal
44   (CGEN_CPU_DESC, void *, long, unsigned int, bfd_vma, int);
45 static void print_address
46   (CGEN_CPU_DESC, void *, bfd_vma, unsigned int, bfd_vma, int) ATTRIBUTE_UNUSED;
47 static void print_keyword
48   (CGEN_CPU_DESC, void *, CGEN_KEYWORD *, long, unsigned int) ATTRIBUTE_UNUSED;
49 static void print_insn_normal
50   (CGEN_CPU_DESC, void *, const CGEN_INSN *, CGEN_FIELDS *, bfd_vma, int);
51 static int print_insn
52   (CGEN_CPU_DESC, bfd_vma,  disassemble_info *, bfd_byte *, unsigned);
53 static int default_print_insn
54   (CGEN_CPU_DESC, bfd_vma, disassemble_info *) ATTRIBUTE_UNUSED;
55 static int read_insn
56   (CGEN_CPU_DESC, bfd_vma, disassemble_info *, bfd_byte *, int, CGEN_EXTRACT_INFO *,
57    unsigned long *);
58 \f
59 /* -- disassembler routines inserted here.  */
60
61 /* -- dis.c */
62
63 #define CGEN_PRINT_INSN epiphany_print_insn
64
65 static int
66 epiphany_print_insn (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info)
67 {
68   bfd_byte buf[CGEN_MAX_INSN_SIZE];
69   int buflen;
70   int status;
71
72   info->bytes_per_chunk = 2;
73   info->bytes_per_line = 4;
74
75   /* Attempt to read the base part of the insn.  */
76   buflen = cd->base_insn_bitsize / 8;
77   status = (*info->read_memory_func) (pc, buf, buflen, info);
78
79   /* Try again with the minimum part, if min < base.  */
80   if (status != 0 && (cd->min_insn_bitsize < cd->base_insn_bitsize))
81     {
82       buflen = cd->min_insn_bitsize / 8;
83       status = (*info->read_memory_func) (pc, buf, buflen, info);
84     }
85
86   if (status != 0)
87     {
88       (*info->memory_error_func) (status, pc, info);
89       return -1;
90     }
91
92   return print_insn (cd, pc, info, buf, buflen);
93 }
94
95
96 static void
97 print_postindex (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
98                  void * dis_info,
99                  long value,
100                  unsigned int attrs ATTRIBUTE_UNUSED,
101                  bfd_vma pc ATTRIBUTE_UNUSED,
102                  int length ATTRIBUTE_UNUSED)
103 {
104   disassemble_info *info = (disassemble_info *) dis_info;
105   (*info->fprintf_func) (info->stream, value ? "-" : "+");
106 }
107
108 static void
109 print_simm_not_reg (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
110                     void * dis_info,
111                     long value,
112                     unsigned int attrs ATTRIBUTE_UNUSED,
113                     bfd_vma pc ATTRIBUTE_UNUSED,
114                     int length ATTRIBUTE_UNUSED)
115 {
116   print_address (cd, dis_info, value, attrs, pc, length);
117 }
118
119 static void
120 print_uimm_not_reg (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
121                     void * dis_info,
122                     unsigned long value,
123                     unsigned int attrs ATTRIBUTE_UNUSED,
124                     bfd_vma pc ATTRIBUTE_UNUSED,
125                     int length ATTRIBUTE_UNUSED)
126 {
127   disassemble_info *info = (disassemble_info *)dis_info;
128
129   if (value & 0x800)
130     (*info->fprintf_func) (info->stream, "-");
131
132   value &= 0x7ff;
133   print_address (cd, dis_info, value, attrs, pc, length);
134 }
135
136 \f
137 /* -- */
138
139 void epiphany_cgen_print_operand
140   (CGEN_CPU_DESC, int, PTR, CGEN_FIELDS *, void const *, bfd_vma, int);
141
142 /* Main entry point for printing operands.
143    XINFO is a `void *' and not a `disassemble_info *' to not put a requirement
144    of dis-asm.h on cgen.h.
145
146    This function is basically just a big switch statement.  Earlier versions
147    used tables to look up the function to use, but
148    - if the table contains both assembler and disassembler functions then
149      the disassembler contains much of the assembler and vice-versa,
150    - there's a lot of inlining possibilities as things grow,
151    - using a switch statement avoids the function call overhead.
152
153    This function could be moved into `print_insn_normal', but keeping it
154    separate makes clear the interface between `print_insn_normal' and each of
155    the handlers.  */
156
157 void
158 epiphany_cgen_print_operand (CGEN_CPU_DESC cd,
159                            int opindex,
160                            void * xinfo,
161                            CGEN_FIELDS *fields,
162                            void const *attrs ATTRIBUTE_UNUSED,
163                            bfd_vma pc,
164                            int length)
165 {
166   disassemble_info *info = (disassemble_info *) xinfo;
167
168   switch (opindex)
169     {
170     case EPIPHANY_OPERAND_DIRECTION :
171       print_postindex (cd, info, fields->f_addsubx, 0, pc, length);
172       break;
173     case EPIPHANY_OPERAND_DISP11 :
174       print_uimm_not_reg (cd, info, fields->f_disp11, 0|(1<<CGEN_OPERAND_VIRTUAL), pc, length);
175       break;
176     case EPIPHANY_OPERAND_DISP3 :
177       print_normal (cd, info, fields->f_disp3, 0, pc, length);
178       break;
179     case EPIPHANY_OPERAND_DPMI :
180       print_postindex (cd, info, fields->f_subd, 0, pc, length);
181       break;
182     case EPIPHANY_OPERAND_FRD :
183       print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rd, 0);
184       break;
185     case EPIPHANY_OPERAND_FRD6 :
186       print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rd6, 0|(1<<CGEN_OPERAND_VIRTUAL));
187       break;
188     case EPIPHANY_OPERAND_FRM :
189       print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rm, 0);
190       break;
191     case EPIPHANY_OPERAND_FRM6 :
192       print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rm6, 0|(1<<CGEN_OPERAND_VIRTUAL));
193       break;
194     case EPIPHANY_OPERAND_FRN :
195       print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rn, 0);
196       break;
197     case EPIPHANY_OPERAND_FRN6 :
198       print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rn6, 0|(1<<CGEN_OPERAND_VIRTUAL));
199       break;
200     case EPIPHANY_OPERAND_IMM16 :
201       print_address (cd, info, fields->f_imm16, 0|(1<<CGEN_OPERAND_RELAX)|(1<<CGEN_OPERAND_VIRTUAL), pc, length);
202       break;
203     case EPIPHANY_OPERAND_IMM8 :
204       print_address (cd, info, fields->f_imm8, 0|(1<<CGEN_OPERAND_RELAX), pc, length);
205       break;
206     case EPIPHANY_OPERAND_RD :
207       print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rd, 0);
208       break;
209     case EPIPHANY_OPERAND_RD6 :
210       print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rd6, 0|(1<<CGEN_OPERAND_VIRTUAL));
211       break;
212     case EPIPHANY_OPERAND_RM :
213       print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rm, 0);
214       break;
215     case EPIPHANY_OPERAND_RM6 :
216       print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rm6, 0|(1<<CGEN_OPERAND_VIRTUAL));
217       break;
218     case EPIPHANY_OPERAND_RN :
219       print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rn, 0);
220       break;
221     case EPIPHANY_OPERAND_RN6 :
222       print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rn6, 0|(1<<CGEN_OPERAND_VIRTUAL));
223       break;
224     case EPIPHANY_OPERAND_SD :
225       print_keyword (cd, info, & epiphany_cgen_opval_cr_names, fields->f_sd, 0);
226       break;
227     case EPIPHANY_OPERAND_SD6 :
228       print_keyword (cd, info, & epiphany_cgen_opval_cr_names, fields->f_sd6, 0|(1<<CGEN_OPERAND_VIRTUAL));
229       break;
230     case EPIPHANY_OPERAND_SDDMA :
231       print_keyword (cd, info, & epiphany_cgen_opval_crdma_names, fields->f_sd6, 0|(1<<CGEN_OPERAND_VIRTUAL));
232       break;
233     case EPIPHANY_OPERAND_SDMEM :
234       print_keyword (cd, info, & epiphany_cgen_opval_crmem_names, fields->f_sd6, 0|(1<<CGEN_OPERAND_VIRTUAL));
235       break;
236     case EPIPHANY_OPERAND_SDMESH :
237       print_keyword (cd, info, & epiphany_cgen_opval_crmesh_names, fields->f_sd6, 0|(1<<CGEN_OPERAND_VIRTUAL));
238       break;
239     case EPIPHANY_OPERAND_SHIFT :
240       print_normal (cd, info, fields->f_shift, 0, pc, length);
241       break;
242     case EPIPHANY_OPERAND_SIMM11 :
243       print_simm_not_reg (cd, info, fields->f_sdisp11, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_RELAX)|(1<<CGEN_OPERAND_VIRTUAL), pc, length);
244       break;
245     case EPIPHANY_OPERAND_SIMM24 :
246       print_address (cd, info, fields->f_simm24, 0|(1<<CGEN_OPERAND_RELAX)|(1<<CGEN_OPERAND_RELOC)|(1<<CGEN_OPERAND_PCREL_ADDR), pc, length);
247       break;
248     case EPIPHANY_OPERAND_SIMM3 :
249       print_simm_not_reg (cd, info, fields->f_sdisp3, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_RELAX), pc, length);
250       break;
251     case EPIPHANY_OPERAND_SIMM8 :
252       print_address (cd, info, fields->f_simm8, 0|(1<<CGEN_OPERAND_RELAX)|(1<<CGEN_OPERAND_RELOC)|(1<<CGEN_OPERAND_PCREL_ADDR), pc, length);
253       break;
254     case EPIPHANY_OPERAND_SN :
255       print_keyword (cd, info, & epiphany_cgen_opval_cr_names, fields->f_sn, 0);
256       break;
257     case EPIPHANY_OPERAND_SN6 :
258       print_keyword (cd, info, & epiphany_cgen_opval_cr_names, fields->f_sn6, 0|(1<<CGEN_OPERAND_VIRTUAL));
259       break;
260     case EPIPHANY_OPERAND_SNDMA :
261       print_keyword (cd, info, & epiphany_cgen_opval_crdma_names, fields->f_sn6, 0|(1<<CGEN_OPERAND_VIRTUAL));
262       break;
263     case EPIPHANY_OPERAND_SNMEM :
264       print_keyword (cd, info, & epiphany_cgen_opval_crmem_names, fields->f_sn6, 0|(1<<CGEN_OPERAND_VIRTUAL));
265       break;
266     case EPIPHANY_OPERAND_SNMESH :
267       print_keyword (cd, info, & epiphany_cgen_opval_crmesh_names, fields->f_sn6, 0|(1<<CGEN_OPERAND_VIRTUAL));
268       break;
269     case EPIPHANY_OPERAND_SWI_NUM :
270       print_uimm_not_reg (cd, info, fields->f_trap_num, 0, pc, length);
271       break;
272     case EPIPHANY_OPERAND_TRAPNUM6 :
273       print_normal (cd, info, fields->f_trap_num, 0, pc, length);
274       break;
275
276     default :
277       /* xgettext:c-format */
278       opcodes_error_handler
279         (_("internal error: unrecognized field %d while printing insn"),
280          opindex);
281       abort ();
282   }
283 }
284
285 cgen_print_fn * const epiphany_cgen_print_handlers[] =
286 {
287   print_insn_normal,
288 };
289
290
291 void
292 epiphany_cgen_init_dis (CGEN_CPU_DESC cd)
293 {
294   epiphany_cgen_init_opcode_table (cd);
295   epiphany_cgen_init_ibld_table (cd);
296   cd->print_handlers = & epiphany_cgen_print_handlers[0];
297   cd->print_operand = epiphany_cgen_print_operand;
298 }
299
300 \f
301 /* Default print handler.  */
302
303 static void
304 print_normal (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
305               void *dis_info,
306               long value,
307               unsigned int attrs,
308               bfd_vma pc ATTRIBUTE_UNUSED,
309               int length ATTRIBUTE_UNUSED)
310 {
311   disassemble_info *info = (disassemble_info *) dis_info;
312
313   /* Print the operand as directed by the attributes.  */
314   if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
315     ; /* nothing to do */
316   else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
317     (*info->fprintf_func) (info->stream, "%ld", value);
318   else
319     (*info->fprintf_func) (info->stream, "0x%lx", value);
320 }
321
322 /* Default address handler.  */
323
324 static void
325 print_address (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
326                void *dis_info,
327                bfd_vma value,
328                unsigned int attrs,
329                bfd_vma pc ATTRIBUTE_UNUSED,
330                int length ATTRIBUTE_UNUSED)
331 {
332   disassemble_info *info = (disassemble_info *) dis_info;
333
334   /* Print the operand as directed by the attributes.  */
335   if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
336     ; /* Nothing to do.  */
337   else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_PCREL_ADDR))
338     (*info->print_address_func) (value, info);
339   else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_ABS_ADDR))
340     (*info->print_address_func) (value, info);
341   else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
342     (*info->fprintf_func) (info->stream, "%ld", (long) value);
343   else
344     (*info->fprintf_func) (info->stream, "0x%lx", (long) value);
345 }
346
347 /* Keyword print handler.  */
348
349 static void
350 print_keyword (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
351                void *dis_info,
352                CGEN_KEYWORD *keyword_table,
353                long value,
354                unsigned int attrs ATTRIBUTE_UNUSED)
355 {
356   disassemble_info *info = (disassemble_info *) dis_info;
357   const CGEN_KEYWORD_ENTRY *ke;
358
359   ke = cgen_keyword_lookup_value (keyword_table, value);
360   if (ke != NULL)
361     (*info->fprintf_func) (info->stream, "%s", ke->name);
362   else
363     (*info->fprintf_func) (info->stream, "???");
364 }
365 \f
366 /* Default insn printer.
367
368    DIS_INFO is defined as `void *' so the disassembler needn't know anything
369    about disassemble_info.  */
370
371 static void
372 print_insn_normal (CGEN_CPU_DESC cd,
373                    void *dis_info,
374                    const CGEN_INSN *insn,
375                    CGEN_FIELDS *fields,
376                    bfd_vma pc,
377                    int length)
378 {
379   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
380   disassemble_info *info = (disassemble_info *) dis_info;
381   const CGEN_SYNTAX_CHAR_TYPE *syn;
382
383   CGEN_INIT_PRINT (cd);
384
385   for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
386     {
387       if (CGEN_SYNTAX_MNEMONIC_P (*syn))
388         {
389           (*info->fprintf_func) (info->stream, "%s", CGEN_INSN_MNEMONIC (insn));
390           continue;
391         }
392       if (CGEN_SYNTAX_CHAR_P (*syn))
393         {
394           (*info->fprintf_func) (info->stream, "%c", CGEN_SYNTAX_CHAR (*syn));
395           continue;
396         }
397
398       /* We have an operand.  */
399       epiphany_cgen_print_operand (cd, CGEN_SYNTAX_FIELD (*syn), info,
400                                  fields, CGEN_INSN_ATTRS (insn), pc, length);
401     }
402 }
403 \f
404 /* Subroutine of print_insn. Reads an insn into the given buffers and updates
405    the extract info.
406    Returns 0 if all is well, non-zero otherwise.  */
407
408 static int
409 read_insn (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
410            bfd_vma pc,
411            disassemble_info *info,
412            bfd_byte *buf,
413            int buflen,
414            CGEN_EXTRACT_INFO *ex_info,
415            unsigned long *insn_value)
416 {
417   int status = (*info->read_memory_func) (pc, buf, buflen, info);
418
419   if (status != 0)
420     {
421       (*info->memory_error_func) (status, pc, info);
422       return -1;
423     }
424
425   ex_info->dis_info = info;
426   ex_info->valid = (1 << buflen) - 1;
427   ex_info->insn_bytes = buf;
428
429   *insn_value = bfd_get_bits (buf, buflen * 8, info->endian == BFD_ENDIAN_BIG);
430   return 0;
431 }
432
433 /* Utility to print an insn.
434    BUF is the base part of the insn, target byte order, BUFLEN bytes long.
435    The result is the size of the insn in bytes or zero for an unknown insn
436    or -1 if an error occurs fetching data (memory_error_func will have
437    been called).  */
438
439 static int
440 print_insn (CGEN_CPU_DESC cd,
441             bfd_vma pc,
442             disassemble_info *info,
443             bfd_byte *buf,
444             unsigned int buflen)
445 {
446   CGEN_INSN_INT insn_value;
447   const CGEN_INSN_LIST *insn_list;
448   CGEN_EXTRACT_INFO ex_info;
449   int basesize;
450
451   /* Extract base part of instruction, just in case CGEN_DIS_* uses it. */
452   basesize = cd->base_insn_bitsize < buflen * 8 ?
453                                      cd->base_insn_bitsize : buflen * 8;
454   insn_value = cgen_get_insn_value (cd, buf, basesize);
455
456
457   /* Fill in ex_info fields like read_insn would.  Don't actually call
458      read_insn, since the incoming buffer is already read (and possibly
459      modified a la m32r).  */
460   ex_info.valid = (1 << buflen) - 1;
461   ex_info.dis_info = info;
462   ex_info.insn_bytes = buf;
463
464   /* The instructions are stored in hash lists.
465      Pick the first one and keep trying until we find the right one.  */
466
467   insn_list = CGEN_DIS_LOOKUP_INSN (cd, (char *) buf, insn_value);
468   while (insn_list != NULL)
469     {
470       const CGEN_INSN *insn = insn_list->insn;
471       CGEN_FIELDS fields;
472       int length;
473       unsigned long insn_value_cropped;
474
475 #ifdef CGEN_VALIDATE_INSN_SUPPORTED
476       /* Not needed as insn shouldn't be in hash lists if not supported.  */
477       /* Supported by this cpu?  */
478       if (! epiphany_cgen_insn_supported (cd, insn))
479         {
480           insn_list = CGEN_DIS_NEXT_INSN (insn_list);
481           continue;
482         }
483 #endif
484
485       /* Basic bit mask must be correct.  */
486       /* ??? May wish to allow target to defer this check until the extract
487          handler.  */
488
489       /* Base size may exceed this instruction's size.  Extract the
490          relevant part from the buffer. */
491       if ((unsigned) (CGEN_INSN_BITSIZE (insn) / 8) < buflen &&
492           (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
493         insn_value_cropped = bfd_get_bits (buf, CGEN_INSN_BITSIZE (insn),
494                                            info->endian == BFD_ENDIAN_BIG);
495       else
496         insn_value_cropped = insn_value;
497
498       if ((insn_value_cropped & CGEN_INSN_BASE_MASK (insn))
499           == CGEN_INSN_BASE_VALUE (insn))
500         {
501           /* Printing is handled in two passes.  The first pass parses the
502              machine insn and extracts the fields.  The second pass prints
503              them.  */
504
505           /* Make sure the entire insn is loaded into insn_value, if it
506              can fit.  */
507           if (((unsigned) CGEN_INSN_BITSIZE (insn) > cd->base_insn_bitsize) &&
508               (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
509             {
510               unsigned long full_insn_value;
511               int rc = read_insn (cd, pc, info, buf,
512                                   CGEN_INSN_BITSIZE (insn) / 8,
513                                   & ex_info, & full_insn_value);
514               if (rc != 0)
515                 return rc;
516               length = CGEN_EXTRACT_FN (cd, insn)
517                 (cd, insn, &ex_info, full_insn_value, &fields, pc);
518             }
519           else
520             length = CGEN_EXTRACT_FN (cd, insn)
521               (cd, insn, &ex_info, insn_value_cropped, &fields, pc);
522
523           /* Length < 0 -> error.  */
524           if (length < 0)
525             return length;
526           if (length > 0)
527             {
528               CGEN_PRINT_FN (cd, insn) (cd, info, insn, &fields, pc, length);
529               /* Length is in bits, result is in bytes.  */
530               return length / 8;
531             }
532         }
533
534       insn_list = CGEN_DIS_NEXT_INSN (insn_list);
535     }
536
537   return 0;
538 }
539
540 /* Default value for CGEN_PRINT_INSN.
541    The result is the size of the insn in bytes or zero for an unknown insn
542    or -1 if an error occured fetching bytes.  */
543
544 #ifndef CGEN_PRINT_INSN
545 #define CGEN_PRINT_INSN default_print_insn
546 #endif
547
548 static int
549 default_print_insn (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info)
550 {
551   bfd_byte buf[CGEN_MAX_INSN_SIZE];
552   int buflen;
553   int status;
554
555   /* Attempt to read the base part of the insn.  */
556   buflen = cd->base_insn_bitsize / 8;
557   status = (*info->read_memory_func) (pc, buf, buflen, info);
558
559   /* Try again with the minimum part, if min < base.  */
560   if (status != 0 && (cd->min_insn_bitsize < cd->base_insn_bitsize))
561     {
562       buflen = cd->min_insn_bitsize / 8;
563       status = (*info->read_memory_func) (pc, buf, buflen, info);
564     }
565
566   if (status != 0)
567     {
568       (*info->memory_error_func) (status, pc, info);
569       return -1;
570     }
571
572   return print_insn (cd, pc, info, buf, buflen);
573 }
574
575 /* Main entry point.
576    Print one instruction from PC on INFO->STREAM.
577    Return the size of the instruction (in bytes).  */
578
579 typedef struct cpu_desc_list
580 {
581   struct cpu_desc_list *next;
582   CGEN_BITSET *isa;
583   int mach;
584   int endian;
585   CGEN_CPU_DESC cd;
586 } cpu_desc_list;
587
588 int
589 print_insn_epiphany (bfd_vma pc, disassemble_info *info)
590 {
591   static cpu_desc_list *cd_list = 0;
592   cpu_desc_list *cl = 0;
593   static CGEN_CPU_DESC cd = 0;
594   static CGEN_BITSET *prev_isa;
595   static int prev_mach;
596   static int prev_endian;
597   int length;
598   CGEN_BITSET *isa;
599   int mach;
600   int endian = (info->endian == BFD_ENDIAN_BIG
601                 ? CGEN_ENDIAN_BIG
602                 : CGEN_ENDIAN_LITTLE);
603   enum bfd_architecture arch;
604
605   /* ??? gdb will set mach but leave the architecture as "unknown" */
606 #ifndef CGEN_BFD_ARCH
607 #define CGEN_BFD_ARCH bfd_arch_epiphany
608 #endif
609   arch = info->arch;
610   if (arch == bfd_arch_unknown)
611     arch = CGEN_BFD_ARCH;
612
613   /* There's no standard way to compute the machine or isa number
614      so we leave it to the target.  */
615 #ifdef CGEN_COMPUTE_MACH
616   mach = CGEN_COMPUTE_MACH (info);
617 #else
618   mach = info->mach;
619 #endif
620
621 #ifdef CGEN_COMPUTE_ISA
622   {
623     static CGEN_BITSET *permanent_isa;
624
625     if (!permanent_isa)
626       permanent_isa = cgen_bitset_create (MAX_ISAS);
627     isa = permanent_isa;
628     cgen_bitset_clear (isa);
629     cgen_bitset_add (isa, CGEN_COMPUTE_ISA (info));
630   }
631 #else
632   isa = info->insn_sets;
633 #endif
634
635   /* If we've switched cpu's, try to find a handle we've used before */
636   if (cd
637       && (cgen_bitset_compare (isa, prev_isa) != 0
638           || mach != prev_mach
639           || endian != prev_endian))
640     {
641       cd = 0;
642       for (cl = cd_list; cl; cl = cl->next)
643         {
644           if (cgen_bitset_compare (cl->isa, isa) == 0 &&
645               cl->mach == mach &&
646               cl->endian == endian)
647             {
648               cd = cl->cd;
649               prev_isa = cd->isas;
650               break;
651             }
652         }
653     }
654
655   /* If we haven't initialized yet, initialize the opcode table.  */
656   if (! cd)
657     {
658       const bfd_arch_info_type *arch_type = bfd_lookup_arch (arch, mach);
659       const char *mach_name;
660
661       if (!arch_type)
662         abort ();
663       mach_name = arch_type->printable_name;
664
665       prev_isa = cgen_bitset_copy (isa);
666       prev_mach = mach;
667       prev_endian = endian;
668       cd = epiphany_cgen_cpu_open (CGEN_CPU_OPEN_ISAS, prev_isa,
669                                  CGEN_CPU_OPEN_BFDMACH, mach_name,
670                                  CGEN_CPU_OPEN_ENDIAN, prev_endian,
671                                  CGEN_CPU_OPEN_END);
672       if (!cd)
673         abort ();
674
675       /* Save this away for future reference.  */
676       cl = xmalloc (sizeof (struct cpu_desc_list));
677       cl->cd = cd;
678       cl->isa = prev_isa;
679       cl->mach = mach;
680       cl->endian = endian;
681       cl->next = cd_list;
682       cd_list = cl;
683
684       epiphany_cgen_init_dis (cd);
685     }
686
687   /* We try to have as much common code as possible.
688      But at this point some targets need to take over.  */
689   /* ??? Some targets may need a hook elsewhere.  Try to avoid this,
690      but if not possible try to move this hook elsewhere rather than
691      have two hooks.  */
692   length = CGEN_PRINT_INSN (cd, pc, info);
693   if (length > 0)
694     return length;
695   if (length < 0)
696     return -1;
697
698   (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
699   return cd->default_insn_bitsize / 8;
700 }