opcodes/h8300-dis.c

   1 /* Disassemble h8300 instructions.
   2    Copyright 1993, 1994, 1996, 1998, 2000, 2001 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 #define DEFINE_TABLE
  19
  20 #include "sysdep.h"
  21 #define h8_opcodes h8ops
  22 #include "opcode/h8300.h"
  23 #include "dis-asm.h"
  24 #include "opintl.h"
  25
  26 static void bfd_h8_disassemble_init PARAMS ((void));
  27 static unsigned int bfd_h8_disassemble
  28   PARAMS ((bfd_vma, disassemble_info *, int));
  29
  30 /* Run through the opcodes and sort them into order to make them easy
  31    to disassemble.  */
  32 static void
  33 bfd_h8_disassemble_init ()
  34 {
  35   unsigned int i;
  36   struct h8_opcode *p;
  37
  38   for (p = h8_opcodes; p->name; p++)
  39     {
  40       int n1 = 0;
  41       int n2 = 0;
  42
  43       if ((int) p->data.nib[0] < 16)
  44         n1 = (int) p->data.nib[0];
  45       else
  46         n1 = 0;
  47
  48       if ((int) p->data.nib[1] < 16)
  49         n2 = (int) p->data.nib[1];
  50       else
  51         n2 = 0;
  52
  53       /* Just make sure there are an even number of nibbles in it, and
  54          that the count is the same as the length.  */
  55       for (i = 0; p->data.nib[i] != E; i++)
  56         ;
  57
  58       if (i & 1)
  59         abort ();
  60
  61       p->length = i / 2;
  62     }
  63 }
  64
  65 static unsigned int
  66 bfd_h8_disassemble (addr, info, mode)
  67      bfd_vma addr;
  68      disassemble_info *info;
  69      int mode;
  70 {
  71   /* Find the first entry in the table for this opcode.  */
  72   static CONST char *regnames[] =
  73     {
  74       "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
  75       "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l"
  76     };
  77   static CONST char *wregnames[] =
  78     {
  79       "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  80       "e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7"
  81     };
  82   static CONST char *lregnames[] =
  83     {
  84       "er0", "er1", "er2", "er3", "er4", "er5", "er6", "er7",
  85       "er0", "er1", "er2", "er3", "er4", "er5", "er6", "er7"
  86     };
  87   int rs = 0;
  88   int rd = 0;
  89   int rdisp = 0;
  90   int abs = 0;
  91   int bit = 0;
  92   int plen = 0;
  93   static boolean init = 0;
  94   struct h8_opcode *q;
  95   char CONST **pregnames = mode != 0 ? lregnames : wregnames;
  96   int status;
  97   int l;
  98   unsigned char data[20];
  99   void *stream = info->stream;
 100   fprintf_ftype fprintf = info->fprintf_func;
 101
 102   if (!init)
 103     {
 104       bfd_h8_disassemble_init ();
 105       init = 1;
 106     }
 107
 108   status = info->read_memory_func (addr, data, 2, info);
 109   if (status != 0)
 110     {
 111       info->memory_error_func (status, addr, info);
 112       return -1;
 113     }
 114
 115   for (l = 2; status == 0 && l < 10; l += 2)
 116     status = info->read_memory_func (addr + l, data + l, 2, info);
 117
 118   /* Find the exact opcode/arg combo.  */
 119   for (q = h8_opcodes; q->name; q++)
 120     {
 121       op_type *nib = q->data.nib;
 122       unsigned int len = 0;
 123
 124       while (1)
 125         {
 126           op_type looking_for = *nib;
 127           int thisnib = data[len >> 1];
 128
 129           thisnib = (len & 1) ? (thisnib & 0xf) : ((thisnib >> 4) & 0xf);
 130
 131           if (looking_for < 16 && looking_for >= 0)
 132             {
 133               if (looking_for != thisnib)
 134                 goto fail;
 135             }
 136           else
 137             {
 138               if ((int) looking_for & (int) B31)
 139                 {
 140                   if (!(((int) thisnib & 0x8) != 0))
 141                     goto fail;
 142
 143                   looking_for = (op_type) ((int) looking_for & ~(int) B31);
 144                 }
 145
 146               if ((int) looking_for & (int) B30)
 147                 {
 148                   if (!(((int) thisnib & 0x8) == 0))
 149                     goto fail;
 150
 151                   looking_for = (op_type) ((int) looking_for & ~(int) B30);
 152                 }
 153
 154               if (looking_for & DBIT)
 155                 {
 156                   /* Exclude adds/subs by looking at bit 0 and 2, and
 157                      make sure the operand size, either w or l,
 158                      matches by looking at bit 1.  */
 159                   if ((looking_for & 7) != (thisnib & 7))
 160                     goto fail;
 161
 162                   abs = (thisnib & 0x8) ? 2 : 1;
 163                 }
 164               else if (looking_for & (REG | IND | INC | DEC))
 165                 {
 166                   if (looking_for & SRC)
 167                     rs = thisnib;
 168                   else
 169                     rd = thisnib;
 170                 }
 171               else if (looking_for & L_16)
 172                 {
 173                   abs = (data[len >> 1]) * 256 + data[(len + 2) >> 1];
 174                   plen = 16;
 175                 }
 176               else if (looking_for & ABSJMP)
 177                 {
 178                   abs = (data[1] << 16) | (data[2] << 8) | (data[3]);
 179                 }
 180               else if (looking_for & MEMIND)
 181                 {
 182                   abs = data[1];
 183                 }
 184               else if (looking_for & L_32)
 185                 {
 186                   int i = len >> 1;
 187
 188                   abs = (data[i] << 24)
 189                     | (data[i + 1] << 16)
 190                     | (data[i + 2] << 8)
 191                     | (data[i + 3]);
 192
 193                   plen = 32;
 194                 }
 195               else if (looking_for & L_24)
 196                 {
 197                   int i = len >> 1;
 198
 199                   abs = (data[i] << 16) | (data[i + 1] << 8) | (data[i + 2]);
 200                   plen = 24;
 201                 }
 202               else if (looking_for & IGNORE)
 203                 {
 204                   ;
 205                 }
 206               else if (looking_for & DISPREG)
 207                 {
 208                   rdisp = thisnib;
 209                 }
 210               else if (looking_for & KBIT)
 211                 {
 212                   switch (thisnib)
 213                     {
 214                     case 9:
 215                       abs = 4;
 216                       break;
 217                     case 8:
 218                       abs = 2;
 219                       break;
 220                     case 0:
 221                       abs = 1;
 222                       break;
 223                     default:
 224                       goto fail;
 225                     }
 226                 }
 227               else if (looking_for & L_8)
 228                 {
 229                   plen = 8;
 230                   abs = data[len >> 1];
 231                 }
 232               else if (looking_for & L_3)
 233                 {
 234                   bit = thisnib & 0x7;
 235                 }
 236               else if (looking_for & L_2)
 237                 {
 238                   plen = 2;
 239                   abs = thisnib & 0x3;
 240                 }
 241               else if (looking_for & MACREG)
 242                 {
 243                   abs = (thisnib == 3);
 244                 }
 245               else if (looking_for == E)
 246                 {
 247                   int i;
 248
 249                   for (i = 0; i < q->length; i++)
 250                     fprintf (stream, "%02x ", data[i]);
 251
 252                   for (; i < 6; i++)
 253                     fprintf (stream, "   ");
 254
 255                   fprintf (stream, "%s\t", q->name);
 256
 257                   /* Gross.  Disgusting.  */
 258                   if (strcmp (q->name, "ldm.l") == 0)
 259                     {
 260                       int count, high;
 261
 262                       count = (data[1] >> 4) & 0x3;
 263                       high = data[3] & 0x7;
 264
 265                       fprintf (stream, "@sp+,er%d-er%d", high - count, high);
 266                       return q->length;
 267                     }
 268
 269                   if (strcmp (q->name, "stm.l") == 0)
 270                     {
 271                       int count, low;
 272
 273                       count = (data[1] >> 4) & 0x3;
 274                       low = data[3] & 0x7;
 275
 276                       fprintf (stream, "er%d-er%d,@-sp", low, low + count);
 277                       return q->length;
 278                     }
 279
 280                   /* Fill in the args.  */
 281                   {
 282                     op_type *args = q->args.nib;
 283                     int hadone = 0;
 284
 285                     while (*args != E)
 286                       {
 287                         int x = *args;
 288
 289                         if (hadone)
 290                           fprintf (stream, ",");
 291
 292                         if (x & L_3)
 293                           {
 294                             fprintf (stream, "#0x%x", (unsigned) bit);
 295                           }
 296                         else if (x & (IMM | KBIT | DBIT))
 297                           {
 298                             /* Bletch.  For shal #2,er0 and friends.  */
 299                             if (*(args + 1) & SRC_IN_DST)
 300                               abs = 2;
 301
 302                             fprintf (stream, "#0x%x", (unsigned) abs);
 303                           }
 304                         else if (x & REG)
 305                           {
 306                             int rn = (x & DST) ? rd : rs;
 307
 308                             switch (x & SIZE)
 309                               {
 310                               case L_8:
 311                                 fprintf (stream, "%s", regnames[rn]);
 312                                 break;
 313                               case L_16:
 314                                 fprintf (stream, "%s", wregnames[rn]);
 315                                 break;
 316                               case L_P:
 317                               case L_32:
 318                                 fprintf (stream, "%s", lregnames[rn]);
 319                                 break;
 320                               }
 321                           }
 322                         else if (x & MACREG)
 323                           {
 324                             fprintf (stream, "mac%c", abs ? 'l' : 'h');
 325                           }
 326                         else if (x & INC)
 327                           {
 328                             fprintf (stream, "@%s+", pregnames[rs]);
 329                           }
 330                         else if (x & DEC)
 331                           {
 332                             fprintf (stream, "@-%s", pregnames[rd]);
 333                           }
 334                         else if (x & IND)
 335                           {
 336                             int rn = (x & DST) ? rd : rs;
 337                             fprintf (stream, "@%s", pregnames[rn]);
 338                           }
 339                         else if (x & ABS8MEM)
 340                           {
 341                             fprintf (stream, "@0x%x:8", (unsigned) abs);
 342                           }
 343                         else if (x & (ABS | ABSJMP))
 344                           {
 345                             fprintf (stream, "@0x%x:%d", (unsigned) abs, plen);
 346                           }
 347                         else if (x & MEMIND)
 348                           {
 349                             fprintf (stream, "@@%d (%x)", abs, abs);
 350                           }
 351                         else if (x & PCREL)
 352                           {
 353                             if (x & L_16)
 354                               {
 355                                 abs += 2;
 356                                 fprintf (stream,
 357                                          ".%s%d (%x)",
 358                                          (short) abs > 0 ? "+" : "",
 359                                          (short) abs, addr + (short) abs + 2);
 360                               }
 361                             else
 362                               {
 363                                 fprintf (stream,
 364                                          ".%s%d (%x)",
 365                                          (char) abs > 0 ? "+" : "",
 366                                          (char) abs, addr + (char) abs + 2);
 367                               }
 368                           }
 369                         else if (x & DISP)
 370                           {
 371                             fprintf (stream, "@(0x%x:%d,%s)",
 372                                      abs, plen, pregnames[rdisp]);
 373                           }
 374                         else if (x & CCR)
 375                           {
 376                             fprintf (stream, "ccr");
 377                           }
 378                         else if (x & EXR)
 379                           {
 380                             fprintf (stream, "exr");
 381                           }
 382                         else
 383                           /* xgettext:c-format */
 384                           fprintf (stream, _("Hmmmm %x"), x);
 385
 386                         hadone = 1;
 387                         args++;
 388                       }
 389                   }
 390
 391                   return q->length;
 392                 }
 393               else
 394                 /* xgettext:c-format */
 395                 fprintf (stream, _("Don't understand %x \n"), looking_for);
 396             }
 397
 398           len++;
 399           nib++;
 400         }
 401
 402     fail:
 403       ;
 404     }
 405
 406   /* Fell off the end.  */
 407   fprintf (stream, "%02x %02x        .word\tH'%x,H'%x",
 408            data[0], data[1],
 409            data[0], data[1]);
 410   return 2;
 411 }
 412
 413 int
 414 print_insn_h8300 (addr, info)
 415      bfd_vma addr;
 416      disassemble_info *info;
 417 {
 418   return bfd_h8_disassemble (addr, info, 0);
 419 }
 420
 421 int
 422 print_insn_h8300h (addr, info)
 423      bfd_vma addr;
 424      disassemble_info *info;
 425 {
 426   return bfd_h8_disassemble (addr, info, 1);
 427 }
 428
 429 int
 430 print_insn_h8300s (addr, info)
 431      bfd_vma addr;
 432      disassemble_info *info;
 433 {
 434   return bfd_h8_disassemble (addr, info, 2);
 435 }