Update the address and phone number of the FSF
[external/binutils.git] / opcodes / mmix-dis.c
1 /* mmix-dis.c -- Disassemble MMIX instructions.
2    Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
3    Written by Hans-Peter Nilsson (hp@bitrange.com)
4
5 This file is part of GDB and the GNU binutils.
6
7 GDB and the GNU binutils are free software; you can redistribute
8 them and/or modify them under the terms of the GNU General Public
9 License as published by the Free Software Foundation; either version 2,
10 or (at your option) any later version.
11
12 GDB and the GNU binutils are distributed in the hope that they
13 will be useful, but WITHOUT ANY WARRANTY; without even the implied
14 warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
15 the GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this file; see the file COPYING.  If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
20
21 #include <stdio.h>
22 #include <string.h>
23 #include <stdlib.h>
24 #include "opcode/mmix.h"
25 #include "dis-asm.h"
26 #include "libiberty.h"
27 #include "bfd.h"
28 #include "opintl.h"
29
30 #define BAD_CASE(x)                             \
31  do                                             \
32    {                                            \
33      fprintf (stderr,                           \
34               _("Bad case %d (%s) in %s:%d\n"), \
35               x, #x, __FILE__, __LINE__);       \
36      abort ();                                  \
37    }                                            \
38  while (0)
39
40 #define FATAL_DEBUG                                                             \
41  do                                                                             \
42    {                                                                            \
43      fprintf (stderr,                                                           \
44               _("Internal: Non-debugged code (test-case missing): %s:%d"),      \
45               __FILE__, __LINE__);                                              \
46      abort ();                                                                  \
47    }                                            \
48  while (0)
49
50 #define ROUND_MODE(n)                                   \
51  ((n) == 1 ? "ROUND_OFF" : (n) == 2 ? "ROUND_UP" :      \
52   (n) == 3 ? "ROUND_DOWN" : (n) == 4 ? "ROUND_NEAR" :   \
53   _("(unknown)"))
54
55 #define INSN_IMMEDIATE_BIT (IMM_OFFSET_BIT << 24)
56 #define INSN_BACKWARD_OFFSET_BIT (1 << 24)
57
58 struct mmix_dis_info
59  {
60    const char *reg_name[256];
61    const char *spec_reg_name[32];
62
63    /* Waste a little memory so we don't have to allocate each separately.
64       We could have an array with static contents for these, but on the
65       other hand, we don't have to.  */
66    char basic_reg_name[256][sizeof ("$255")];
67  };
68
69 static bfd_boolean initialize_mmix_dis_info
70   PARAMS ((struct disassemble_info *));
71 static const struct mmix_opcode *get_opcode
72   PARAMS ((unsigned long));
73
74
75 /* Initialize a target-specific array in INFO.  */
76
77 static bfd_boolean
78 initialize_mmix_dis_info (info)
79      struct disassemble_info *info;
80 {
81   struct mmix_dis_info *minfop = malloc (sizeof (struct mmix_dis_info));
82   int i;
83
84   if (minfop == NULL)
85     return FALSE;
86
87   memset (minfop, 0, sizeof (*minfop));
88
89   /* Initialize register names from register symbols.  If there's no
90      register section, then there are no register symbols.  */
91   if ((info->section != NULL && info->section->owner != NULL)
92       || (info->symbols != NULL
93           && info->symbols[0] != NULL
94           && bfd_asymbol_bfd (info->symbols[0]) != NULL))
95     {
96       bfd *abfd = info->section && info->section->owner != NULL
97         ? info->section->owner
98         : bfd_asymbol_bfd (info->symbols[0]);
99       asection *reg_section = bfd_get_section_by_name (abfd, "*REG*");
100
101       if (reg_section != NULL)
102         {
103           /* The returned symcount *does* include the ending NULL.  */
104           long symsize = bfd_get_symtab_upper_bound (abfd);
105           asymbol **syms = malloc (symsize);
106           long nsyms;
107           long i;
108
109           if (syms == NULL)
110             { FATAL_DEBUG;
111               free (minfop);
112               return FALSE;
113             }
114           nsyms = bfd_canonicalize_symtab (abfd, syms);
115
116           /* We use the first name for a register.  If this is MMO, then
117              it's the name with the first sequence number, presumably the
118              first in the source.  */
119           for (i = 0; i < nsyms && syms[i] != NULL; i++)
120             {
121               if (syms[i]->section == reg_section
122                   && syms[i]->value < 256
123                   && minfop->reg_name[syms[i]->value] == NULL)
124                 minfop->reg_name[syms[i]->value] = syms[i]->name;
125             }
126         }
127     }
128
129   /* Fill in the rest with the canonical names.  */
130   for (i = 0; i < 256; i++)
131     if (minfop->reg_name[i] == NULL)
132       {
133         sprintf (minfop->basic_reg_name[i], "$%d", i);
134         minfop->reg_name[i] = minfop->basic_reg_name[i];
135       }
136
137   /* We assume it's actually a one-to-one mapping of number-to-name.  */
138   for (i = 0; mmix_spec_regs[i].name != NULL; i++)
139     minfop->spec_reg_name[mmix_spec_regs[i].number] = mmix_spec_regs[i].name;
140
141   info->private_data = (PTR) minfop;
142   return TRUE;
143 }
144
145 /* A table indexed by the first byte is constructed as we disassemble each
146    tetrabyte.  The contents is a pointer into mmix_insns reflecting the
147    first found entry with matching match-bits and lose-bits.  Further
148    entries are considered one after one until the operand constraints
149    match or the match-bits and lose-bits do not match.  Normally a
150    "further entry" will just show that there was no other match.  */
151
152 static const struct mmix_opcode *
153 get_opcode (insn)
154      unsigned long insn;
155 {
156   static const struct mmix_opcode **opcodes = NULL;
157   const struct mmix_opcode *opcodep = mmix_opcodes;
158   unsigned int opcode_part = (insn >> 24) & 255;
159   if (opcodes == NULL)
160     opcodes = xcalloc (256, sizeof (struct mmix_opcode *));
161
162   opcodep = opcodes[opcode_part];
163   if (opcodep == NULL
164       || (opcodep->match & insn) != opcodep->match
165       || (opcodep->lose & insn) != 0)
166     {
167       /* Search through the table.  */
168       for (opcodep = mmix_opcodes; opcodep->name != NULL; opcodep++)
169         {
170           /* FIXME: Break out this into an initialization function.  */
171           if ((opcodep->match & (opcode_part << 24)) == opcode_part
172               && (opcodep->lose & (opcode_part << 24)) == 0)
173             opcodes[opcode_part] = opcodep;
174
175           if ((opcodep->match & insn) == opcodep->match
176               && (opcodep->lose & insn) == 0)
177             break;
178         }
179     }
180
181   if (opcodep->name == NULL)
182     return NULL;
183
184   /* Check constraints.  If they don't match, loop through the next opcode
185      entries.  */
186   do
187     {
188       switch (opcodep->operands)
189         {
190           /* These have no restraint on what can be in the lower three
191              bytes.  */
192         case mmix_operands_regs:
193         case mmix_operands_reg_yz:
194         case mmix_operands_regs_z_opt:
195         case mmix_operands_regs_z:
196         case mmix_operands_jmp:
197         case mmix_operands_pushgo:
198         case mmix_operands_pop:
199         case mmix_operands_sync:
200         case mmix_operands_x_regs_z:
201         case mmix_operands_neg:
202         case mmix_operands_pushj:
203         case mmix_operands_regaddr:
204         case mmix_operands_get:
205         case mmix_operands_set:
206         case mmix_operands_save:
207         case mmix_operands_unsave:
208         case mmix_operands_xyz_opt:
209           return opcodep;
210
211           /* For a ROUND_MODE, the middle byte must be 0..4.  */
212         case mmix_operands_roundregs_z:
213         case mmix_operands_roundregs:
214           {
215             int midbyte = (insn >> 8) & 255;
216             if (midbyte <= 4)
217               return opcodep;
218           }
219         break;
220
221         case mmix_operands_put:
222           /* A "PUT".  If it is "immediate", then no restrictions,
223              otherwise we have to make sure the register number is < 32.  */
224           if ((insn & INSN_IMMEDIATE_BIT)
225               || ((insn >> 16) & 255) < 32)
226             return opcodep;
227           break;
228
229         case mmix_operands_resume:
230           /* Middle bytes must be zero.  */
231           if ((insn & 0x00ffff00) == 0)
232             return opcodep;
233           break;
234
235         default:
236           BAD_CASE (opcodep->operands);
237         }
238
239       opcodep++;
240     }
241   while ((opcodep->match & insn) == opcodep->match
242          && (opcodep->lose & insn) == 0);
243
244   /* If we got here, we had no match.  */
245   return NULL;
246 }
247
248 /* The main disassembly function.  */
249
250 int
251 print_insn_mmix (memaddr, info)
252      bfd_vma memaddr;
253      struct disassemble_info *info;
254 {
255   unsigned char buffer[4];
256   unsigned long insn;
257   unsigned int x, y, z;
258   const struct mmix_opcode *opcodep;
259   int status = (*info->read_memory_func) (memaddr, buffer, 4, info);
260   struct mmix_dis_info *minfop;
261
262   if (status != 0)
263     {
264       (*info->memory_error_func) (status, memaddr, info);
265       return -1;
266     }
267
268   /* FIXME: Is -1 suitable?  */
269   if (info->private_data == NULL
270       && ! initialize_mmix_dis_info (info))
271     return -1;
272
273   minfop = (struct mmix_dis_info *) info->private_data;
274   x = buffer[1];
275   y = buffer[2];
276   z = buffer[3];
277
278   insn = bfd_getb32 (buffer);
279
280   opcodep = get_opcode (insn);
281
282   if (opcodep == NULL)
283     {
284       (*info->fprintf_func) (info->stream, _("*unknown*"));
285       return 4;
286     }
287
288   (*info->fprintf_func) (info->stream, "%s ", opcodep->name);
289
290   /* Present bytes in the order they are laid out in memory.  */
291   info->display_endian = BFD_ENDIAN_BIG;
292
293   info->insn_info_valid = 1;
294   info->bytes_per_chunk = 4;
295   info->branch_delay_insns = 0;
296   info->target = 0;
297   switch (opcodep->type)
298     {
299     case mmix_type_normal:
300     case mmix_type_memaccess_block:
301       info->insn_type = dis_nonbranch;
302       break;
303
304     case mmix_type_branch:
305       info->insn_type = dis_branch;
306       break;
307
308     case mmix_type_condbranch:
309       info->insn_type = dis_condbranch;
310       break;
311
312     case mmix_type_memaccess_octa:
313       info->insn_type = dis_dref;
314       info->data_size = 8;
315       break;
316
317     case mmix_type_memaccess_tetra:
318       info->insn_type = dis_dref;
319       info->data_size = 4;
320       break;
321
322     case mmix_type_memaccess_wyde:
323       info->insn_type = dis_dref;
324       info->data_size = 2;
325       break;
326
327     case mmix_type_memaccess_byte:
328       info->insn_type = dis_dref;
329       info->data_size = 1;
330       break;
331
332     case mmix_type_jsr:
333       info->insn_type = dis_jsr;
334       break;
335
336     default:
337       BAD_CASE(opcodep->type);
338     }
339
340   switch (opcodep->operands)
341     {
342     case mmix_operands_regs:
343       /*  All registers: "$X,$Y,$Z".  */
344       (*info->fprintf_func) (info->stream, "%s,%s,%s",
345                              minfop->reg_name[x],
346                              minfop->reg_name[y],
347                              minfop->reg_name[z]);
348       break;
349
350     case mmix_operands_reg_yz:
351       /* Like SETH - "$X,YZ".  */
352       (*info->fprintf_func) (info->stream, "%s,0x%x",
353                              minfop->reg_name[x], y * 256 + z);
354       break;
355
356     case mmix_operands_regs_z_opt:
357     case mmix_operands_regs_z:
358     case mmix_operands_pushgo:
359       /* The regular "$X,$Y,$Z|Z".  */
360       if (insn & INSN_IMMEDIATE_BIT)
361         (*info->fprintf_func) (info->stream, "%s,%s,%d",
362                                minfop->reg_name[x], minfop->reg_name[y], z);
363       else
364         (*info->fprintf_func) (info->stream, "%s,%s,%s",
365                                minfop->reg_name[x],
366                                minfop->reg_name[y],
367                                minfop->reg_name[z]);
368       break;
369
370     case mmix_operands_jmp:
371       /* Address; only JMP.  */
372       {
373         bfd_signed_vma offset = (x * 65536 + y * 256 + z) * 4;
374
375         if (insn & INSN_BACKWARD_OFFSET_BIT)
376           offset -= (256 * 65536) * 4;
377
378         info->target = memaddr + offset;
379         (*info->print_address_func) (memaddr + offset, info);
380       }
381       break;
382
383     case mmix_operands_roundregs_z:
384       /* Two registers, like FLOT, possibly with rounding: "$X,$Z|Z"
385          "$X,ROUND_MODE,$Z|Z".  */
386       if (y != 0)
387         {
388           if (insn & INSN_IMMEDIATE_BIT)
389             (*info->fprintf_func) (info->stream, "%s,%s,%d",
390                                    minfop->reg_name[x],
391                                    ROUND_MODE (y), z);
392           else
393             (*info->fprintf_func) (info->stream, "%s,%s,%s",
394                                    minfop->reg_name[x],
395                                    ROUND_MODE (y),
396                                    minfop->reg_name[z]);
397         }
398       else
399         {
400           if (insn & INSN_IMMEDIATE_BIT)
401             (*info->fprintf_func) (info->stream, "%s,%d",
402                                    minfop->reg_name[x], z);
403           else
404             (*info->fprintf_func) (info->stream, "%s,%s",
405                                    minfop->reg_name[x],
406                                    minfop->reg_name[z]);
407         }
408       break;
409
410     case mmix_operands_pop:
411       /* Like POP - "X,YZ".  */
412       (*info->fprintf_func) (info->stream, "%d,%d", x, y*256 + z);
413       break;
414
415     case mmix_operands_roundregs:
416       /* Two registers, possibly with rounding: "$X,$Z" or
417          "$X,ROUND_MODE,$Z".  */
418       if (y != 0)
419         (*info->fprintf_func) (info->stream, "%s,%s,%s",
420                                minfop->reg_name[x],
421                                ROUND_MODE (y),
422                                minfop->reg_name[z]);
423       else
424         (*info->fprintf_func) (info->stream, "%s,%s",
425                                minfop->reg_name[x],
426                                minfop->reg_name[z]);
427       break;
428
429     case mmix_operands_sync:
430         /* Like SYNC - "XYZ".  */
431       (*info->fprintf_func) (info->stream, "%u",
432                              x * 65536 + y * 256 + z);
433       break;
434
435     case mmix_operands_x_regs_z:
436       /* Like SYNCD - "X,$Y,$Z|Z".  */
437       if (insn & INSN_IMMEDIATE_BIT)
438         (*info->fprintf_func) (info->stream, "%d,%s,%d",
439                                x, minfop->reg_name[y], z);
440       else
441         (*info->fprintf_func) (info->stream, "%d,%s,%s",
442                                x, minfop->reg_name[y],
443                                minfop->reg_name[z]);
444       break;
445
446     case mmix_operands_neg:
447       /* Like NEG and NEGU - "$X,Y,$Z|Z".  */
448       if (insn & INSN_IMMEDIATE_BIT)
449         (*info->fprintf_func) (info->stream, "%s,%d,%d",
450                                minfop->reg_name[x], y, z);
451       else
452         (*info->fprintf_func) (info->stream, "%s,%d,%s",
453                                minfop->reg_name[x], y,
454                                minfop->reg_name[z]);
455       break;
456
457     case mmix_operands_pushj:
458     case mmix_operands_regaddr:
459       /* Like GETA or branches - "$X,Address".  */
460       {
461         bfd_signed_vma offset = (y * 256 + z) * 4;
462
463         if (insn & INSN_BACKWARD_OFFSET_BIT)
464           offset -= 65536 * 4;
465
466         info->target = memaddr + offset;
467
468         (*info->fprintf_func) (info->stream, "%s,", minfop->reg_name[x]);
469         (*info->print_address_func) (memaddr + offset, info);
470       }
471       break;
472
473     case mmix_operands_get:
474       /* GET - "X,spec_reg".  */
475       (*info->fprintf_func) (info->stream, "%s,%s",
476                              minfop->reg_name[x],
477                              minfop->spec_reg_name[z]);
478       break;
479
480     case mmix_operands_put:
481       /* PUT - "spec_reg,$Z|Z".  */
482       if (insn & INSN_IMMEDIATE_BIT)
483         (*info->fprintf_func) (info->stream, "%s,%d",
484                                minfop->spec_reg_name[x], z);
485       else
486         (*info->fprintf_func) (info->stream, "%s,%s",
487                                minfop->spec_reg_name[x],
488                                minfop->reg_name[z]);
489       break;
490
491     case mmix_operands_set:
492       /*  Two registers, "$X,$Y".  */
493       (*info->fprintf_func) (info->stream, "%s,%s",
494                              minfop->reg_name[x],
495                              minfop->reg_name[y]);
496       break;
497
498     case mmix_operands_save:
499       /* SAVE - "$X,0".  */
500       (*info->fprintf_func) (info->stream, "%s,0", minfop->reg_name[x]);
501       break;
502
503     case mmix_operands_unsave:
504       /* UNSAVE - "0,$Z".  */
505       (*info->fprintf_func) (info->stream, "0,%s", minfop->reg_name[z]);
506       break;
507
508     case mmix_operands_xyz_opt:
509       /* Like SWYM or TRAP - "X,Y,Z".  */
510       (*info->fprintf_func) (info->stream, "%d,%d,%d", x, y, z);
511       break;
512
513     case mmix_operands_resume:
514       /* Just "Z", like RESUME.  */
515       (*info->fprintf_func) (info->stream, "%d", z);
516       break;
517
518     default:
519       (*info->fprintf_func) (info->stream, _("*unknown operands type: %d*"),
520                              opcodep->operands);
521       break;
522     }
523
524   return 4;
525 }