toolchain/binutils/opcodes/sh64-dis.c

   1 /* Disassemble SH64 instructions.
   2    Copyright 2000, 2001, 2002, 2003 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 #include "dis-asm.h"
  21 #include "sysdep.h"
  22 #include "sh64-opc.h"
  23 #include "libiberty.h"
  24
  25 /* We need to refer to the ELF header structure.  */
  26 #include "elf-bfd.h"
  27 #include "elf/sh.h"
  28 #include "elf32-sh64.h"
  29
  30 #define ELF_MODE32_CODE_LABEL_P(SYM) \
  31  (((elf_symbol_type *) (SYM))->internal_elf_sym.st_other & STO_SH5_ISA32)
  32
  33 #define SAVED_MOVI_R(INFO) \
  34  (((struct sh64_disassemble_info *) ((INFO)->private_data))->address_reg)
  35
  36 #define SAVED_MOVI_IMM(INFO) \
  37  (((struct sh64_disassemble_info *) ((INFO)->private_data))->built_address)
  38
  39 struct sh64_disassemble_info
  40  {
  41    /* When we see a MOVI, we save the register and the value, and merge a
  42       subsequent SHORI and display the address, if there is one.  */
  43    unsigned int address_reg;
  44    bfd_signed_vma built_address;
  45
  46    /* This is the range decriptor for the current address.  It is kept
  47       around for the next call.  */
  48    sh64_elf_crange crange;
  49  };
  50
  51 /* Each item in the table is a mask to indicate which bits to be set
  52    to determine an instruction's operator.
  53    The index is as same as the instruction in the opcode table.
  54    Note that some archs have this as a field in the opcode table.  */
  55 static unsigned long *shmedia_opcode_mask_table;
  56
  57 static void initialize_shmedia_opcode_mask_table PARAMS ((void));
  58 static int print_insn_shmedia PARAMS ((bfd_vma, disassemble_info *));
  59 static const char *creg_name PARAMS ((int));
  60 static bfd_boolean init_sh64_disasm_info PARAMS ((struct disassemble_info *));
  61 static enum sh64_elf_cr_type sh64_get_contents_type_disasm
  62   PARAMS ((bfd_vma, struct disassemble_info *));
  63
  64 /* Initialize the SH64 opcode mask table for each instruction in SHmedia
  65    mode.  */
  66
  67 static void
  68 initialize_shmedia_opcode_mask_table ()
  69 {
  70   int n_opc;
  71   int n;
  72
  73   /* Calculate number of opcodes.  */
  74   for (n_opc = 0; shmedia_table[n_opc].name != NULL; n_opc++)
  75     ;
  76
  77   shmedia_opcode_mask_table
  78     = xmalloc (sizeof (shmedia_opcode_mask_table[0]) * n_opc);
  79
  80   for (n = 0; n < n_opc; n++)
  81     {
  82       int i;
  83
  84       unsigned long mask = 0;
  85
  86       for (i = 0; shmedia_table[n].arg[i] != A_NONE; i++)
  87         {
  88           int offset = shmedia_table[n].nibbles[i];
  89           int length;
  90
  91           switch (shmedia_table[n].arg[i])
  92             {
  93             case A_GREG_M:
  94             case A_GREG_N:
  95             case A_GREG_D:
  96             case A_CREG_K:
  97             case A_CREG_J:
  98             case A_FREG_G:
  99             case A_FREG_H:
 100             case A_FREG_F:
 101             case A_DREG_G:
 102             case A_DREG_H:
 103             case A_DREG_F:
 104             case A_FMREG_G:
 105             case A_FMREG_H:
 106             case A_FMREG_F:
 107             case A_FPREG_G:
 108             case A_FPREG_H:
 109             case A_FPREG_F:
 110             case A_FVREG_G:
 111             case A_FVREG_H:
 112             case A_FVREG_F:
 113             case A_REUSE_PREV:
 114               length = 6;
 115               break;
 116
 117             case A_TREG_A:
 118             case A_TREG_B:
 119               length = 3;
 120               break;
 121
 122             case A_IMMM:
 123               abort ();
 124               break;
 125
 126             case A_IMMU5:
 127               length = 5;
 128               break;
 129
 130             case A_IMMS6:
 131             case A_IMMU6:
 132             case A_IMMS6BY32:
 133               length = 6;
 134               break;
 135
 136             case A_IMMS10:
 137             case A_IMMS10BY1:
 138             case A_IMMS10BY2:
 139             case A_IMMS10BY4:
 140             case A_IMMS10BY8:
 141               length = 10;
 142               break;
 143
 144             case A_IMMU16:
 145             case A_IMMS16:
 146             case A_PCIMMS16BY4:
 147             case A_PCIMMS16BY4_PT:
 148               length = 16;
 149               break;
 150
 151             default:
 152               abort ();
 153               length = 0;
 154               break;
 155             }
 156
 157           if (length != 0)
 158             mask |= (0xffffffff >> (32 - length)) << offset;
 159         }
 160       shmedia_opcode_mask_table[n] = 0xffffffff & ~mask;
 161     }
 162 }
 163
 164 /* Get a predefined control-register-name, or return NULL.  */
 165
 166 const char *
 167 creg_name (cregno)
 168      int cregno;
 169 {
 170   const shmedia_creg_info *cregp;
 171
 172   /* If control register usage is common enough, change this to search a
 173      hash-table.  */
 174   for (cregp = shmedia_creg_table; cregp->name != NULL; cregp++)
 175     {
 176       if (cregp->cregno == cregno)
 177         return cregp->name;
 178     }
 179
 180   return NULL;
 181 }
 182
 183 /* Main function to disassemble SHmedia instructions.  */
 184
 185 static int
 186 print_insn_shmedia (memaddr, info)
 187      bfd_vma memaddr;
 188      struct disassemble_info *info;
 189 {
 190   fprintf_ftype fprintf_fn = info->fprintf_func;
 191   void *stream = info->stream;
 192
 193   unsigned char insn[4];
 194   unsigned long instruction;
 195   int status;
 196   int n;
 197   const shmedia_opcode_info *op;
 198   int i;
 199   unsigned int r = 0;
 200   long imm = 0;
 201   bfd_vma disp_pc_addr;
 202
 203   status = info->read_memory_func (memaddr, insn, 4, info);
 204
 205   /* If we can't read four bytes, something is wrong.  Display any data we
 206      can get as .byte:s.  */
 207   if (status != 0)
 208     {
 209       int i;
 210
 211       for (i = 0; i < 3; i++)
 212         {
 213           status = info->read_memory_func (memaddr + i, insn, 1, info);
 214           if (status != 0)
 215             break;
 216           (*fprintf_fn) (stream, "%s0x%02x",
 217                          i == 0 ? ".byte " : ", ",
 218                          insn[0]);
 219         }
 220
 221       return i ? i : -1;
 222     }
 223
 224   /* Rearrange the bytes to make up an instruction.  */
 225   if (info->endian == BFD_ENDIAN_LITTLE)
 226     instruction = bfd_getl32 (insn);
 227   else
 228     instruction = bfd_getb32 (insn);
 229
 230   /* FIXME: Searching could be implemented using a hash on relevant
 231      fields.  */
 232   for (n = 0, op = shmedia_table;
 233        op->name != NULL
 234        && ((instruction & shmedia_opcode_mask_table[n]) != op->opcode_base);
 235        n++, op++)
 236     ;
 237
 238   /* FIXME: We should also check register number constraints.  */
 239   if (op->name == NULL)
 240     {
 241       fprintf_fn (stream, ".long 0x%08x", instruction);
 242       return 4;
 243     }
 244
 245   fprintf_fn (stream, "%s\t", op->name);
 246
 247   for (i = 0; i < 3 && op->arg[i] != A_NONE; i++)
 248     {
 249       unsigned long temp = instruction >> op->nibbles[i];
 250       int by_number = 0;
 251
 252       if (i > 0 && op->arg[i] != A_REUSE_PREV)
 253         fprintf_fn (stream, ",");
 254
 255       switch (op->arg[i])
 256         {
 257         case A_REUSE_PREV:
 258           continue;
 259
 260         case A_GREG_M:
 261         case A_GREG_N:
 262         case A_GREG_D:
 263           r = temp & 0x3f;
 264           fprintf_fn (stream, "r%d", r);
 265           break;
 266
 267         case A_FVREG_F:
 268         case A_FVREG_G:
 269         case A_FVREG_H:
 270           r = temp & 0x3f;
 271           fprintf_fn (stream, "fv%d", r);
 272           break;
 273
 274         case A_FPREG_F:
 275         case A_FPREG_G:
 276         case A_FPREG_H:
 277           r = temp & 0x3f;
 278           fprintf_fn (stream, "fp%d", r);
 279           break;
 280
 281         case A_FMREG_F:
 282         case A_FMREG_G:
 283         case A_FMREG_H:
 284           r = temp & 0x3f;
 285           fprintf_fn (stream, "mtrx%d", r);
 286           break;
 287
 288         case A_CREG_K:
 289         case A_CREG_J:
 290           {
 291             const char *name;
 292             r = temp & 0x3f;
 293
 294             name = creg_name (r);
 295
 296             if (name != NULL)
 297               fprintf_fn (stream, "%s", name);
 298             else
 299               fprintf_fn (stream, "cr%d", r);
 300           }
 301           break;
 302
 303         case A_FREG_G:
 304         case A_FREG_H:
 305         case A_FREG_F:
 306           r = temp & 0x3f;
 307           fprintf_fn (stream, "fr%d", r);
 308           break;
 309
 310         case A_DREG_G:
 311         case A_DREG_H:
 312         case A_DREG_F:
 313           r = temp & 0x3f;
 314           fprintf_fn (stream, "dr%d", r);
 315           break;
 316
 317         case A_TREG_A:
 318         case A_TREG_B:
 319           r = temp & 0x7;
 320           fprintf_fn (stream, "tr%d", r);
 321           break;
 322
 323           /* A signed 6-bit number.  */
 324         case A_IMMS6:
 325           imm = temp & 0x3f;
 326           if (imm & (unsigned long) 0x20)
 327             imm |= ~(unsigned long) 0x3f;
 328           fprintf_fn (stream, "%d", imm);
 329           break;
 330
 331           /* A signed 6-bit number, multiplied by 32 when used.  */
 332         case A_IMMS6BY32:
 333           imm = temp & 0x3f;
 334           if (imm & (unsigned long) 0x20)
 335             imm |= ~(unsigned long) 0x3f;
 336           fprintf_fn (stream, "%d", imm * 32);
 337           break;
 338
 339           /* A signed 10-bit number, multiplied by 8 when used.  */
 340         case A_IMMS10BY8:
 341           by_number++;
 342           /* Fall through.  */
 343
 344           /* A signed 10-bit number, multiplied by 4 when used.  */
 345         case A_IMMS10BY4:
 346           by_number++;
 347           /* Fall through.  */
 348
 349           /* A signed 10-bit number, multiplied by 2 when used.  */
 350         case A_IMMS10BY2:
 351           by_number++;
 352           /* Fall through.  */
 353
 354           /* A signed 10-bit number.  */
 355         case A_IMMS10:
 356         case A_IMMS10BY1:
 357           imm = temp & 0x3ff;
 358           if (imm & (unsigned long) 0x200)
 359             imm |= ~(unsigned long) 0x3ff;
 360           imm <<= by_number;
 361           fprintf_fn (stream, "%d", imm);
 362           break;
 363
 364           /* A signed 16-bit number.  */
 365         case A_IMMS16:
 366           imm = temp & 0xffff;
 367           if (imm & (unsigned long) 0x8000)
 368             imm |= ~((unsigned long) 0xffff);
 369           fprintf_fn (stream, "%d", imm);
 370           break;
 371
 372           /* A PC-relative signed 16-bit number, multiplied by 4 when
 373              used.  */
 374         case A_PCIMMS16BY4:
 375           imm = temp & 0xffff;  /* 16 bits */
 376           if (imm & (unsigned long) 0x8000)
 377             imm |= ~(unsigned long) 0xffff;
 378           imm <<= 2;
 379           disp_pc_addr = (bfd_vma) imm + memaddr;
 380           (*info->print_address_func) (disp_pc_addr, info);
 381           break;
 382
 383           /* An unsigned 5-bit number.  */
 384         case A_IMMU5:
 385           imm = temp & 0x1f;
 386           fprintf_fn (stream, "%d", imm);
 387           break;
 388
 389           /* An unsigned 6-bit number.  */
 390         case A_IMMU6:
 391           imm = temp & 0x3f;
 392           fprintf_fn (stream, "%d", imm);
 393           break;
 394
 395           /* An unsigned 16-bit number.  */
 396         case A_IMMU16:
 397           imm = temp & 0xffff;
 398           fprintf_fn (stream, "%d", imm);
 399           break;
 400
 401         default:
 402           abort ();
 403           break;
 404         }
 405     }
 406
 407   /* FIXME: Looks like 32-bit values only are handled.
 408      FIXME: PC-relative numbers aren't handled correctly.  */
 409   if (op->opcode_base == (unsigned long) SHMEDIA_SHORI_OPC
 410       && SAVED_MOVI_R (info) == r)
 411     {
 412       asection *section = info->section;
 413
 414       /* Most callers do not set the section field correctly yet.  Revert
 415          to getting the section from symbols, if any. */
 416       if (section == NULL
 417           && info->symbols != NULL
 418           && bfd_asymbol_flavour (info->symbols[0]) == bfd_target_elf_flavour
 419           && ! bfd_is_und_section (bfd_get_section (info->symbols[0]))
 420           && ! bfd_is_abs_section (bfd_get_section (info->symbols[0])))
 421         section = bfd_get_section (info->symbols[0]);
 422
 423       /* Only guess addresses when the contents of this section is fully
 424          relocated.  Otherwise, the value will be zero or perhaps even
 425          bogus.  */
 426       if (section == NULL
 427           || section->owner == NULL
 428           || elf_elfheader (section->owner)->e_type == ET_EXEC)
 429         {
 430           bfd_signed_vma shori_addr;
 431
 432           shori_addr = SAVED_MOVI_IMM (info) << 16;
 433           shori_addr |= imm;
 434
 435           fprintf_fn (stream, "\t! 0x");
 436           (*info->print_address_func) (shori_addr, info);
 437         }
 438     }
 439
 440   if (op->opcode_base == SHMEDIA_MOVI_OPC)
 441     {
 442       SAVED_MOVI_IMM (info) = imm;
 443       SAVED_MOVI_R (info) = r;
 444     }
 445   else
 446     {
 447       SAVED_MOVI_IMM (info) = 0;
 448       SAVED_MOVI_R (info) = 255;
 449     }
 450
 451   return 4;
 452 }
 453
 454 /* Check the type of contents about to be disassembled.  This is like
 455    sh64_get_contents_type (which may be called from here), except that it
 456    takes the same arguments as print_insn_* and does what can be done if
 457    no section is available.  */
 458
 459 static enum sh64_elf_cr_type
 460 sh64_get_contents_type_disasm (memaddr, info)
 461      bfd_vma memaddr;
 462      struct disassemble_info *info;
 463 {
 464   struct sh64_disassemble_info *sh64_infop = info->private_data;
 465
 466   /* Perhaps we have a region from a previous probe and it still counts
 467      for this address?  */
 468   if (sh64_infop->crange.cr_type != CRT_NONE
 469       && memaddr >= sh64_infop->crange.cr_addr
 470       && memaddr < sh64_infop->crange.cr_addr + sh64_infop->crange.cr_size)
 471     return sh64_infop->crange.cr_type;
 472
 473   /* If we have a section, try and use it.  */
 474   if (info->section
 475       && bfd_get_flavour (info->section->owner) == bfd_target_elf_flavour)
 476     {
 477       enum sh64_elf_cr_type cr_type
 478         = sh64_get_contents_type (info->section, memaddr,
 479                                   &sh64_infop->crange);
 480
 481       if (cr_type != CRT_NONE)
 482         return cr_type;
 483     }
 484
 485   /* If we have symbols, we can try and get at a section from *that*.  */
 486   if (info->symbols != NULL
 487       && bfd_asymbol_flavour (info->symbols[0]) == bfd_target_elf_flavour
 488       && ! bfd_is_und_section (bfd_get_section (info->symbols[0]))
 489       && ! bfd_is_abs_section (bfd_get_section (info->symbols[0])))
 490     {
 491       enum sh64_elf_cr_type cr_type
 492         = sh64_get_contents_type (bfd_get_section (info->symbols[0]),
 493                                   memaddr, &sh64_infop->crange);
 494
 495       if (cr_type != CRT_NONE)
 496         return cr_type;
 497     }
 498
 499   /* We can make a reasonable guess based on the st_other field of a
 500      symbol; for a BranchTarget this is marked as STO_SH5_ISA32 and then
 501      it's most probably code there.  */
 502   if (info->symbols
 503       && bfd_asymbol_flavour (info->symbols[0]) == bfd_target_elf_flavour
 504       && elf_symbol_from (bfd_asymbol_bfd (info->symbols[0]),
 505                           info->symbols[0])->internal_elf_sym.st_other
 506       == STO_SH5_ISA32)
 507     return CRT_SH5_ISA32;
 508
 509   /* If all else fails, guess this is code and guess on the low bit set.  */
 510   return (memaddr & 1) == 1 ? CRT_SH5_ISA32 : CRT_SH5_ISA16;
 511 }
 512
 513 /* Initialize static and dynamic disassembly state.  */
 514
 515 static bfd_boolean
 516 init_sh64_disasm_info (info)
 517      struct disassemble_info *info;
 518 {
 519   struct sh64_disassemble_info *sh64_infop
 520     = calloc (sizeof (*sh64_infop), 1);
 521
 522   if (sh64_infop == NULL)
 523     return FALSE;
 524
 525   info->private_data = sh64_infop;
 526
 527   SAVED_MOVI_IMM (info) = 0;
 528   SAVED_MOVI_R (info) = 255;
 529
 530   if (shmedia_opcode_mask_table == NULL)
 531     initialize_shmedia_opcode_mask_table ();
 532
 533   return TRUE;
 534 }
 535
 536 /* Main entry to disassemble SHmedia instructions, given an endian set in
 537    INFO.  Note that the simulator uses this as the main entry and does not
 538    use any of the functions further below.  */
 539
 540 int
 541 print_insn_sh64x_media (memaddr, info)
 542      bfd_vma memaddr;
 543      struct disassemble_info *info;
 544 {
 545   if (info->private_data == NULL && ! init_sh64_disasm_info (info))
 546     return -1;
 547
 548   /* Make reasonable output.  */
 549   info->bytes_per_line = 4;
 550   info->bytes_per_chunk = 4;
 551
 552   return print_insn_shmedia (memaddr, info);
 553 }
 554
 555 /* Main entry to disassemble SHmedia insns.
 556    If we see an SHcompact instruction, return -2.  */
 557
 558 int
 559 print_insn_sh64 (memaddr, info)
 560      bfd_vma memaddr;
 561      struct disassemble_info *info;
 562 {
 563   enum bfd_endian endian = info->endian;
 564   enum sh64_elf_cr_type cr_type;
 565
 566   if (info->private_data == NULL && ! init_sh64_disasm_info (info))
 567     return -1;
 568
 569   cr_type = sh64_get_contents_type_disasm (memaddr, info);
 570   if (cr_type != CRT_SH5_ISA16)
 571     {
 572       int length = 4 - (memaddr % 4);
 573       info->display_endian = endian;
 574
 575       /* If we got an uneven address to indicate SHmedia, adjust it.  */
 576       if (cr_type == CRT_SH5_ISA32 && length == 3)
 577         memaddr--, length = 4;
 578
 579       /* Only disassemble on four-byte boundaries.  Addresses that are not
 580          a multiple of four can happen after a data region.  */
 581       if (cr_type == CRT_SH5_ISA32 && length == 4)
 582         return print_insn_sh64x_media (memaddr, info);
 583
 584       /* We get CRT_DATA *only* for data regions in a mixed-contents
 585          section.  For sections with data only, we get indication of one
 586          of the ISA:s.  You may think that we shouldn't disassemble
 587          section with only data if we can figure that out.  However, the
 588          disassembly function is by default not called for data-only
 589          sections, so if the user explicitly specified disassembly of a
 590          data section, that's what we should do.  */
 591       if (cr_type == CRT_DATA || length != 4)
 592         {
 593           int status;
 594           unsigned char data[4];
 595           struct sh64_disassemble_info *sh64_infop = info->private_data;
 596
 597           if (length == 4
 598               && sh64_infop->crange.cr_type != CRT_NONE
 599               && memaddr >= sh64_infop->crange.cr_addr
 600               && memaddr < (sh64_infop->crange.cr_addr
 601                             + sh64_infop->crange.cr_size))
 602             length
 603               = (sh64_infop->crange.cr_addr
 604                  + sh64_infop->crange.cr_size - memaddr);
 605
 606           status
 607             = (*info->read_memory_func) (memaddr, data,
 608                                          length >= 4 ? 4 : length, info);
 609
 610           if (status == 0 && length >= 4)
 611             {
 612               (*info->fprintf_func) (info->stream, ".long 0x%08lx",
 613                                      endian == BFD_ENDIAN_BIG
 614                                      ? (long) (bfd_getb32 (data))
 615                                      : (long) (bfd_getl32 (data)));
 616               return 4;
 617             }
 618           else
 619             {
 620               int i;
 621
 622               for (i = 0; i < length; i++)
 623                 {
 624                   status = info->read_memory_func (memaddr + i, data, 1, info);
 625                   if (status != 0)
 626                     break;
 627                   (*info->fprintf_func) (info->stream, "%s0x%02x",
 628                                          i == 0 ? ".byte " : ", ",
 629                                          data[0]);
 630                 }
 631
 632               return i ? i : -1;
 633             }
 634         }
 635     }
 636
 637   /* SH1 .. SH4 instruction, let caller handle it.  */
 638   return -2;
 639 }