URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [opcodes/] [sh-dis.c] - Blame information for rev 1773

Go to most recent revision | Details | Compare with Previous | View Log


/* Disassemble SH instructions.
   Copyright 1993, 1994, 1995, 1997, 1998, 2000, 2001
   Free Software Foundation, Inc.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
#include <stdio.h>
#include "sysdep.h"
#define STATIC_TABLE
#define DEFINE_TABLE
 
#include "sh-opc.h"
#include "dis-asm.h"
 
static void print_movxy
  PARAMS ((sh_opcode_info *, int, int, fprintf_ftype, void *));
static void print_insn_ddt PARAMS ((int, struct disassemble_info *));
static void print_dsp_reg PARAMS ((int, fprintf_ftype, void *));
static void print_insn_ppi PARAMS ((int, struct disassemble_info *));
 
static void
print_movxy (op, rn, rm, fprintf_fn, stream)
     sh_opcode_info *op;
     int rn, rm;
     fprintf_ftype fprintf_fn;
     void *stream;
{
  int n;
 
  fprintf_fn (stream, "%s\t", op->name);
  for (n = 0; n < 2; n++)
    {
      switch (op->arg[n])
        {
        case A_IND_N:
          fprintf_fn (stream, "@r%d", rn);
          break;
        case A_INC_N:
          fprintf_fn (stream, "@r%d+", rn);
          break;
        case A_PMOD_N:
          fprintf_fn (stream, "@r%d+r8", rn);
          break;
        case A_PMODY_N:
          fprintf_fn (stream, "@r%d+r9", rn);
          break;
        case DSP_REG_M:
          fprintf_fn (stream, "a%c", '0' + rm);
          break;
        case DSP_REG_X:
          fprintf_fn (stream, "x%c", '0' + rm);
          break;
        case DSP_REG_Y:
          fprintf_fn (stream, "y%c", '0' + rm);
          break;
        default:
          abort ();
        }
      if (n == 0)
        fprintf_fn (stream, ",");
    }
}
 
/* Print a double data transfer insn.  INSN is just the lower three
   nibbles of the insn, i.e. field a and the bit that indicates if
   a parallel processing insn follows.
   Return nonzero if a field b of a parallel processing insns follows.  */
 
static void
print_insn_ddt (insn, info)
     int insn;
     struct disassemble_info *info;
{
  fprintf_ftype fprintf_fn = info->fprintf_func;
  void *stream = info->stream;
 
  /* If this is just a nop, make sure to emit something.  */
  if (insn == 0x000)
    fprintf_fn (stream, "nopx\tnopy");
 
  /* If a parallel processing insn was printed before,
     and we got a non-nop, emit a tab.  */
  if ((insn & 0x800) && (insn & 0x3ff))
    fprintf_fn (stream, "\t");
 
  /* Check if either the x or y part is invalid.  */
  if (((insn & 0xc) == 0 && (insn & 0x2a0))
      || ((insn & 3) == 0 && (insn & 0x150)))
    fprintf_fn (stream, ".word 0x%x", insn);
  else
    {
      static sh_opcode_info *first_movx, *first_movy;
      sh_opcode_info *opx, *opy;
      unsigned int insn_x, insn_y;
 
      if (! first_movx)
        {
          for (first_movx = sh_table; first_movx->nibbles[1] != MOVX;)
            first_movx++;
          for (first_movy = first_movx; first_movy->nibbles[1] != MOVY;)
            first_movy++;
        }
      insn_x = (insn >> 2) & 0xb;
      if (insn_x)
        {
          for (opx = first_movx; opx->nibbles[2] != insn_x;)
            opx++;
          print_movxy (opx, ((insn >> 9) & 1) + 4, (insn >> 7) & 1,
                       fprintf_fn, stream);
        }
      insn_y = (insn & 3) | ((insn >> 1) & 8);
      if (insn_y)
        {
          if (insn_x)
            fprintf_fn (stream, "\t");
          for (opy = first_movy; opy->nibbles[2] != insn_y;)
            opy++;
          print_movxy (opy, ((insn >> 8) & 1) + 6, (insn >> 6) & 1,
                       fprintf_fn, stream);
        }
    }
}
 
static void
print_dsp_reg (rm, fprintf_fn, stream)
     int rm;
     fprintf_ftype fprintf_fn;
     void *stream;
{
  switch (rm)
    {
    case A_A1_NUM:
      fprintf_fn (stream, "a1");
      break;
    case A_A0_NUM:
      fprintf_fn (stream, "a0");
      break;
    case A_X0_NUM:
      fprintf_fn (stream, "x0");
      break;
    case A_X1_NUM:
      fprintf_fn (stream, "x1");
      break;
    case A_Y0_NUM:
      fprintf_fn (stream, "y0");
      break;
    case A_Y1_NUM:
      fprintf_fn (stream, "y1");
      break;
    case A_M0_NUM:
      fprintf_fn (stream, "m0");
      break;
    case A_A1G_NUM:
      fprintf_fn (stream, "a1g");
      break;
    case A_M1_NUM:
      fprintf_fn (stream, "m1");
      break;
    case A_A0G_NUM:
      fprintf_fn (stream, "a0g");
      break;
    default:
      fprintf_fn (stream, "0x%x", rm);
      break;
    }
}
 
static void
print_insn_ppi (field_b, info)
     int field_b;
     struct disassemble_info *info;
{
  static char *sx_tab[] = { "x0", "x1", "a0", "a1" };
  static char *sy_tab[] = { "y0", "y1", "m0", "m1" };
  fprintf_ftype fprintf_fn = info->fprintf_func;
  void *stream = info->stream;
  unsigned int nib1, nib2, nib3;
  char *dc = NULL;
  sh_opcode_info *op;
 
  if ((field_b & 0xe800) == 0)
    {
      fprintf_fn (stream, "psh%c\t#%d,",
                  field_b & 0x1000 ? 'a' : 'l',
                  (field_b >> 4) & 127);
      print_dsp_reg (field_b & 0xf, fprintf_fn, stream);
      return;
    }
  if ((field_b & 0xc000) == 0x4000 && (field_b & 0x3000) != 0x1000)
    {
      static char *du_tab[] = { "x0", "y0", "a0", "a1" };
      static char *se_tab[] = { "x0", "x1", "y0", "a1" };
      static char *sf_tab[] = { "y0", "y1", "x0", "a1" };
      static char *sg_tab[] = { "m0", "m1", "a0", "a1" };
 
      if (field_b & 0x2000)
        {
          fprintf_fn (stream, "p%s %s,%s,%s\t",
                      (field_b & 0x1000) ? "add" : "sub",
                      sx_tab[(field_b >> 6) & 3],
                      sy_tab[(field_b >> 4) & 3],
                      du_tab[(field_b >> 0) & 3]);
        }
      fprintf_fn (stream, "pmuls%c%s,%s,%s",
                  field_b & 0x2000 ? ' ' : '\t',
                  se_tab[(field_b >> 10) & 3],
                  sf_tab[(field_b >>  8) & 3],
                  sg_tab[(field_b >>  2) & 3]);
      return;
    }
 
  nib1 = PPIC;
  nib2 = field_b >> 12 & 0xf;
  nib3 = field_b >> 8 & 0xf;
  switch (nib3 & 0x3)
    {
    case 0:
      dc = "";
      nib1 = PPI3;
      break;
    case 1:
      dc = "";
      break;
    case 2:
      dc = "dct ";
      nib3 -= 1;
      break;
    case 3:
      dc = "dcf ";
      nib3 -= 2;
      break;
    }
  for (op = sh_table; op->name; op++)
    {
      if (op->nibbles[1] == nib1
          && op->nibbles[2] == nib2
          && op->nibbles[3] == nib3)
        {
          int n;
 
          fprintf_fn (stream, "%s%s\t", dc, op->name);
          for (n = 0; n < 3 && op->arg[n] != A_END; n++)
            {
              if (n && op->arg[1] != A_END)
                fprintf_fn (stream, ",");
              switch (op->arg[n])
                {
                case DSP_REG_N:
                  print_dsp_reg (field_b & 0xf, fprintf_fn, stream);
                  break;
                case DSP_REG_X:
                  fprintf_fn (stream, sx_tab[(field_b >> 6) & 3]);
                  break;
                case DSP_REG_Y:
                  fprintf_fn (stream, sy_tab[(field_b >> 4) & 3]);
                  break;
                case A_MACH:
                  fprintf_fn (stream, "mach");
                  break;
                case A_MACL:
                  fprintf_fn (stream, "macl");
                  break;
                default:
                  abort ();
                }
            }
          return;
        }
    }
  /* Not found.  */
  fprintf_fn (stream, ".word 0x%x", field_b);
}
 
int
print_insn_sh (memaddr, info)
     bfd_vma memaddr;
     struct disassemble_info *info;
{
  fprintf_ftype fprintf_fn = info->fprintf_func;
  void *stream = info->stream;
  unsigned char insn[2];
  unsigned char nibs[4];
  int status;
  bfd_vma relmask = ~(bfd_vma) 0;
  sh_opcode_info *op;
  int target_arch;
 
  switch (info->mach)
    {
    case bfd_mach_sh:
      target_arch = arch_sh1;
      /* SH coff object files lack information about the machine type, so
         we end up with bfd_mach_sh unless it was set explicitly (which
         could have happended if this is a call from gdb or the simulator.)  */
      if (info->symbols
          && bfd_asymbol_flavour(*info->symbols) == bfd_target_coff_flavour)
        target_arch = arch_sh4;
      break;
    case bfd_mach_sh2:
      target_arch = arch_sh2;
      break;
    case bfd_mach_sh_dsp:
      target_arch = arch_sh_dsp;
      break;
    case bfd_mach_sh3:
      target_arch = arch_sh3;
      break;
    case bfd_mach_sh3_dsp:
      target_arch = arch_sh3_dsp;
      break;
    case bfd_mach_sh3e:
      target_arch = arch_sh3e;
      break;
    case bfd_mach_sh4:
      target_arch = arch_sh4;
      break;
    case bfd_mach_sh5:
#ifdef INCLUDE_SHMEDIA
      status = print_insn_sh64 (memaddr, info);
      if (status != -2)
        return status;
#endif
      /* When we get here for sh64, it's because we want to disassemble
         SHcompact, i.e. arch_sh4.  */
      target_arch = arch_sh4;
      break;
    default:
      abort ();
    }
 
  status = info->read_memory_func (memaddr, insn, 2, info);
 
  if (status != 0)
    {
      info->memory_error_func (status, memaddr, info);
      return -1;
    }
 
  if (info->endian == BFD_ENDIAN_LITTLE)
    {
      nibs[0] = (insn[1] >> 4) & 0xf;
      nibs[1] = insn[1] & 0xf;
 
      nibs[2] = (insn[0] >> 4) & 0xf;
      nibs[3] = insn[0] & 0xf;
    }
  else
    {
      nibs[0] = (insn[0] >> 4) & 0xf;
      nibs[1] = insn[0] & 0xf;
 
      nibs[2] = (insn[1] >> 4) & 0xf;
      nibs[3] = insn[1] & 0xf;
    }
 
  if (nibs[0] == 0xf && (nibs[1] & 4) == 0 && target_arch & arch_sh_dsp_up)
    {
      if (nibs[1] & 8)
        {
          int field_b;
 
          status = info->read_memory_func (memaddr + 2, insn, 2, info);
 
          if (status != 0)
            {
              info->memory_error_func (status, memaddr + 2, info);
              return -1;
            }
 
          if (info->endian == BFD_ENDIAN_LITTLE)
            field_b = insn[1] << 8 | insn[0];
          else
            field_b = insn[0] << 8 | insn[1];
 
          print_insn_ppi (field_b, info);
          print_insn_ddt ((nibs[1] << 8) | (nibs[2] << 4) | nibs[3], info);
          return 4;
        }
      print_insn_ddt ((nibs[1] << 8) | (nibs[2] << 4) | nibs[3], info);
      return 2;
    }
  for (op = sh_table; op->name; op++)
    {
      int n;
      int imm = 0;
      int rn = 0;
      int rm = 0;
      int rb = 0;
      int disp_pc;
      bfd_vma disp_pc_addr = 0;
 
      if ((op->arch & target_arch) == 0)
        goto fail;
      for (n = 0; n < 4; n++)
        {
          int i = op->nibbles[n];
 
          if (i < 16)
            {
              if (nibs[n] == i)
                continue;
              goto fail;
            }
          switch (i)
            {
            case BRANCH_8:
              imm = (nibs[2] << 4) | (nibs[3]);
              if (imm & 0x80)
                imm |= ~0xff;
              imm = ((char) imm) * 2 + 4;
              goto ok;
            case BRANCH_12:
              imm = ((nibs[1]) << 8) | (nibs[2] << 4) | (nibs[3]);
              if (imm & 0x800)
                imm |= ~0xfff;
              imm = imm * 2 + 4;
              goto ok;
            case IMM0_4:
            case IMM1_4:
              imm = nibs[3];
              goto ok;
            case IMM0_4BY2:
            case IMM1_4BY2:
              imm = nibs[3] << 1;
              goto ok;
            case IMM0_4BY4:
            case IMM1_4BY4:
              imm = nibs[3] << 2;
              goto ok;
            case IMM0_8:
            case IMM1_8:
              imm = (nibs[2] << 4) | nibs[3];
              goto ok;
            case PCRELIMM_8BY2:
              imm = ((nibs[2] << 4) | nibs[3]) << 1;
              relmask = ~(bfd_vma) 1;
              goto ok;
            case PCRELIMM_8BY4:
              imm = ((nibs[2] << 4) | nibs[3]) << 2;
              relmask = ~(bfd_vma) 3;
              goto ok;
            case IMM0_8BY2:
            case IMM1_8BY2:
              imm = ((nibs[2] << 4) | nibs[3]) << 1;
              goto ok;
            case IMM0_8BY4:
            case IMM1_8BY4:
              imm = ((nibs[2] << 4) | nibs[3]) << 2;
              goto ok;
            case REG_N:
              rn = nibs[n];
              break;
            case REG_M:
              rm = nibs[n];
              break;
            case REG_NM:
              rn = (nibs[n] & 0xc) >> 2;
              rm = (nibs[n] & 0x3);
              break;
            case REG_B:
              rb = nibs[n] & 0x07;
              break;
            case SDT_REG_N:
              /* sh-dsp: single data transfer.  */
              rn = nibs[n];
              if ((rn & 0xc) != 4)
                goto fail;
              rn = rn & 0x3;
              rn |= (!(rn & 2)) << 2;
              break;
            case PPI:
            case REPEAT:
              goto fail;
            default:
              abort ();
            }
        }
 
    ok:
      fprintf_fn (stream, "%s\t", op->name);
      disp_pc = 0;
      for (n = 0; n < 3 && op->arg[n] != A_END; n++)
        {
          if (n && op->arg[1] != A_END)
            fprintf_fn (stream, ",");
          switch (op->arg[n])
            {
            case A_IMM:
              fprintf_fn (stream, "#%d", (char) (imm));
              break;
            case A_R0:
              fprintf_fn (stream, "r0");
              break;
            case A_REG_N:
              fprintf_fn (stream, "r%d", rn);
              break;
            case A_INC_N:
              fprintf_fn (stream, "@r%d+", rn);
              break;
            case A_DEC_N:
              fprintf_fn (stream, "@-r%d", rn);
              break;
            case A_IND_N:
              fprintf_fn (stream, "@r%d", rn);
              break;
            case A_DISP_REG_N:
              fprintf_fn (stream, "@(%d,r%d)", imm, rn);
              break;
            case A_PMOD_N:
              fprintf_fn (stream, "@r%d+r8", rn);
              break;
            case A_REG_M:
              fprintf_fn (stream, "r%d", rm);
              break;
            case A_INC_M:
              fprintf_fn (stream, "@r%d+", rm);
              break;
            case A_DEC_M:
              fprintf_fn (stream, "@-r%d", rm);
              break;
            case A_IND_M:
              fprintf_fn (stream, "@r%d", rm);
              break;
            case A_DISP_REG_M:
              fprintf_fn (stream, "@(%d,r%d)", imm, rm);
              break;
            case A_REG_B:
              fprintf_fn (stream, "r%d_bank", rb);
              break;
            case A_DISP_PC:
              disp_pc = 1;
              disp_pc_addr = imm + 4 + (memaddr & relmask);
              (*info->print_address_func) (disp_pc_addr, info);
              break;
            case A_IND_R0_REG_N:
              fprintf_fn (stream, "@(r0,r%d)", rn);
              break;
            case A_IND_R0_REG_M:
              fprintf_fn (stream, "@(r0,r%d)", rm);
              break;
            case A_DISP_GBR:
              fprintf_fn (stream, "@(%d,gbr)", imm);
              break;
            case A_R0_GBR:
              fprintf_fn (stream, "@(r0,gbr)");
              break;
            case A_BDISP12:
            case A_BDISP8:
              (*info->print_address_func) (imm + memaddr, info);
              break;
            case A_SR:
              fprintf_fn (stream, "sr");
              break;
            case A_GBR:
              fprintf_fn (stream, "gbr");
              break;
            case A_VBR:
              fprintf_fn (stream, "vbr");
              break;
            case A_DSR:
              fprintf_fn (stream, "dsr");
              break;
            case A_MOD:
              fprintf_fn (stream, "mod");
              break;
            case A_RE:
              fprintf_fn (stream, "re");
              break;
            case A_RS:
              fprintf_fn (stream, "rs");
              break;
            case A_A0:
              fprintf_fn (stream, "a0");
              break;
            case A_X0:
              fprintf_fn (stream, "x0");
              break;
            case A_X1:
              fprintf_fn (stream, "x1");
              break;
            case A_Y0:
              fprintf_fn (stream, "y0");
              break;
            case A_Y1:
              fprintf_fn (stream, "y1");
              break;
            case DSP_REG_M:
              print_dsp_reg (rm, fprintf_fn, stream);
              break;
            case A_SSR:
              fprintf_fn (stream, "ssr");
              break;
            case A_SPC:
              fprintf_fn (stream, "spc");
              break;
            case A_MACH:
              fprintf_fn (stream, "mach");
              break;
            case A_MACL:
              fprintf_fn (stream, "macl");
              break;
            case A_PR:
              fprintf_fn (stream, "pr");
              break;
            case A_SGR:
              fprintf_fn (stream, "sgr");
              break;
            case A_DBR:
              fprintf_fn (stream, "dbr");
              break;
            case F_REG_N:
              fprintf_fn (stream, "fr%d", rn);
              break;
            case F_REG_M:
              fprintf_fn (stream, "fr%d", rm);
              break;
            case DX_REG_N:
              if (rn & 1)
                {
                  fprintf_fn (stream, "xd%d", rn & ~1);
                  break;
                }
            case D_REG_N:
              fprintf_fn (stream, "dr%d", rn);
              break;
            case DX_REG_M:
              if (rm & 1)
                {
                  fprintf_fn (stream, "xd%d", rm & ~1);
                  break;
                }
            case D_REG_M:
              fprintf_fn (stream, "dr%d", rm);
              break;
            case FPSCR_M:
            case FPSCR_N:
              fprintf_fn (stream, "fpscr");
              break;
            case FPUL_M:
            case FPUL_N:
              fprintf_fn (stream, "fpul");
              break;
            case F_FR0:
              fprintf_fn (stream, "fr0");
              break;
            case V_REG_N:
              fprintf_fn (stream, "fv%d", rn * 4);
              break;
            case V_REG_M:
              fprintf_fn (stream, "fv%d", rm * 4);
              break;
            case XMTRX_M4:
              fprintf_fn (stream, "xmtrx");
              break;
            default:
              abort ();
            }
        }
 
#if 0
      /* This code prints instructions in delay slots on the same line
         as the instruction which needs the delay slots.  This can be
         confusing, since other disassembler don't work this way, and
         it means that the instructions are not all in a line.  So I
         disabled it.  Ian.  */
      if (!(info->flags & 1)
          && (op->name[0] == 'j'
              || (op->name[0] == 'b'
                  && (op->name[1] == 'r'
                      || op->name[1] == 's'))
              || (op->name[0] == 'r' && op->name[1] == 't')
              || (op->name[0] == 'b' && op->name[2] == '.')))
        {
          info->flags |= 1;
          fprintf_fn (stream, "\t(slot ");
          print_insn_sh (memaddr + 2, info);
          info->flags &= ~1;
          fprintf_fn (stream, ")");
          return 4;
        }
#endif
 
      if (disp_pc && strcmp (op->name, "mova") != 0)
        {
          int size;
          bfd_byte bytes[4];
 
          if (relmask == ~(bfd_vma) 1)
            size = 2;
          else
            size = 4;
          status = info->read_memory_func (disp_pc_addr, bytes, size, info);
          if (status == 0)
            {
              unsigned int val;
 
              if (size == 2)
                {
                  if (info->endian == BFD_ENDIAN_LITTLE)
                    val = bfd_getl16 (bytes);
                  else
                    val = bfd_getb16 (bytes);
                }
              else
                {
                  if (info->endian == BFD_ENDIAN_LITTLE)
                    val = bfd_getl32 (bytes);
                  else
                    val = bfd_getb32 (bytes);
                }
              fprintf_fn (stream, "\t! 0x%x", val);
            }
        }
 
      return 2;
    fail:
      ;
 
    }
  fprintf_fn (stream, ".word 0x%x%x%x%x", nibs[0], nibs[1], nibs[2], nibs[3]);
  return 2;
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [opcodes/] [sh-dis.c] - Blame information for rev 1773

Line No.	Rev	Author	Line
1	1181	sfurman	`/* Disassemble SH instructions.`
2			`Copyright 1993, 1994, 1995, 1997, 1998, 2000, 2001`
3			`Free Software Foundation, Inc.`
4
5			`This program is free software; you can redistribute it and/or modify`
6			`it under the terms of the GNU General Public License as published by`
7			`the Free Software Foundation; either version 2 of the License, or`
8			`(at your option) any later version.`
9
10			`This program is distributed in the hope that it will be useful,`
11			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
12			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
13			`GNU General Public License for more details.`
14
15			`You should have received a copy of the GNU General Public License`
16			`along with this program; if not, write to the Free Software`
17			`Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */`
18
19			`#include <stdio.h>`
20			`#include "sysdep.h"`
21			`#define STATIC_TABLE`
22			`#define DEFINE_TABLE`
23
24			`#include "sh-opc.h"`
25			`#include "dis-asm.h"`
26
27			`static void print_movxy`
28			`PARAMS ((sh_opcode_info , int, int, fprintf_ftype, void ));`
29			`static void print_insn_ddt PARAMS ((int, struct disassemble_info *));`
30			`static void print_dsp_reg PARAMS ((int, fprintf_ftype, void *));`
31			`static void print_insn_ppi PARAMS ((int, struct disassemble_info *));`
32
33			`static void`
34			`print_movxy (op, rn, rm, fprintf_fn, stream)`
35			`sh_opcode_info *op;`
36			`int rn, rm;`
37			`fprintf_ftype fprintf_fn;`
38			`void *stream;`
39			`{`
40			`int n;`
41
42			`fprintf_fn (stream, "%s\t", op->name);`
43			`for (n = 0; n < 2; n++)`
44			`{`
45			`switch (op->arg[n])`
46			`{`
47			`case A_IND_N:`
48			`fprintf_fn (stream, "@r%d", rn);`
49			`break;`
50			`case A_INC_N:`
51			`fprintf_fn (stream, "@r%d+", rn);`
52			`break;`
53			`case A_PMOD_N:`
54			`fprintf_fn (stream, "@r%d+r8", rn);`
55			`break;`
56			`case A_PMODY_N:`
57			`fprintf_fn (stream, "@r%d+r9", rn);`
58			`break;`
59			`case DSP_REG_M:`
60			`fprintf_fn (stream, "a%c", '0' + rm);`
61			`break;`
62			`case DSP_REG_X:`
63			`fprintf_fn (stream, "x%c", '0' + rm);`
64			`break;`
65			`case DSP_REG_Y:`
66			`fprintf_fn (stream, "y%c", '0' + rm);`
67			`break;`
68			`default:`
69			`abort ();`
70			`}`
71			`if (n == 0)`
72			`fprintf_fn (stream, ",");`
73			`}`
74			`}`
75
76			`/* Print a double data transfer insn. INSN is just the lower three`
77			`nibbles of the insn, i.e. field a and the bit that indicates if`
78			`a parallel processing insn follows.`
79			`Return nonzero if a field b of a parallel processing insns follows. */`
80
81			`static void`
82			`print_insn_ddt (insn, info)`
83			`int insn;`
84			`struct disassemble_info *info;`
85			`{`
86			`fprintf_ftype fprintf_fn = info->fprintf_func;`
87			`void *stream = info->stream;`
88
89			`/* If this is just a nop, make sure to emit something. */`
90			`if (insn == 0x000)`
91			`fprintf_fn (stream, "nopx\tnopy");`
92
93			`/* If a parallel processing insn was printed before,`
94			`and we got a non-nop, emit a tab. */`
95			`if ((insn & 0x800) && (insn & 0x3ff))`
96			`fprintf_fn (stream, "\t");`
97
98			`/* Check if either the x or y part is invalid. */`
99			`if (((insn & 0xc) == 0 && (insn & 0x2a0))`
100			`\|\| ((insn & 3) == 0 && (insn & 0x150)))`
101			`fprintf_fn (stream, ".word 0x%x", insn);`
102			`else`
103			`{`
104			`static sh_opcode_info first_movx, first_movy;`
105			`sh_opcode_info opx, opy;`
106			`unsigned int insn_x, insn_y;`
107
108			`if (! first_movx)`
109			`{`
110			`for (first_movx = sh_table; first_movx->nibbles[1] != MOVX;)`
111			`first_movx++;`
112			`for (first_movy = first_movx; first_movy->nibbles[1] != MOVY;)`
113			`first_movy++;`
114			`}`
115			`insn_x = (insn >> 2) & 0xb;`
116			`if (insn_x)`
117			`{`
118			`for (opx = first_movx; opx->nibbles[2] != insn_x;)`
119			`opx++;`
120			`print_movxy (opx, ((insn >> 9) & 1) + 4, (insn >> 7) & 1,`
121			`fprintf_fn, stream);`
122			`}`
123			`insn_y = (insn & 3) \| ((insn >> 1) & 8);`
124			`if (insn_y)`
125			`{`
126			`if (insn_x)`
127			`fprintf_fn (stream, "\t");`
128			`for (opy = first_movy; opy->nibbles[2] != insn_y;)`
129			`opy++;`
130			`print_movxy (opy, ((insn >> 8) & 1) + 6, (insn >> 6) & 1,`
131			`fprintf_fn, stream);`
132			`}`
133			`}`
134			`}`
135
136			`static void`
137			`print_dsp_reg (rm, fprintf_fn, stream)`
138			`int rm;`
139			`fprintf_ftype fprintf_fn;`
140			`void *stream;`
141			`{`
142			`switch (rm)`
143			`{`
144			`case A_A1_NUM:`
145			`fprintf_fn (stream, "a1");`
146			`break;`
147			`case A_A0_NUM:`
148			`fprintf_fn (stream, "a0");`
149			`break;`
150			`case A_X0_NUM:`
151			`fprintf_fn (stream, "x0");`
152			`break;`
153			`case A_X1_NUM:`
154			`fprintf_fn (stream, "x1");`
155			`break;`
156			`case A_Y0_NUM:`
157			`fprintf_fn (stream, "y0");`
158			`break;`
159			`case A_Y1_NUM:`
160			`fprintf_fn (stream, "y1");`
161			`break;`
162			`case A_M0_NUM:`
163			`fprintf_fn (stream, "m0");`
164			`break;`
165			`case A_A1G_NUM:`
166			`fprintf_fn (stream, "a1g");`
167			`break;`
168			`case A_M1_NUM:`
169			`fprintf_fn (stream, "m1");`
170			`break;`
171			`case A_A0G_NUM:`
172			`fprintf_fn (stream, "a0g");`
173			`break;`
174			`default:`
175			`fprintf_fn (stream, "0x%x", rm);`
176			`break;`
177			`}`
178			`}`
179
180			`static void`
181			`print_insn_ppi (field_b, info)`
182			`int field_b;`
183			`struct disassemble_info *info;`
184			`{`
185			`static char *sx_tab[] = { "x0", "x1", "a0", "a1" };`
186			`static char *sy_tab[] = { "y0", "y1", "m0", "m1" };`
187			`fprintf_ftype fprintf_fn = info->fprintf_func;`
188			`void *stream = info->stream;`
189			`unsigned int nib1, nib2, nib3;`
190			`char *dc = NULL;`
191			`sh_opcode_info *op;`
192
193			`if ((field_b & 0xe800) == 0)`
194			`{`
195			`fprintf_fn (stream, "psh%c\t#%d,",`
196			`field_b & 0x1000 ? 'a' : 'l',`
197			`(field_b >> 4) & 127);`
198			`print_dsp_reg (field_b & 0xf, fprintf_fn, stream);`
199			`return;`
200			`}`
201			`if ((field_b & 0xc000) == 0x4000 && (field_b & 0x3000) != 0x1000)`
202			`{`
203			`static char *du_tab[] = { "x0", "y0", "a0", "a1" };`
204			`static char *se_tab[] = { "x0", "x1", "y0", "a1" };`
205			`static char *sf_tab[] = { "y0", "y1", "x0", "a1" };`
206			`static char *sg_tab[] = { "m0", "m1", "a0", "a1" };`
207
208			`if (field_b & 0x2000)`
209			`{`
210			`fprintf_fn (stream, "p%s %s,%s,%s\t",`
211			`(field_b & 0x1000) ? "add" : "sub",`
212			`sx_tab[(field_b >> 6) & 3],`
213			`sy_tab[(field_b >> 4) & 3],`
214			`du_tab[(field_b >> 0) & 3]);`
215			`}`
216			`fprintf_fn (stream, "pmuls%c%s,%s,%s",`
217			`field_b & 0x2000 ? ' ' : '\t',`
218			`se_tab[(field_b >> 10) & 3],`
219			`sf_tab[(field_b >> 8) & 3],`
220			`sg_tab[(field_b >> 2) & 3]);`
221			`return;`
222			`}`
223
224			`nib1 = PPIC;`
225			`nib2 = field_b >> 12 & 0xf;`
226			`nib3 = field_b >> 8 & 0xf;`
227			`switch (nib3 & 0x3)`
228			`{`
229			`case 0:`
230			`dc = "";`
231			`nib1 = PPI3;`
232			`break;`
233			`case 1:`
234			`dc = "";`
235			`break;`
236			`case 2:`
237			`dc = "dct ";`
238			`nib3 -= 1;`
239			`break;`
240			`case 3:`
241			`dc = "dcf ";`
242			`nib3 -= 2;`
243			`break;`
244			`}`
245			`for (op = sh_table; op->name; op++)`
246			`{`
247			`if (op->nibbles[1] == nib1`
248			`&& op->nibbles[2] == nib2`
249			`&& op->nibbles[3] == nib3)`
250			`{`
251			`int n;`
252
253			`fprintf_fn (stream, "%s%s\t", dc, op->name);`
254			`for (n = 0; n < 3 && op->arg[n] != A_END; n++)`
255			`{`
256			`if (n && op->arg[1] != A_END)`
257			`fprintf_fn (stream, ",");`
258			`switch (op->arg[n])`
259			`{`
260			`case DSP_REG_N:`
261			`print_dsp_reg (field_b & 0xf, fprintf_fn, stream);`
262			`break;`
263			`case DSP_REG_X:`
264			`fprintf_fn (stream, sx_tab[(field_b >> 6) & 3]);`
265			`break;`
266			`case DSP_REG_Y:`
267			`fprintf_fn (stream, sy_tab[(field_b >> 4) & 3]);`
268			`break;`
269			`case A_MACH:`
270			`fprintf_fn (stream, "mach");`
271			`break;`
272			`case A_MACL:`
273			`fprintf_fn (stream, "macl");`
274			`break;`
275			`default:`
276			`abort ();`
277			`}`
278			`}`
279			`return;`
280			`}`
281			`}`
282			`/* Not found. */`
283			`fprintf_fn (stream, ".word 0x%x", field_b);`
284			`}`
285
286			`int`
287			`print_insn_sh (memaddr, info)`
288			`bfd_vma memaddr;`
289			`struct disassemble_info *info;`
290			`{`
291			`fprintf_ftype fprintf_fn = info->fprintf_func;`
292			`void *stream = info->stream;`
293			`unsigned char insn[2];`
294			`unsigned char nibs[4];`
295			`int status;`
296			`bfd_vma relmask = ~(bfd_vma) 0;`
297			`sh_opcode_info *op;`
298			`int target_arch;`
299
300			`switch (info->mach)`
301			`{`
302			`case bfd_mach_sh:`
303			`target_arch = arch_sh1;`
304			`/* SH coff object files lack information about the machine type, so`
305			`we end up with bfd_mach_sh unless it was set explicitly (which`
306			`could have happended if this is a call from gdb or the simulator.) */`
307			`if (info->symbols`
308			`&& bfd_asymbol_flavour(*info->symbols) == bfd_target_coff_flavour)`
309			`target_arch = arch_sh4;`
310			`break;`
311			`case bfd_mach_sh2:`
312			`target_arch = arch_sh2;`
313			`break;`
314			`case bfd_mach_sh_dsp:`
315			`target_arch = arch_sh_dsp;`
316			`break;`
317			`case bfd_mach_sh3:`
318			`target_arch = arch_sh3;`
319			`break;`
320			`case bfd_mach_sh3_dsp:`
321			`target_arch = arch_sh3_dsp;`
322			`break;`
323			`case bfd_mach_sh3e:`
324			`target_arch = arch_sh3e;`
325			`break;`
326			`case bfd_mach_sh4:`
327			`target_arch = arch_sh4;`
328			`break;`
329			`case bfd_mach_sh5:`
330			`#ifdef INCLUDE_SHMEDIA`
331			`status = print_insn_sh64 (memaddr, info);`
332			`if (status != -2)`
333			`return status;`
334			`#endif`
335			`/* When we get here for sh64, it's because we want to disassemble`
336			`SHcompact, i.e. arch_sh4. */`
337			`target_arch = arch_sh4;`
338			`break;`
339			`default:`
340			`abort ();`
341			`}`
342
343			`status = info->read_memory_func (memaddr, insn, 2, info);`
344
345			`if (status != 0)`
346			`{`
347			`info->memory_error_func (status, memaddr, info);`
348			`return -1;`
349			`}`
350
351			`if (info->endian == BFD_ENDIAN_LITTLE)`
352			`{`
353			`nibs[0] = (insn[1] >> 4) & 0xf;`
354			`nibs[1] = insn[1] & 0xf;`
355
356			`nibs[2] = (insn[0] >> 4) & 0xf;`
357			`nibs[3] = insn[0] & 0xf;`
358			`}`
359			`else`
360			`{`
361			`nibs[0] = (insn[0] >> 4) & 0xf;`
362			`nibs[1] = insn[0] & 0xf;`
363
364			`nibs[2] = (insn[1] >> 4) & 0xf;`
365			`nibs[3] = insn[1] & 0xf;`
366			`}`
367
368			`if (nibs[0] == 0xf && (nibs[1] & 4) == 0 && target_arch & arch_sh_dsp_up)`
369			`{`
370			`if (nibs[1] & 8)`
371			`{`
372			`int field_b;`
373
374			`status = info->read_memory_func (memaddr + 2, insn, 2, info);`
375
376			`if (status != 0)`
377			`{`
378			`info->memory_error_func (status, memaddr + 2, info);`
379			`return -1;`
380			`}`
381
382			`if (info->endian == BFD_ENDIAN_LITTLE)`
383			`field_b = insn[1] << 8 \| insn[0];`
384			`else`
385			`field_b = insn[0] << 8 \| insn[1];`
386
387			`print_insn_ppi (field_b, info);`
388			`print_insn_ddt ((nibs[1] << 8) \| (nibs[2] << 4) \| nibs[3], info);`
389			`return 4;`
390			`}`
391			`print_insn_ddt ((nibs[1] << 8) \| (nibs[2] << 4) \| nibs[3], info);`
392			`return 2;`
393			`}`
394			`for (op = sh_table; op->name; op++)`
395			`{`
396			`int n;`
397			`int imm = 0;`
398			`int rn = 0;`
399			`int rm = 0;`
400			`int rb = 0;`
401			`int disp_pc;`
402			`bfd_vma disp_pc_addr = 0;`
403
404			`if ((op->arch & target_arch) == 0)`
405			`goto fail;`
406			`for (n = 0; n < 4; n++)`
407			`{`
408			`int i = op->nibbles[n];`
409
410			`if (i < 16)`
411			`{`
412			`if (nibs[n] == i)`
413			`continue;`
414			`goto fail;`
415			`}`
416			`switch (i)`
417			`{`
418			`case BRANCH_8:`
419			`imm = (nibs[2] << 4) \| (nibs[3]);`
420			`if (imm & 0x80)`
421			`imm \|= ~0xff;`
422			`imm = ((char) imm) * 2 + 4;`
423			`goto ok;`
424			`case BRANCH_12:`
425			`imm = ((nibs[1]) << 8) \| (nibs[2] << 4) \| (nibs[3]);`
426			`if (imm & 0x800)`
427			`imm \|= ~0xfff;`
428			`imm = imm * 2 + 4;`
429			`goto ok;`
430			`case IMM0_4:`
431			`case IMM1_4:`
432			`imm = nibs[3];`
433			`goto ok;`
434			`case IMM0_4BY2:`
435			`case IMM1_4BY2:`
436			`imm = nibs[3] << 1;`
437			`goto ok;`
438			`case IMM0_4BY4:`
439			`case IMM1_4BY4:`
440			`imm = nibs[3] << 2;`
441			`goto ok;`
442			`case IMM0_8:`
443			`case IMM1_8:`
444			`imm = (nibs[2] << 4) \| nibs[3];`
445			`goto ok;`
446			`case PCRELIMM_8BY2:`
447			`imm = ((nibs[2] << 4) \| nibs[3]) << 1;`
448			`relmask = ~(bfd_vma) 1;`
449			`goto ok;`
450			`case PCRELIMM_8BY4:`
451			`imm = ((nibs[2] << 4) \| nibs[3]) << 2;`
452			`relmask = ~(bfd_vma) 3;`
453			`goto ok;`
454			`case IMM0_8BY2:`
455			`case IMM1_8BY2:`
456			`imm = ((nibs[2] << 4) \| nibs[3]) << 1;`
457			`goto ok;`
458			`case IMM0_8BY4:`
459			`case IMM1_8BY4:`
460			`imm = ((nibs[2] << 4) \| nibs[3]) << 2;`
461			`goto ok;`
462			`case REG_N:`
463			`rn = nibs[n];`
464			`break;`
465			`case REG_M:`
466			`rm = nibs[n];`
467			`break;`
468			`case REG_NM:`
469			`rn = (nibs[n] & 0xc) >> 2;`
470			`rm = (nibs[n] & 0x3);`
471			`break;`
472			`case REG_B:`
473			`rb = nibs[n] & 0x07;`
474			`break;`
475			`case SDT_REG_N:`
476			`/* sh-dsp: single data transfer. */`
477			`rn = nibs[n];`
478			`if ((rn & 0xc) != 4)`
479			`goto fail;`
480			`rn = rn & 0x3;`
481			`rn \|= (!(rn & 2)) << 2;`
482			`break;`
483			`case PPI:`
484			`case REPEAT:`
485			`goto fail;`
486			`default:`
487			`abort ();`
488			`}`
489			`}`
490
491			`ok:`
492			`fprintf_fn (stream, "%s\t", op->name);`
493			`disp_pc = 0;`
494			`for (n = 0; n < 3 && op->arg[n] != A_END; n++)`
495			`{`
496			`if (n && op->arg[1] != A_END)`
497			`fprintf_fn (stream, ",");`
498			`switch (op->arg[n])`
499			`{`
500			`case A_IMM:`
501			`fprintf_fn (stream, "#%d", (char) (imm));`
502			`break;`
503			`case A_R0:`
504			`fprintf_fn (stream, "r0");`
505			`break;`
506			`case A_REG_N:`
507			`fprintf_fn (stream, "r%d", rn);`
508			`break;`
509			`case A_INC_N:`
510			`fprintf_fn (stream, "@r%d+", rn);`
511			`break;`
512			`case A_DEC_N:`
513			`fprintf_fn (stream, "@-r%d", rn);`
514			`break;`
515			`case A_IND_N:`
516			`fprintf_fn (stream, "@r%d", rn);`
517			`break;`
518			`case A_DISP_REG_N:`
519			`fprintf_fn (stream, "@(%d,r%d)", imm, rn);`
520			`break;`
521			`case A_PMOD_N:`
522			`fprintf_fn (stream, "@r%d+r8", rn);`
523			`break;`
524			`case A_REG_M:`
525			`fprintf_fn (stream, "r%d", rm);`
526			`break;`
527			`case A_INC_M:`
528			`fprintf_fn (stream, "@r%d+", rm);`
529			`break;`
530			`case A_DEC_M:`
531			`fprintf_fn (stream, "@-r%d", rm);`
532			`break;`
533			`case A_IND_M:`
534			`fprintf_fn (stream, "@r%d", rm);`
535			`break;`
536			`case A_DISP_REG_M:`
537			`fprintf_fn (stream, "@(%d,r%d)", imm, rm);`
538			`break;`
539			`case A_REG_B:`
540			`fprintf_fn (stream, "r%d_bank", rb);`
541			`break;`
542			`case A_DISP_PC:`
543			`disp_pc = 1;`
544			`disp_pc_addr = imm + 4 + (memaddr & relmask);`
545			`(*info->print_address_func) (disp_pc_addr, info);`
546			`break;`
547			`case A_IND_R0_REG_N:`
548			`fprintf_fn (stream, "@(r0,r%d)", rn);`
549			`break;`
550			`case A_IND_R0_REG_M:`
551			`fprintf_fn (stream, "@(r0,r%d)", rm);`
552			`break;`
553			`case A_DISP_GBR:`
554			`fprintf_fn (stream, "@(%d,gbr)", imm);`
555			`break;`
556			`case A_R0_GBR:`
557			`fprintf_fn (stream, "@(r0,gbr)");`
558			`break;`
559			`case A_BDISP12:`
560			`case A_BDISP8:`
561			`(*info->print_address_func) (imm + memaddr, info);`
562			`break;`
563			`case A_SR:`
564			`fprintf_fn (stream, "sr");`
565			`break;`
566			`case A_GBR:`
567			`fprintf_fn (stream, "gbr");`
568			`break;`
569			`case A_VBR:`
570			`fprintf_fn (stream, "vbr");`
571			`break;`
572			`case A_DSR:`
573			`fprintf_fn (stream, "dsr");`
574			`break;`
575			`case A_MOD:`
576			`fprintf_fn (stream, "mod");`
577			`break;`
578			`case A_RE:`
579			`fprintf_fn (stream, "re");`
580			`break;`
581			`case A_RS:`
582			`fprintf_fn (stream, "rs");`
583			`break;`
584			`case A_A0:`
585			`fprintf_fn (stream, "a0");`
586			`break;`
587			`case A_X0:`
588			`fprintf_fn (stream, "x0");`
589			`break;`
590			`case A_X1:`
591			`fprintf_fn (stream, "x1");`
592			`break;`
593			`case A_Y0:`
594			`fprintf_fn (stream, "y0");`
595			`break;`
596			`case A_Y1:`
597			`fprintf_fn (stream, "y1");`
598			`break;`
599			`case DSP_REG_M:`
600			`print_dsp_reg (rm, fprintf_fn, stream);`
601			`break;`
602			`case A_SSR:`
603			`fprintf_fn (stream, "ssr");`
604			`break;`
605			`case A_SPC:`
606			`fprintf_fn (stream, "spc");`
607			`break;`
608			`case A_MACH:`
609			`fprintf_fn (stream, "mach");`
610			`break;`
611			`case A_MACL:`
612			`fprintf_fn (stream, "macl");`
613			`break;`
614			`case A_PR:`
615			`fprintf_fn (stream, "pr");`
616			`break;`
617			`case A_SGR:`
618			`fprintf_fn (stream, "sgr");`
619			`break;`
620			`case A_DBR:`
621			`fprintf_fn (stream, "dbr");`
622			`break;`
623			`case F_REG_N:`
624			`fprintf_fn (stream, "fr%d", rn);`
625			`break;`
626			`case F_REG_M:`
627			`fprintf_fn (stream, "fr%d", rm);`
628			`break;`
629			`case DX_REG_N:`
630			`if (rn & 1)`
631			`{`
632			`fprintf_fn (stream, "xd%d", rn & ~1);`
633			`break;`
634			`}`
635			`case D_REG_N:`
636			`fprintf_fn (stream, "dr%d", rn);`
637			`break;`
638			`case DX_REG_M:`
639			`if (rm & 1)`
640			`{`
641			`fprintf_fn (stream, "xd%d", rm & ~1);`
642			`break;`
643			`}`
644			`case D_REG_M:`
645			`fprintf_fn (stream, "dr%d", rm);`
646			`break;`
647			`case FPSCR_M:`
648			`case FPSCR_N:`
649			`fprintf_fn (stream, "fpscr");`
650			`break;`
651			`case FPUL_M:`
652			`case FPUL_N:`
653			`fprintf_fn (stream, "fpul");`
654			`break;`
655			`case F_FR0:`
656			`fprintf_fn (stream, "fr0");`
657			`break;`
658			`case V_REG_N:`
659			`fprintf_fn (stream, "fv%d", rn * 4);`
660			`break;`
661			`case V_REG_M:`
662			`fprintf_fn (stream, "fv%d", rm * 4);`
663			`break;`
664			`case XMTRX_M4:`
665			`fprintf_fn (stream, "xmtrx");`
666			`break;`
667			`default:`
668			`abort ();`
669			`}`
670			`}`
671
672			`#if 0`
673			`/* This code prints instructions in delay slots on the same line`
674			`as the instruction which needs the delay slots. This can be`
675			`confusing, since other disassembler don't work this way, and`
676			`it means that the instructions are not all in a line. So I`
677			`disabled it. Ian. */`
678			`if (!(info->flags & 1)`
679			`&& (op->name[0] == 'j'`
680			`\|\| (op->name[0] == 'b'`
681			`&& (op->name[1] == 'r'`
682			`\|\| op->name[1] == 's'))`
683			`\|\| (op->name[0] == 'r' && op->name[1] == 't')`
684			`\|\| (op->name[0] == 'b' && op->name[2] == '.')))`
685			`{`
686			`info->flags \|= 1;`
687			`fprintf_fn (stream, "\t(slot ");`
688			`print_insn_sh (memaddr + 2, info);`
689			`info->flags &= ~1;`
690			`fprintf_fn (stream, ")");`
691			`return 4;`
692			`}`
693			`#endif`
694
695			`if (disp_pc && strcmp (op->name, "mova") != 0)`
696			`{`
697			`int size;`
698			`bfd_byte bytes[4];`
699
700			`if (relmask == ~(bfd_vma) 1)`
701			`size = 2;`
702			`else`
703			`size = 4;`
704			`status = info->read_memory_func (disp_pc_addr, bytes, size, info);`
705			`if (status == 0)`
706			`{`
707			`unsigned int val;`
708
709			`if (size == 2)`
710			`{`
711			`if (info->endian == BFD_ENDIAN_LITTLE)`
712			`val = bfd_getl16 (bytes);`
713			`else`
714			`val = bfd_getb16 (bytes);`
715			`}`
716			`else`
717			`{`
718			`if (info->endian == BFD_ENDIAN_LITTLE)`
719			`val = bfd_getl32 (bytes);`
720			`else`
721			`val = bfd_getb32 (bytes);`
722			`}`
723			`fprintf_fn (stream, "\t! 0x%x", val);`
724			`}`
725			`}`
726
727			`return 2;`
728			`fail:`
729			`;`
730
731			`}`
732			`fprintf_fn (stream, ".word 0x%x%x%x%x", nibs[0], nibs[1], nibs[2], nibs[3]);`
733			`return 2;`
734			`}`