Automatic date update in version.in
[external/binutils.git] / opcodes / cgen-dis.in
1 /* Disassembler interface for targets using CGEN. -*- C -*-
2    CGEN: Cpu tools GENerator
3
4    THIS FILE IS MACHINE GENERATED WITH CGEN.
5    - the resultant file is machine generated, cgen-dis.in isn't
6
7    Copyright (C) 1996-2019 Free Software Foundation, Inc.
8
9    This file is part of libopcodes.
10
11    This library is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 3, or (at your option)
14    any later version.
15
16    It is distributed in the hope that it will be useful, but WITHOUT
17    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
19    License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with this program; if not, write to the Free Software Foundation, Inc.,
23    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
24
25 /* ??? Eventually more and more of this stuff can go to cpu-independent files.
26    Keep that in mind.  */
27
28 #include "sysdep.h"
29 #include <stdio.h>
30 #include "ansidecl.h"
31 #include "disassemble.h"
32 #include "bfd.h"
33 #include "symcat.h"
34 #include "libiberty.h"
35 #include "@prefix@-desc.h"
36 #include "@prefix@-opc.h"
37 #include "opintl.h"
38
39 /* Default text to print if an instruction isn't recognized.  */
40 #define UNKNOWN_INSN_MSG _("*unknown*")
41
42 static void print_normal
43   (CGEN_CPU_DESC, void *, long, unsigned int, bfd_vma, int);
44 static void print_address
45   (CGEN_CPU_DESC, void *, bfd_vma, unsigned int, bfd_vma, int) ATTRIBUTE_UNUSED;
46 static void print_keyword
47   (CGEN_CPU_DESC, void *, CGEN_KEYWORD *, long, unsigned int) ATTRIBUTE_UNUSED;
48 static void print_insn_normal
49   (CGEN_CPU_DESC, void *, const CGEN_INSN *, CGEN_FIELDS *, bfd_vma, int);
50 static int print_insn
51   (CGEN_CPU_DESC, bfd_vma,  disassemble_info *, bfd_byte *, unsigned);
52 static int default_print_insn
53   (CGEN_CPU_DESC, bfd_vma, disassemble_info *) ATTRIBUTE_UNUSED;
54 static int read_insn
55   (CGEN_CPU_DESC, bfd_vma, disassemble_info *, bfd_byte *, int, CGEN_EXTRACT_INFO *,
56    unsigned long *);
57 \f
58 /* -- disassembler routines inserted here.  */
59 \f
60 /* Default print handler.  */
61
62 static void
63 print_normal (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
64               void *dis_info,
65               long value,
66               unsigned int attrs,
67               bfd_vma pc ATTRIBUTE_UNUSED,
68               int length ATTRIBUTE_UNUSED)
69 {
70   disassemble_info *info = (disassemble_info *) dis_info;
71
72   /* Print the operand as directed by the attributes.  */
73   if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
74     ; /* nothing to do */
75   else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
76     (*info->fprintf_func) (info->stream, "%ld", value);
77   else
78     (*info->fprintf_func) (info->stream, "0x%lx", value);
79 }
80
81 /* Default address handler.  */
82
83 static void
84 print_address (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
85                void *dis_info,
86                bfd_vma value,
87                unsigned int attrs,
88                bfd_vma pc ATTRIBUTE_UNUSED,
89                int length ATTRIBUTE_UNUSED)
90 {
91   disassemble_info *info = (disassemble_info *) dis_info;
92
93   /* Print the operand as directed by the attributes.  */
94   if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY))
95     ; /* Nothing to do.  */
96   else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_PCREL_ADDR))
97     (*info->print_address_func) (value, info);
98   else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_ABS_ADDR))
99     (*info->print_address_func) (value, info);
100   else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED))
101     (*info->fprintf_func) (info->stream, "%ld", (long) value);
102   else
103     (*info->fprintf_func) (info->stream, "0x%lx", (long) value);
104 }
105
106 /* Keyword print handler.  */
107
108 static void
109 print_keyword (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
110                void *dis_info,
111                CGEN_KEYWORD *keyword_table,
112                long value,
113                unsigned int attrs ATTRIBUTE_UNUSED)
114 {
115   disassemble_info *info = (disassemble_info *) dis_info;
116   const CGEN_KEYWORD_ENTRY *ke;
117
118   ke = cgen_keyword_lookup_value (keyword_table, value);
119   if (ke != NULL)
120     (*info->fprintf_func) (info->stream, "%s", ke->name);
121   else
122     (*info->fprintf_func) (info->stream, "???");
123 }
124 \f
125 /* Default insn printer.
126
127    DIS_INFO is defined as `void *' so the disassembler needn't know anything
128    about disassemble_info.  */
129
130 static void
131 print_insn_normal (CGEN_CPU_DESC cd,
132                    void *dis_info,
133                    const CGEN_INSN *insn,
134                    CGEN_FIELDS *fields,
135                    bfd_vma pc,
136                    int length)
137 {
138   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
139   disassemble_info *info = (disassemble_info *) dis_info;
140   const CGEN_SYNTAX_CHAR_TYPE *syn;
141
142   CGEN_INIT_PRINT (cd);
143
144   for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
145     {
146       if (CGEN_SYNTAX_MNEMONIC_P (*syn))
147         {
148           (*info->fprintf_func) (info->stream, "%s", CGEN_INSN_MNEMONIC (insn));
149           continue;
150         }
151       if (CGEN_SYNTAX_CHAR_P (*syn))
152         {
153           (*info->fprintf_func) (info->stream, "%c", CGEN_SYNTAX_CHAR (*syn));
154           continue;
155         }
156
157       /* We have an operand.  */
158       @arch@_cgen_print_operand (cd, CGEN_SYNTAX_FIELD (*syn), info,
159                                  fields, CGEN_INSN_ATTRS (insn), pc, length);
160     }
161 }
162 \f
163 /* Subroutine of print_insn. Reads an insn into the given buffers and updates
164    the extract info.
165    Returns 0 if all is well, non-zero otherwise.  */
166
167 static int
168 read_insn (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
169            bfd_vma pc,
170            disassemble_info *info,
171            bfd_byte *buf,
172            int buflen,
173            CGEN_EXTRACT_INFO *ex_info,
174            unsigned long *insn_value)
175 {
176   int status = (*info->read_memory_func) (pc, buf, buflen, info);
177
178   if (status != 0)
179     {
180       (*info->memory_error_func) (status, pc, info);
181       return -1;
182     }
183
184   ex_info->dis_info = info;
185   ex_info->valid = (1 << buflen) - 1;
186   ex_info->insn_bytes = buf;
187
188   *insn_value = bfd_get_bits (buf, buflen * 8, info->endian == BFD_ENDIAN_BIG);
189   return 0;
190 }
191
192 /* Utility to print an insn.
193    BUF is the base part of the insn, target byte order, BUFLEN bytes long.
194    The result is the size of the insn in bytes or zero for an unknown insn
195    or -1 if an error occurs fetching data (memory_error_func will have
196    been called).  */
197
198 static int
199 print_insn (CGEN_CPU_DESC cd,
200             bfd_vma pc,
201             disassemble_info *info,
202             bfd_byte *buf,
203             unsigned int buflen)
204 {
205   CGEN_INSN_INT insn_value;
206   const CGEN_INSN_LIST *insn_list;
207   CGEN_EXTRACT_INFO ex_info;
208   int basesize;
209
210   /* Extract base part of instruction, just in case CGEN_DIS_* uses it. */
211   basesize = cd->base_insn_bitsize < buflen * 8 ?
212                                      cd->base_insn_bitsize : buflen * 8;
213   insn_value = cgen_get_insn_value (cd, buf, basesize);
214
215
216   /* Fill in ex_info fields like read_insn would.  Don't actually call
217      read_insn, since the incoming buffer is already read (and possibly
218      modified a la m32r).  */
219   ex_info.valid = (1 << buflen) - 1;
220   ex_info.dis_info = info;
221   ex_info.insn_bytes = buf;
222
223   /* The instructions are stored in hash lists.
224      Pick the first one and keep trying until we find the right one.  */
225
226   insn_list = CGEN_DIS_LOOKUP_INSN (cd, (char *) buf, insn_value);
227   while (insn_list != NULL)
228     {
229       const CGEN_INSN *insn = insn_list->insn;
230       CGEN_FIELDS fields;
231       int length;
232       unsigned long insn_value_cropped;
233
234 #ifdef CGEN_VALIDATE_INSN_SUPPORTED
235       /* Not needed as insn shouldn't be in hash lists if not supported.  */
236       /* Supported by this cpu?  */
237       if (! @arch@_cgen_insn_supported (cd, insn))
238         {
239           insn_list = CGEN_DIS_NEXT_INSN (insn_list);
240           continue;
241         }
242 #endif
243
244       /* Basic bit mask must be correct.  */
245       /* ??? May wish to allow target to defer this check until the extract
246          handler.  */
247
248       /* Base size may exceed this instruction's size.  Extract the
249          relevant part from the buffer. */
250       if ((unsigned) (CGEN_INSN_BITSIZE (insn) / 8) < buflen &&
251           (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
252         insn_value_cropped = bfd_get_bits (buf, CGEN_INSN_BITSIZE (insn),
253                                            info->endian == BFD_ENDIAN_BIG);
254       else
255         insn_value_cropped = insn_value;
256
257       if ((insn_value_cropped & CGEN_INSN_BASE_MASK (insn))
258           == CGEN_INSN_BASE_VALUE (insn))
259         {
260           /* Printing is handled in two passes.  The first pass parses the
261              machine insn and extracts the fields.  The second pass prints
262              them.  */
263
264           /* Make sure the entire insn is loaded into insn_value, if it
265              can fit.  */
266           if (((unsigned) CGEN_INSN_BITSIZE (insn) > cd->base_insn_bitsize) &&
267               (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long))
268             {
269               unsigned long full_insn_value;
270               int rc = read_insn (cd, pc, info, buf,
271                                   CGEN_INSN_BITSIZE (insn) / 8,
272                                   & ex_info, & full_insn_value);
273               if (rc != 0)
274                 return rc;
275               length = CGEN_EXTRACT_FN (cd, insn)
276                 (cd, insn, &ex_info, full_insn_value, &fields, pc);
277             }
278           else
279             length = CGEN_EXTRACT_FN (cd, insn)
280               (cd, insn, &ex_info, insn_value_cropped, &fields, pc);
281
282           /* Length < 0 -> error.  */
283           if (length < 0)
284             return length;
285           if (length > 0)
286             {
287               CGEN_PRINT_FN (cd, insn) (cd, info, insn, &fields, pc, length);
288               /* Length is in bits, result is in bytes.  */
289               return length / 8;
290             }
291         }
292
293       insn_list = CGEN_DIS_NEXT_INSN (insn_list);
294     }
295
296   return 0;
297 }
298
299 /* Default value for CGEN_PRINT_INSN.
300    The result is the size of the insn in bytes or zero for an unknown insn
301    or -1 if an error occured fetching bytes.  */
302
303 #ifndef CGEN_PRINT_INSN
304 #define CGEN_PRINT_INSN default_print_insn
305 #endif
306
307 static int
308 default_print_insn (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info)
309 {
310   bfd_byte buf[CGEN_MAX_INSN_SIZE];
311   int buflen;
312   int status;
313
314   /* Attempt to read the base part of the insn.  */
315   buflen = cd->base_insn_bitsize / 8;
316   status = (*info->read_memory_func) (pc, buf, buflen, info);
317
318   /* Try again with the minimum part, if min < base.  */
319   if (status != 0 && (cd->min_insn_bitsize < cd->base_insn_bitsize))
320     {
321       buflen = cd->min_insn_bitsize / 8;
322       status = (*info->read_memory_func) (pc, buf, buflen, info);
323     }
324
325   if (status != 0)
326     {
327       (*info->memory_error_func) (status, pc, info);
328       return -1;
329     }
330
331   return print_insn (cd, pc, info, buf, buflen);
332 }
333
334 /* Main entry point.
335    Print one instruction from PC on INFO->STREAM.
336    Return the size of the instruction (in bytes).  */
337
338 typedef struct cpu_desc_list
339 {
340   struct cpu_desc_list *next;
341   CGEN_BITSET *isa;
342   int mach;
343   int endian;
344   CGEN_CPU_DESC cd;
345 } cpu_desc_list;
346
347 int
348 print_insn_@arch@ (bfd_vma pc, disassemble_info *info)
349 {
350   static cpu_desc_list *cd_list = 0;
351   cpu_desc_list *cl = 0;
352   static CGEN_CPU_DESC cd = 0;
353   static CGEN_BITSET *prev_isa;
354   static int prev_mach;
355   static int prev_endian;
356   int length;
357   CGEN_BITSET *isa;
358   int mach;
359   int endian = (info->endian == BFD_ENDIAN_BIG
360                 ? CGEN_ENDIAN_BIG
361                 : CGEN_ENDIAN_LITTLE);
362   enum bfd_architecture arch;
363
364   /* ??? gdb will set mach but leave the architecture as "unknown" */
365 #ifndef CGEN_BFD_ARCH
366 #define CGEN_BFD_ARCH bfd_arch_@arch@
367 #endif
368   arch = info->arch;
369   if (arch == bfd_arch_unknown)
370     arch = CGEN_BFD_ARCH;
371
372   /* There's no standard way to compute the machine or isa number
373      so we leave it to the target.  */
374 #ifdef CGEN_COMPUTE_MACH
375   mach = CGEN_COMPUTE_MACH (info);
376 #else
377   mach = info->mach;
378 #endif
379
380 #ifdef CGEN_COMPUTE_ISA
381   {
382     static CGEN_BITSET *permanent_isa;
383
384     if (!permanent_isa)
385       permanent_isa = cgen_bitset_create (MAX_ISAS);
386     isa = permanent_isa;
387     cgen_bitset_clear (isa);
388     cgen_bitset_add (isa, CGEN_COMPUTE_ISA (info));
389   }
390 #else
391   isa = info->insn_sets;
392 #endif
393
394   /* If we've switched cpu's, try to find a handle we've used before */
395   if (cd
396       && (cgen_bitset_compare (isa, prev_isa) != 0
397           || mach != prev_mach
398           || endian != prev_endian))
399     {
400       cd = 0;
401       for (cl = cd_list; cl; cl = cl->next)
402         {
403           if (cgen_bitset_compare (cl->isa, isa) == 0 &&
404               cl->mach == mach &&
405               cl->endian == endian)
406             {
407               cd = cl->cd;
408               prev_isa = cd->isas;
409               break;
410             }
411         }
412     }
413
414   /* If we haven't initialized yet, initialize the opcode table.  */
415   if (! cd)
416     {
417       const bfd_arch_info_type *arch_type = bfd_lookup_arch (arch, mach);
418       const char *mach_name;
419
420       if (!arch_type)
421         abort ();
422       mach_name = arch_type->printable_name;
423
424       prev_isa = cgen_bitset_copy (isa);
425       prev_mach = mach;
426       prev_endian = endian;
427       cd = @arch@_cgen_cpu_open (CGEN_CPU_OPEN_ISAS, prev_isa,
428                                  CGEN_CPU_OPEN_BFDMACH, mach_name,
429                                  CGEN_CPU_OPEN_ENDIAN, prev_endian,
430                                  CGEN_CPU_OPEN_END);
431       if (!cd)
432         abort ();
433
434       /* Save this away for future reference.  */
435       cl = xmalloc (sizeof (struct cpu_desc_list));
436       cl->cd = cd;
437       cl->isa = prev_isa;
438       cl->mach = mach;
439       cl->endian = endian;
440       cl->next = cd_list;
441       cd_list = cl;
442
443       @arch@_cgen_init_dis (cd);
444     }
445
446   /* We try to have as much common code as possible.
447      But at this point some targets need to take over.  */
448   /* ??? Some targets may need a hook elsewhere.  Try to avoid this,
449      but if not possible try to move this hook elsewhere rather than
450      have two hooks.  */
451   length = CGEN_PRINT_INSN (cd, pc, info);
452   if (length > 0)
453     return length;
454   if (length < 0)
455     return -1;
456
457   (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
458   return cd->default_insn_bitsize / 8;
459 }