opcodes/h8500-dis.c

   1 /* Disassemble h8500 instructions.
   2    Copyright 1993, 1998, 2000, 2001, 2002, 2004 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 #include <stdio.h>
  19
  20 #define DISASSEMBLER_TABLE
  21 #define DEFINE_TABLE
  22
  23 #include "sysdep.h"
  24 #include "h8500-opc.h"
  25 #include "dis-asm.h"
  26 #include "opintl.h"
  27
  28 /* Maximum length of an instruction.  */
  29 #define MAXLEN 8
  30
  31 #include <setjmp.h>
  32
  33 static int fetch_data PARAMS ((struct disassemble_info *, bfd_byte *));
  34
  35 struct private
  36 {
  37   /* Points to first byte not fetched.  */
  38   bfd_byte *max_fetched;
  39   bfd_byte the_buffer[MAXLEN];
  40   bfd_vma insn_start;
  41   jmp_buf bailout;
  42 };
  43
  44 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
  45    to ADDR (exclusive) are valid.  Returns 1 for success, longjmps
  46    on error.  */
  47 #define FETCH_DATA(info, addr) \
  48   ((addr) <= ((struct private *)(info->private_data))->max_fetched \
  49    ? 1 : fetch_data ((info), (addr)))
  50
  51 static int
  52 fetch_data (info, addr)
  53      struct disassemble_info *info;
  54      bfd_byte *addr;
  55 {
  56   int status;
  57   struct private *priv = (struct private *) info->private_data;
  58   bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
  59
  60   status = (*info->read_memory_func) (start,
  61                                       priv->max_fetched,
  62                                       addr - priv->max_fetched,
  63                                       info);
  64   if (status != 0)
  65     {
  66       (*info->memory_error_func) (status, start, info);
  67       longjmp (priv->bailout, 1);
  68     }
  69   else
  70     priv->max_fetched = addr;
  71   return 1;
  72 }
  73
  74 static char *crname[] = { "sr", "ccr", "*", "br", "ep", "dp", "*", "tp" };
  75
  76 int
  77 print_insn_h8500 (addr, info)
  78      bfd_vma addr;
  79      disassemble_info *info;
  80 {
  81   const h8500_opcode_info *opcode;
  82   void *stream = info->stream;
  83   fprintf_ftype func = info->fprintf_func;
  84
  85   struct private priv;
  86   bfd_byte *buffer = priv.the_buffer;
  87
  88   info->private_data = (PTR) & priv;
  89   priv.max_fetched = priv.the_buffer;
  90   priv.insn_start = addr;
  91   if (setjmp (priv.bailout) != 0)
  92     /* Error return.  */
  93     return -1;
  94
  95   if (0)
  96     {
  97       static int one;
  98
  99       if (!one)
 100         {
 101           one = 1;
 102           for (opcode = h8500_table; opcode->name; opcode++)
 103             {
 104               if ((opcode->bytes[0].contents & 0x8) == 0)
 105                 printf ("%s\n", opcode->name);
 106             }
 107         }
 108     }
 109
 110   /* Run down the table to find the one which matches.  */
 111   for (opcode = h8500_table; opcode->name; opcode++)
 112     {
 113       int byte;
 114       int rn = 0;
 115       int rd = 0;
 116       int rs = 0;
 117       int disp = 0;
 118       int abs = 0;
 119       int imm = 0;
 120       int pcrel = 0;
 121       int qim = 0;
 122       int i;
 123       int cr = 0;
 124
 125       for (byte = 0; byte < opcode->length; byte++)
 126         {
 127           FETCH_DATA (info, buffer + byte + 1);
 128           if ((buffer[byte] & opcode->bytes[byte].mask)
 129               != (opcode->bytes[byte].contents))
 130             {
 131               goto next;
 132             }
 133           else
 134             {
 135               /* Extract any info parts.  */
 136               switch (opcode->bytes[byte].insert)
 137                 {
 138                 case 0:
 139                 case FP:
 140                   break;
 141                 default:
 142                   /* xgettext:c-format */
 143                   func (stream, _("can't cope with insert %d\n"),
 144                         opcode->bytes[byte].insert);
 145                   break;
 146                 case RN:
 147                   rn = buffer[byte] & 0x7;
 148                   break;
 149                 case RS:
 150                   rs = buffer[byte] & 0x7;
 151                   break;
 152                 case CRB:
 153                   cr = buffer[byte] & 0x7;
 154                   if (cr == 0)
 155                     goto next;
 156                   break;
 157                 case CRW:
 158                   cr = buffer[byte] & 0x7;
 159                   if (cr != 0)
 160                     goto next;
 161                   break;
 162                 case DISP16:
 163                   FETCH_DATA (info, buffer + byte + 2);
 164                   disp = (buffer[byte] << 8) | (buffer[byte + 1]);
 165                   break;
 166                 case FPIND_D8:
 167                 case DISP8:
 168                   disp = ((char) (buffer[byte]));
 169                   break;
 170                 case RD:
 171                 case RDIND:
 172                   rd = buffer[byte] & 0x7;
 173                   break;
 174                 case ABS24:
 175                   FETCH_DATA (info, buffer + byte + 3);
 176                   abs =
 177                     (buffer[byte] << 16)
 178                     | (buffer[byte + 1] << 8)
 179                     | (buffer[byte + 2]);
 180                   break;
 181                 case ABS16:
 182                   FETCH_DATA (info, buffer + byte + 2);
 183                   abs = (buffer[byte] << 8) | (buffer[byte + 1]);
 184                   break;
 185                 case ABS8:
 186                   abs = (buffer[byte]);
 187                   break;
 188                 case IMM16:
 189                   FETCH_DATA (info, buffer + byte + 2);
 190                   imm = (buffer[byte] << 8) | (buffer[byte + 1]);
 191                   break;
 192                 case IMM4:
 193                   imm = (buffer[byte]) & 0xf;
 194                   break;
 195                 case IMM8:
 196                 case RLIST:
 197                   imm = (buffer[byte]);
 198                   break;
 199                 case PCREL16:
 200                   FETCH_DATA (info, buffer + byte + 2);
 201                   pcrel = (buffer[byte] << 8) | (buffer[byte + 1]);
 202                   break;
 203                 case PCREL8:
 204                   pcrel = (buffer[byte]);
 205                   break;
 206                 case QIM:
 207                   switch (buffer[byte] & 0x7)
 208                     {
 209                     case 0:
 210                       qim = 1;
 211                       break;
 212                     case 1:
 213                       qim = 2;
 214                       break;
 215                     case 4:
 216                       qim = -1;
 217                       break;
 218                     case 5:
 219                       qim = -2;
 220                       break;
 221                     }
 222                   break;
 223
 224                 }
 225             }
 226         }
 227       /* We get here when all the masks have passed so we can output
 228          the operands.  */
 229       FETCH_DATA (info, buffer + opcode->length);
 230       (func) (stream, "%s\t", opcode->name);
 231       for (i = 0; i < opcode->nargs; i++)
 232         {
 233           if (i)
 234             (func) (stream, ",");
 235           switch (opcode->arg_type[i])
 236             {
 237             case FP:
 238               func (stream, "fp");
 239               break;
 240             case RNIND_D16:
 241               func (stream, "@(0x%x:16,r%d)", disp, rn);
 242               break;
 243             case RNIND_D8:
 244               func (stream, "@(0x%x:8 (%d),r%d)", disp & 0xff, disp, rn);
 245               break;
 246             case RDIND_D16:
 247               func (stream, "@(0x%x:16,r%d)", disp, rd);
 248               break;
 249             case RDIND_D8:
 250               func (stream, "@(0x%x:8 (%d), r%d)", disp & 0xff, disp, rd);
 251               break;
 252             case FPIND_D8:
 253               func (stream, "@(0x%x:8 (%d), fp)", disp & 0xff, disp, rn);
 254               break;
 255             case CRB:
 256             case CRW:
 257               func (stream, "%s", crname[cr]);
 258               break;
 259             case RN:
 260               func (stream, "r%d", rn);
 261               break;
 262             case RD:
 263               func (stream, "r%d", rd);
 264               break;
 265             case RS:
 266               func (stream, "r%d", rs);
 267               break;
 268             case RNDEC:
 269               func (stream, "@-r%d", rn);
 270               break;
 271             case RNINC:
 272               func (stream, "@r%d+", rn);
 273               break;
 274             case RNIND:
 275               func (stream, "@r%d", rn);
 276               break;
 277             case RDIND:
 278               func (stream, "@r%d", rd);
 279               break;
 280             case SPINC:
 281               func (stream, "@sp+");
 282               break;
 283             case SPDEC:
 284               func (stream, "@-sp");
 285               break;
 286             case ABS24:
 287               func (stream, "@0x%0x:24", abs);
 288               break;
 289             case ABS16:
 290               func (stream, "@0x%0x:16", abs & 0xffff);
 291               break;
 292             case ABS8:
 293               func (stream, "@0x%0x:8", abs & 0xff);
 294               break;
 295             case IMM16:
 296               func (stream, "#0x%0x:16", imm & 0xffff);
 297               break;
 298             case RLIST:
 299               {
 300                 int i;
 301                 int nc = 0;
 302                 func (stream, "(");
 303                 for (i = 0; i < 8; i++)
 304                   {
 305                     if (imm & (1 << i))
 306                       {
 307                         func (stream, "r%d", i);
 308                         if (nc)
 309                           func (stream, ",");
 310                         nc = 1;
 311                       }
 312                   }
 313                 func (stream, ")");
 314               }
 315               break;
 316             case IMM8:
 317               func (stream, "#0x%0x:8", imm & 0xff);
 318               break;
 319             case PCREL16:
 320               func (stream, "0x%0x:16",
 321                     (pcrel + addr + opcode->length) & 0xffff);
 322               break;
 323             case PCREL8:
 324               func (stream, "#0x%0x:8",
 325                     ((char) pcrel + addr + opcode->length) & 0xffff);
 326               break;
 327             case QIM:
 328               func (stream, "#%d:q", qim);
 329               break;
 330             case IMM4:
 331               func (stream, "#%d:4", imm);
 332               break;
 333             }
 334         }
 335       return opcode->length;
 336     next:
 337       ;
 338     }
 339
 340   /* Couldn't understand anything.  */
 341   /* xgettext:c-format */
 342   func (stream, _("%02x\t\t*unknown*"), buffer[0]);
 343   return 1;
 344 }