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