OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [opcodes/] [crx-dis.c] - Diff between revs 156 and 816

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 156 Rev 816
/* Disassembler code for CRX.
/* Disassembler code for CRX.
   Copyright 2004, 2005, 2007 Free Software Foundation, Inc.
   Copyright 2004, 2005, 2007 Free Software Foundation, Inc.
   Contributed by Tomer Levi, NSC, Israel.
   Contributed by Tomer Levi, NSC, Israel.
   Written by Tomer Levi.
   Written by Tomer Levi.
 
 
   This file is part of the GNU opcodes library.
   This file is part of the GNU opcodes library.
 
 
   This library is free software; you can redistribute it and/or modify
   This library is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   the Free Software Foundation; either version 3, or (at your option)
   any later version.
   any later version.
 
 
   It is distributed in the hope that it will be useful, but WITHOUT
   It is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
   License for more details.
   License for more details.
 
 
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
   MA 02110-1301, USA.  */
 
 
#include "dis-asm.h"
#include "dis-asm.h"
#include "sysdep.h"
#include "sysdep.h"
#include "opcode/crx.h"
#include "opcode/crx.h"
 
 
/* String to print when opcode was not matched.  */
/* String to print when opcode was not matched.  */
#define ILLEGAL "illegal"
#define ILLEGAL "illegal"
  /* Escape to 16-bit immediate.  */
  /* Escape to 16-bit immediate.  */
#define ESCAPE_16_BIT  0xE
#define ESCAPE_16_BIT  0xE
 
 
/* Extract 'n_bits' from 'a' starting from offset 'offs'.  */
/* Extract 'n_bits' from 'a' starting from offset 'offs'.  */
#define EXTRACT(a, offs, n_bits)            \
#define EXTRACT(a, offs, n_bits)            \
  (n_bits == 32 ? (((a) >> (offs)) & 0xffffffffL)   \
  (n_bits == 32 ? (((a) >> (offs)) & 0xffffffffL)   \
  : (((a) >> (offs)) & ((1 << (n_bits)) -1)))
  : (((a) >> (offs)) & ((1 << (n_bits)) -1)))
 
 
/* Set Bit Mask - a mask to set all bits starting from offset 'offs'.  */
/* Set Bit Mask - a mask to set all bits starting from offset 'offs'.  */
#define SBM(offs)  ((((1 << (32 - offs)) -1) << (offs)))
#define SBM(offs)  ((((1 << (32 - offs)) -1) << (offs)))
 
 
typedef unsigned long dwordU;
typedef unsigned long dwordU;
typedef unsigned short wordU;
typedef unsigned short wordU;
 
 
typedef struct
typedef struct
{
{
  dwordU val;
  dwordU val;
  int nbits;
  int nbits;
} parameter;
} parameter;
 
 
/* Structure to hold valid 'cinv' instruction options.  */
/* Structure to hold valid 'cinv' instruction options.  */
 
 
typedef struct
typedef struct
  {
  {
    /* Cinv printed string.  */
    /* Cinv printed string.  */
    char *str;
    char *str;
    /* Value corresponding to the string.  */
    /* Value corresponding to the string.  */
    unsigned int value;
    unsigned int value;
  }
  }
cinv_entry;
cinv_entry;
 
 
/* CRX 'cinv' options.  */
/* CRX 'cinv' options.  */
const cinv_entry crx_cinvs[] =
const cinv_entry crx_cinvs[] =
{
{
  {"[i]", 2}, {"[i,u]", 3}, {"[d]", 4}, {"[d,u]", 5},
  {"[i]", 2}, {"[i,u]", 3}, {"[d]", 4}, {"[d,u]", 5},
  {"[d,i]", 6}, {"[d,i,u]", 7}, {"[b]", 8},
  {"[d,i]", 6}, {"[d,i,u]", 7}, {"[b]", 8},
  {"[b,i]", 10}, {"[b,i,u]", 11}, {"[b,d]", 12},
  {"[b,i]", 10}, {"[b,i,u]", 11}, {"[b,d]", 12},
  {"[b,d,u]", 13}, {"[b,d,i]", 14}, {"[b,d,i,u]", 15}
  {"[b,d,u]", 13}, {"[b,d,i]", 14}, {"[b,d,i,u]", 15}
};
};
 
 
/* Enum to distinguish different registers argument types.  */
/* Enum to distinguish different registers argument types.  */
typedef enum REG_ARG_TYPE
typedef enum REG_ARG_TYPE
  {
  {
    /* General purpose register (r<N>).  */
    /* General purpose register (r<N>).  */
    REG_ARG = 0,
    REG_ARG = 0,
    /* User register (u<N>).  */
    /* User register (u<N>).  */
    USER_REG_ARG,
    USER_REG_ARG,
    /* CO-Processor register (c<N>).  */
    /* CO-Processor register (c<N>).  */
    COP_ARG,
    COP_ARG,
    /* CO-Processor special register (cs<N>).  */
    /* CO-Processor special register (cs<N>).  */
    COPS_ARG
    COPS_ARG
  }
  }
REG_ARG_TYPE;
REG_ARG_TYPE;
 
 
/* Number of valid 'cinv' instruction options.  */
/* Number of valid 'cinv' instruction options.  */
int NUMCINVS = ((sizeof crx_cinvs)/(sizeof crx_cinvs[0]));
int NUMCINVS = ((sizeof crx_cinvs)/(sizeof crx_cinvs[0]));
/* Current opcode table entry we're disassembling.  */
/* Current opcode table entry we're disassembling.  */
const inst *instruction;
const inst *instruction;
/* Current instruction we're disassembling.  */
/* Current instruction we're disassembling.  */
ins currInsn;
ins currInsn;
/* The current instruction is read into 3 consecutive words.  */
/* The current instruction is read into 3 consecutive words.  */
wordU words[3];
wordU words[3];
/* Contains all words in appropriate order.  */
/* Contains all words in appropriate order.  */
ULONGLONG allWords;
ULONGLONG allWords;
/* Holds the current processed argument number.  */
/* Holds the current processed argument number.  */
int processing_argument_number;
int processing_argument_number;
/* Nonzero means a CST4 instruction.  */
/* Nonzero means a CST4 instruction.  */
int cst4flag;
int cst4flag;
/* Nonzero means the instruction's original size is
/* Nonzero means the instruction's original size is
   incremented (escape sequence is used).  */
   incremented (escape sequence is used).  */
int size_changed;
int size_changed;
 
 
static int get_number_of_operands (void);
static int get_number_of_operands (void);
static argtype getargtype     (operand_type);
static argtype getargtype     (operand_type);
static int getbits            (operand_type);
static int getbits            (operand_type);
static char *getregname       (reg);
static char *getregname       (reg);
static char *getcopregname    (copreg, reg_type);
static char *getcopregname    (copreg, reg_type);
static char * getprocregname  (int);
static char * getprocregname  (int);
static char *gettrapstring    (unsigned);
static char *gettrapstring    (unsigned);
static char *getcinvstring    (unsigned);
static char *getcinvstring    (unsigned);
static void getregliststring  (int, char *, enum REG_ARG_TYPE);
static void getregliststring  (int, char *, enum REG_ARG_TYPE);
static wordU get_word_at_PC   (bfd_vma, struct disassemble_info *);
static wordU get_word_at_PC   (bfd_vma, struct disassemble_info *);
static void get_words_at_PC   (bfd_vma, struct disassemble_info *);
static void get_words_at_PC   (bfd_vma, struct disassemble_info *);
static unsigned long build_mask (void);
static unsigned long build_mask (void);
static int powerof2           (int);
static int powerof2           (int);
static int match_opcode       (void);
static int match_opcode       (void);
static void make_instruction  (void);
static void make_instruction  (void);
static void print_arguments   (ins *, bfd_vma, struct disassemble_info *);
static void print_arguments   (ins *, bfd_vma, struct disassemble_info *);
static void print_arg         (argument *, bfd_vma, struct disassemble_info *);
static void print_arg         (argument *, bfd_vma, struct disassemble_info *);
 
 
/* Retrieve the number of operands for the current assembled instruction.  */
/* Retrieve the number of operands for the current assembled instruction.  */
 
 
static int
static int
get_number_of_operands (void)
get_number_of_operands (void)
{
{
  int i;
  int i;
 
 
  for (i = 0; instruction->operands[i].op_type && i < MAX_OPERANDS; i++)
  for (i = 0; instruction->operands[i].op_type && i < MAX_OPERANDS; i++)
    ;
    ;
 
 
  return i;
  return i;
}
}
 
 
/* Return the bit size for a given operand.  */
/* Return the bit size for a given operand.  */
 
 
static int
static int
getbits (operand_type op)
getbits (operand_type op)
{
{
  if (op < MAX_OPRD)
  if (op < MAX_OPRD)
    return crx_optab[op].bit_size;
    return crx_optab[op].bit_size;
  else
  else
    return 0;
    return 0;
}
}
 
 
/* Return the argument type of a given operand.  */
/* Return the argument type of a given operand.  */
 
 
static argtype
static argtype
getargtype (operand_type op)
getargtype (operand_type op)
{
{
  if (op < MAX_OPRD)
  if (op < MAX_OPRD)
    return crx_optab[op].arg_type;
    return crx_optab[op].arg_type;
  else
  else
    return nullargs;
    return nullargs;
}
}
 
 
/* Given the trap index in dispatch table, return its name.
/* Given the trap index in dispatch table, return its name.
   This routine is used when disassembling the 'excp' instruction.  */
   This routine is used when disassembling the 'excp' instruction.  */
 
 
static char *
static char *
gettrapstring (unsigned int index)
gettrapstring (unsigned int index)
{
{
  const trap_entry *trap;
  const trap_entry *trap;
 
 
  for (trap = crx_traps; trap < crx_traps + NUMTRAPS; trap++)
  for (trap = crx_traps; trap < crx_traps + NUMTRAPS; trap++)
    if (trap->entry == index)
    if (trap->entry == index)
      return trap->name;
      return trap->name;
 
 
  return ILLEGAL;
  return ILLEGAL;
}
}
 
 
/* Given a 'cinv' instruction constant operand, return its corresponding string.
/* Given a 'cinv' instruction constant operand, return its corresponding string.
   This routine is used when disassembling the 'cinv' instruction.  */
   This routine is used when disassembling the 'cinv' instruction.  */
 
 
static char *
static char *
getcinvstring (unsigned int num)
getcinvstring (unsigned int num)
{
{
  const cinv_entry *cinv;
  const cinv_entry *cinv;
 
 
  for (cinv = crx_cinvs; cinv < (crx_cinvs + NUMCINVS); cinv++)
  for (cinv = crx_cinvs; cinv < (crx_cinvs + NUMCINVS); cinv++)
    if (cinv->value == num)
    if (cinv->value == num)
      return cinv->str;
      return cinv->str;
 
 
  return ILLEGAL;
  return ILLEGAL;
}
}
 
 
/* Given a register enum value, retrieve its name.  */
/* Given a register enum value, retrieve its name.  */
 
 
char *
char *
getregname (reg r)
getregname (reg r)
{
{
  const reg_entry *reg = &crx_regtab[r];
  const reg_entry *reg = &crx_regtab[r];
 
 
  if (reg->type != CRX_R_REGTYPE)
  if (reg->type != CRX_R_REGTYPE)
    return ILLEGAL;
    return ILLEGAL;
  else
  else
    return reg->name;
    return reg->name;
}
}
 
 
/* Given a coprocessor register enum value, retrieve its name.  */
/* Given a coprocessor register enum value, retrieve its name.  */
 
 
char *
char *
getcopregname (copreg r, reg_type type)
getcopregname (copreg r, reg_type type)
{
{
  const reg_entry *reg;
  const reg_entry *reg;
 
 
  if (type == CRX_C_REGTYPE)
  if (type == CRX_C_REGTYPE)
    reg = &crx_copregtab[r];
    reg = &crx_copregtab[r];
  else if (type == CRX_CS_REGTYPE)
  else if (type == CRX_CS_REGTYPE)
    reg = &crx_copregtab[r+(cs0-c0)];
    reg = &crx_copregtab[r+(cs0-c0)];
  else
  else
    return ILLEGAL;
    return ILLEGAL;
 
 
  return reg->name;
  return reg->name;
}
}
 
 
 
 
/* Getting a processor register name.  */
/* Getting a processor register name.  */
 
 
static char *
static char *
getprocregname (int index)
getprocregname (int index)
{
{
  const reg_entry *r;
  const reg_entry *r;
 
 
  for (r = crx_regtab; r < crx_regtab + NUMREGS; r++)
  for (r = crx_regtab; r < crx_regtab + NUMREGS; r++)
    if (r->image == index)
    if (r->image == index)
      return r->name;
      return r->name;
 
 
  return "ILLEGAL REGISTER";
  return "ILLEGAL REGISTER";
}
}
 
 
/* Get the power of two for a given integer.  */
/* Get the power of two for a given integer.  */
 
 
static int
static int
powerof2 (int x)
powerof2 (int x)
{
{
  int product, i;
  int product, i;
 
 
  for (i = 0, product = 1; i < x; i++)
  for (i = 0, product = 1; i < x; i++)
    product *= 2;
    product *= 2;
 
 
  return product;
  return product;
}
}
 
 
/* Transform a register bit mask to a register list.  */
/* Transform a register bit mask to a register list.  */
 
 
void
void
getregliststring (int mask, char *string, enum REG_ARG_TYPE core_cop)
getregliststring (int mask, char *string, enum REG_ARG_TYPE core_cop)
{
{
  char temp_string[5];
  char temp_string[5];
  int i;
  int i;
 
 
  string[0] = '{';
  string[0] = '{';
  string[1] = '\0';
  string[1] = '\0';
 
 
 
 
  /* A zero mask means HI/LO registers.  */
  /* A zero mask means HI/LO registers.  */
  if (mask == 0)
  if (mask == 0)
    {
    {
      if (core_cop == USER_REG_ARG)
      if (core_cop == USER_REG_ARG)
        strcat (string, "ulo,uhi");
        strcat (string, "ulo,uhi");
      else
      else
        strcat (string, "lo,hi");
        strcat (string, "lo,hi");
    }
    }
  else
  else
    {
    {
      for (i = 0; i < 16; i++)
      for (i = 0; i < 16; i++)
        {
        {
          if (mask & 0x1)
          if (mask & 0x1)
            {
            {
              switch (core_cop)
              switch (core_cop)
              {
              {
              case REG_ARG:
              case REG_ARG:
                sprintf (temp_string, "r%d", i);
                sprintf (temp_string, "r%d", i);
                break;
                break;
              case USER_REG_ARG:
              case USER_REG_ARG:
                sprintf (temp_string, "u%d", i);
                sprintf (temp_string, "u%d", i);
                break;
                break;
              case COP_ARG:
              case COP_ARG:
                sprintf (temp_string, "c%d", i);
                sprintf (temp_string, "c%d", i);
                break;
                break;
              case COPS_ARG:
              case COPS_ARG:
                sprintf (temp_string, "cs%d", i);
                sprintf (temp_string, "cs%d", i);
                break;
                break;
              default:
              default:
                break;
                break;
              }
              }
              strcat (string, temp_string);
              strcat (string, temp_string);
              if (mask & 0xfffe)
              if (mask & 0xfffe)
                strcat (string, ",");
                strcat (string, ",");
            }
            }
          mask >>= 1;
          mask >>= 1;
        }
        }
    }
    }
 
 
  strcat (string, "}");
  strcat (string, "}");
}
}
 
 
/* START and END are relating 'allWords' struct, which is 48 bits size.
/* START and END are relating 'allWords' struct, which is 48 bits size.
 
 
                          START|--------|END
                          START|--------|END
            +---------+---------+---------+---------+
            +---------+---------+---------+---------+
            |         |    V    |     A   |   L     |
            |         |    V    |     A   |   L     |
            +---------+---------+---------+---------+
            +---------+---------+---------+---------+
                      0         16        32        48
                      0         16        32        48
    words                 [0]       [1]       [2]       */
    words                 [0]       [1]       [2]       */
 
 
static parameter
static parameter
makelongparameter (ULONGLONG val, int start, int end)
makelongparameter (ULONGLONG val, int start, int end)
{
{
  parameter p;
  parameter p;
 
 
  p.val = (dwordU) EXTRACT(val, 48 - end, end - start);
  p.val = (dwordU) EXTRACT(val, 48 - end, end - start);
  p.nbits = end - start;
  p.nbits = end - start;
  return p;
  return p;
}
}
 
 
/* Build a mask of the instruction's 'constant' opcode,
/* Build a mask of the instruction's 'constant' opcode,
   based on the instruction's printing flags.  */
   based on the instruction's printing flags.  */
 
 
static unsigned long
static unsigned long
build_mask (void)
build_mask (void)
{
{
  unsigned int print_flags;
  unsigned int print_flags;
  unsigned long mask;
  unsigned long mask;
 
 
  print_flags = instruction->flags & FMT_CRX;
  print_flags = instruction->flags & FMT_CRX;
  switch (print_flags)
  switch (print_flags)
    {
    {
      case FMT_1:
      case FMT_1:
        mask = 0xF0F00000;
        mask = 0xF0F00000;
        break;
        break;
      case FMT_2:
      case FMT_2:
        mask = 0xFFF0FF00;
        mask = 0xFFF0FF00;
        break;
        break;
      case FMT_3:
      case FMT_3:
        mask = 0xFFF00F00;
        mask = 0xFFF00F00;
        break;
        break;
      case FMT_4:
      case FMT_4:
        mask = 0xFFF0F000;
        mask = 0xFFF0F000;
        break;
        break;
      case FMT_5:
      case FMT_5:
        mask = 0xFFF0FFF0;
        mask = 0xFFF0FFF0;
        break;
        break;
      default:
      default:
        mask = SBM(instruction->match_bits);
        mask = SBM(instruction->match_bits);
        break;
        break;
    }
    }
 
 
  return mask;
  return mask;
}
}
 
 
/* Search for a matching opcode. Return 1 for success, 0 for failure.  */
/* Search for a matching opcode. Return 1 for success, 0 for failure.  */
 
 
static int
static int
match_opcode (void)
match_opcode (void)
{
{
  unsigned long mask;
  unsigned long mask;
 
 
  /* The instruction 'constant' opcode doewsn't exceed 32 bits.  */
  /* The instruction 'constant' opcode doewsn't exceed 32 bits.  */
  unsigned long doubleWord = words[1] + (words[0] << 16);
  unsigned long doubleWord = words[1] + (words[0] << 16);
 
 
  /* Start searching from end of instruction table.  */
  /* Start searching from end of instruction table.  */
  instruction = &crx_instruction[NUMOPCODES - 2];
  instruction = &crx_instruction[NUMOPCODES - 2];
 
 
  /* Loop over instruction table until a full match is found.  */
  /* Loop over instruction table until a full match is found.  */
  while (instruction >= crx_instruction)
  while (instruction >= crx_instruction)
    {
    {
      mask = build_mask ();
      mask = build_mask ();
      if ((doubleWord & mask) == BIN(instruction->match, instruction->match_bits))
      if ((doubleWord & mask) == BIN(instruction->match, instruction->match_bits))
        return 1;
        return 1;
      else
      else
        instruction--;
        instruction--;
    }
    }
  return 0;
  return 0;
}
}
 
 
/* Set the proper parameter value for different type of arguments.  */
/* Set the proper parameter value for different type of arguments.  */
 
 
static void
static void
make_argument (argument * a, int start_bits)
make_argument (argument * a, int start_bits)
{
{
  int inst_bit_size, total_size;
  int inst_bit_size, total_size;
  parameter p;
  parameter p;
 
 
  if ((instruction->size == 3) && a->size >= 16)
  if ((instruction->size == 3) && a->size >= 16)
    inst_bit_size = 48;
    inst_bit_size = 48;
  else
  else
    inst_bit_size = 32;
    inst_bit_size = 32;
 
 
  switch (a->type)
  switch (a->type)
    {
    {
    case arg_copr:
    case arg_copr:
    case arg_copsr:
    case arg_copsr:
      p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
      p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
                             inst_bit_size - start_bits);
                             inst_bit_size - start_bits);
      a->cr = p.val;
      a->cr = p.val;
      break;
      break;
 
 
    case arg_r:
    case arg_r:
      p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
      p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
                             inst_bit_size - start_bits);
                             inst_bit_size - start_bits);
      a->r = p.val;
      a->r = p.val;
      break;
      break;
 
 
    case arg_ic:
    case arg_ic:
      p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
      p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
                             inst_bit_size - start_bits);
                             inst_bit_size - start_bits);
 
 
      if ((p.nbits == 4) && cst4flag)
      if ((p.nbits == 4) && cst4flag)
        {
        {
          if (IS_INSN_TYPE (CMPBR_INS) && (p.val == ESCAPE_16_BIT))
          if (IS_INSN_TYPE (CMPBR_INS) && (p.val == ESCAPE_16_BIT))
            {
            {
              /* A special case, where the value is actually stored
              /* A special case, where the value is actually stored
                 in the last 4 bits.  */
                 in the last 4 bits.  */
              p = makelongparameter (allWords, 44, 48);
              p = makelongparameter (allWords, 44, 48);
              /* The size of the instruction should be incremented.  */
              /* The size of the instruction should be incremented.  */
              size_changed = 1;
              size_changed = 1;
            }
            }
 
 
          if (p.val == 6)
          if (p.val == 6)
            p.val = -1;
            p.val = -1;
          else if (p.val == 13)
          else if (p.val == 13)
            p.val = 48;
            p.val = 48;
          else if (p.val == 5)
          else if (p.val == 5)
            p.val = -4;
            p.val = -4;
          else if (p.val == 10)
          else if (p.val == 10)
            p.val = 32;
            p.val = 32;
          else if (p.val == 11)
          else if (p.val == 11)
            p.val = 20;
            p.val = 20;
          else if (p.val == 9)
          else if (p.val == 9)
            p.val = 16;
            p.val = 16;
        }
        }
 
 
      a->constant = p.val;
      a->constant = p.val;
      break;
      break;
 
 
    case arg_idxr:
    case arg_idxr:
      a->scale = 0;
      a->scale = 0;
      total_size = a->size + 10;  /* sizeof(rbase + ridx + scl2) = 10.  */
      total_size = a->size + 10;  /* sizeof(rbase + ridx + scl2) = 10.  */
      p = makelongparameter (allWords, inst_bit_size - total_size,
      p = makelongparameter (allWords, inst_bit_size - total_size,
                             inst_bit_size - (total_size - 4));
                             inst_bit_size - (total_size - 4));
      a->r = p.val;
      a->r = p.val;
      p = makelongparameter (allWords, inst_bit_size - (total_size - 4),
      p = makelongparameter (allWords, inst_bit_size - (total_size - 4),
                             inst_bit_size - (total_size - 8));
                             inst_bit_size - (total_size - 8));
      a->i_r = p.val;
      a->i_r = p.val;
      p = makelongparameter (allWords, inst_bit_size - (total_size - 8),
      p = makelongparameter (allWords, inst_bit_size - (total_size - 8),
                             inst_bit_size - (total_size - 10));
                             inst_bit_size - (total_size - 10));
      a->scale = p.val;
      a->scale = p.val;
      p = makelongparameter (allWords, inst_bit_size - (total_size - 10),
      p = makelongparameter (allWords, inst_bit_size - (total_size - 10),
                             inst_bit_size);
                             inst_bit_size);
      a->constant = p.val;
      a->constant = p.val;
      break;
      break;
 
 
    case arg_rbase:
    case arg_rbase:
      p = makelongparameter (allWords, inst_bit_size - (start_bits + 4),
      p = makelongparameter (allWords, inst_bit_size - (start_bits + 4),
                             inst_bit_size - start_bits);
                             inst_bit_size - start_bits);
      a->r = p.val;
      a->r = p.val;
      break;
      break;
 
 
    case arg_cr:
    case arg_cr:
      if (a->size <= 8)
      if (a->size <= 8)
        {
        {
          p = makelongparameter (allWords, inst_bit_size - (start_bits + 4),
          p = makelongparameter (allWords, inst_bit_size - (start_bits + 4),
                                 inst_bit_size - start_bits);
                                 inst_bit_size - start_bits);
          a->r = p.val;
          a->r = p.val;
          /* Case for opc4 r dispu rbase.  */
          /* Case for opc4 r dispu rbase.  */
          p = makelongparameter (allWords, inst_bit_size - (start_bits + 8),
          p = makelongparameter (allWords, inst_bit_size - (start_bits + 8),
                                 inst_bit_size - (start_bits + 4));
                                 inst_bit_size - (start_bits + 4));
        }
        }
      else
      else
        {
        {
          /* The 'rbase' start_bits is always relative to a 32-bit data type.  */
          /* The 'rbase' start_bits is always relative to a 32-bit data type.  */
          p = makelongparameter (allWords, 32 - (start_bits + 4),
          p = makelongparameter (allWords, 32 - (start_bits + 4),
                                 32 - start_bits);
                                 32 - start_bits);
          a->r = p.val;
          a->r = p.val;
          p = makelongparameter (allWords, 32 - start_bits,
          p = makelongparameter (allWords, 32 - start_bits,
                                 inst_bit_size);
                                 inst_bit_size);
        }
        }
      if ((p.nbits == 4) && cst4flag)
      if ((p.nbits == 4) && cst4flag)
        {
        {
          if (instruction->flags & DISPUW4)
          if (instruction->flags & DISPUW4)
            p.val *= 2;
            p.val *= 2;
          else if (instruction->flags & DISPUD4)
          else if (instruction->flags & DISPUD4)
            p.val *= 4;
            p.val *= 4;
        }
        }
      a->constant = p.val;
      a->constant = p.val;
      break;
      break;
 
 
    case arg_c:
    case arg_c:
      p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
      p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
                             inst_bit_size - start_bits);
                             inst_bit_size - start_bits);
      a->constant = p.val;
      a->constant = p.val;
      break;
      break;
    default:
    default:
      break;
      break;
    }
    }
}
}
 
 
/*  Print a single argument.  */
/*  Print a single argument.  */
 
 
static void
static void
print_arg (argument *a, bfd_vma memaddr, struct disassemble_info *info)
print_arg (argument *a, bfd_vma memaddr, struct disassemble_info *info)
{
{
  LONGLONG longdisp, mask;
  LONGLONG longdisp, mask;
  int sign_flag = 0;
  int sign_flag = 0;
  int relative = 0;
  int relative = 0;
  bfd_vma number;
  bfd_vma number;
  int op_index = 0;
  int op_index = 0;
  char string[200];
  char string[200];
  PTR stream = info->stream;
  PTR stream = info->stream;
  fprintf_ftype func = info->fprintf_func;
  fprintf_ftype func = info->fprintf_func;
 
 
  switch (a->type)
  switch (a->type)
    {
    {
    case arg_copr:
    case arg_copr:
      func (stream, "%s", getcopregname (a->cr, CRX_C_REGTYPE));
      func (stream, "%s", getcopregname (a->cr, CRX_C_REGTYPE));
      break;
      break;
 
 
    case arg_copsr:
    case arg_copsr:
      func (stream, "%s", getcopregname (a->cr, CRX_CS_REGTYPE));
      func (stream, "%s", getcopregname (a->cr, CRX_CS_REGTYPE));
      break;
      break;
 
 
    case arg_r:
    case arg_r:
      if (IS_INSN_MNEMONIC ("mtpr") || IS_INSN_MNEMONIC ("mfpr"))
      if (IS_INSN_MNEMONIC ("mtpr") || IS_INSN_MNEMONIC ("mfpr"))
        func (stream, "%s", getprocregname (a->r));
        func (stream, "%s", getprocregname (a->r));
      else
      else
        func (stream, "%s", getregname (a->r));
        func (stream, "%s", getregname (a->r));
      break;
      break;
 
 
    case arg_ic:
    case arg_ic:
      if (IS_INSN_MNEMONIC ("excp"))
      if (IS_INSN_MNEMONIC ("excp"))
        func (stream, "%s", gettrapstring (a->constant));
        func (stream, "%s", gettrapstring (a->constant));
 
 
      else if (IS_INSN_MNEMONIC ("cinv"))
      else if (IS_INSN_MNEMONIC ("cinv"))
        func (stream, "%s", getcinvstring (a->constant));
        func (stream, "%s", getcinvstring (a->constant));
 
 
      else if (INST_HAS_REG_LIST)
      else if (INST_HAS_REG_LIST)
        {
        {
          REG_ARG_TYPE reg_arg_type = IS_INSN_TYPE (COP_REG_INS) ?
          REG_ARG_TYPE reg_arg_type = IS_INSN_TYPE (COP_REG_INS) ?
                                 COP_ARG : IS_INSN_TYPE (COPS_REG_INS) ?
                                 COP_ARG : IS_INSN_TYPE (COPS_REG_INS) ?
                                 COPS_ARG : (instruction->flags & USER_REG) ?
                                 COPS_ARG : (instruction->flags & USER_REG) ?
                                 USER_REG_ARG : REG_ARG;
                                 USER_REG_ARG : REG_ARG;
 
 
          if ((reg_arg_type == COP_ARG) || (reg_arg_type == COPS_ARG))
          if ((reg_arg_type == COP_ARG) || (reg_arg_type == COPS_ARG))
            {
            {
                /*  Check for proper argument number.  */
                /*  Check for proper argument number.  */
                if (processing_argument_number == 2)
                if (processing_argument_number == 2)
                  {
                  {
                    getregliststring (a->constant, string, reg_arg_type);
                    getregliststring (a->constant, string, reg_arg_type);
                    func (stream, "%s", string);
                    func (stream, "%s", string);
                  }
                  }
                else
                else
                  func (stream, "$0x%lx", a->constant);
                  func (stream, "$0x%lx", a->constant);
            }
            }
          else
          else
            {
            {
              getregliststring (a->constant, string, reg_arg_type);
              getregliststring (a->constant, string, reg_arg_type);
              func (stream, "%s", string);
              func (stream, "%s", string);
            }
            }
        }
        }
      else
      else
        func (stream, "$0x%lx", a->constant);
        func (stream, "$0x%lx", a->constant);
      break;
      break;
 
 
    case arg_idxr:
    case arg_idxr:
      func (stream, "0x%lx(%s,%s,%d)", a->constant, getregname (a->r),
      func (stream, "0x%lx(%s,%s,%d)", a->constant, getregname (a->r),
            getregname (a->i_r), powerof2 (a->scale));
            getregname (a->i_r), powerof2 (a->scale));
      break;
      break;
 
 
    case arg_rbase:
    case arg_rbase:
      func (stream, "(%s)", getregname (a->r));
      func (stream, "(%s)", getregname (a->r));
      break;
      break;
 
 
    case arg_cr:
    case arg_cr:
      func (stream, "0x%lx(%s)", a->constant, getregname (a->r));
      func (stream, "0x%lx(%s)", a->constant, getregname (a->r));
 
 
      if (IS_INSN_TYPE (LD_STOR_INS_INC))
      if (IS_INSN_TYPE (LD_STOR_INS_INC))
        func (stream, "+");
        func (stream, "+");
      break;
      break;
 
 
    case arg_c:
    case arg_c:
      /* Removed the *2 part as because implicit zeros are no more required.
      /* Removed the *2 part as because implicit zeros are no more required.
         Have to fix this as this needs a bit of extension in terms of branchins.
         Have to fix this as this needs a bit of extension in terms of branchins.
         Have to add support for cmp and branch instructions.  */
         Have to add support for cmp and branch instructions.  */
      if (IS_INSN_TYPE (BRANCH_INS) || IS_INSN_MNEMONIC ("bal")
      if (IS_INSN_TYPE (BRANCH_INS) || IS_INSN_MNEMONIC ("bal")
          || IS_INSN_TYPE (CMPBR_INS) || IS_INSN_TYPE (DCR_BRANCH_INS)
          || IS_INSN_TYPE (CMPBR_INS) || IS_INSN_TYPE (DCR_BRANCH_INS)
          || IS_INSN_TYPE (COP_BRANCH_INS))
          || IS_INSN_TYPE (COP_BRANCH_INS))
        {
        {
          relative = 1;
          relative = 1;
          longdisp = a->constant;
          longdisp = a->constant;
          longdisp <<= 1;
          longdisp <<= 1;
 
 
          switch (a->size)
          switch (a->size)
            {
            {
            case 8:
            case 8:
            case 16:
            case 16:
            case 24:
            case 24:
            case 32:
            case 32:
              mask = ((LONGLONG)1 << a->size) - 1;
              mask = ((LONGLONG)1 << a->size) - 1;
              if (longdisp & ((LONGLONG)1 << a->size))
              if (longdisp & ((LONGLONG)1 << a->size))
                {
                {
                  sign_flag = 1;
                  sign_flag = 1;
                  longdisp = ~(longdisp) + 1;
                  longdisp = ~(longdisp) + 1;
                }
                }
              a->constant = (unsigned long int) (longdisp & mask);
              a->constant = (unsigned long int) (longdisp & mask);
              break;
              break;
            default:
            default:
              func (stream,
              func (stream,
                    "Wrong offset used in branch/bal instruction");
                    "Wrong offset used in branch/bal instruction");
              break;
              break;
            }
            }
 
 
        }
        }
      /* For branch Neq instruction it is 2*offset + 2.  */
      /* For branch Neq instruction it is 2*offset + 2.  */
      else if (IS_INSN_TYPE (BRANCH_NEQ_INS))
      else if (IS_INSN_TYPE (BRANCH_NEQ_INS))
        a->constant = 2 * a->constant + 2;
        a->constant = 2 * a->constant + 2;
      else if (IS_INSN_TYPE (LD_STOR_INS_INC)
      else if (IS_INSN_TYPE (LD_STOR_INS_INC)
          || IS_INSN_TYPE (LD_STOR_INS)
          || IS_INSN_TYPE (LD_STOR_INS)
          || IS_INSN_TYPE (STOR_IMM_INS)
          || IS_INSN_TYPE (STOR_IMM_INS)
          || IS_INSN_TYPE (CSTBIT_INS))
          || IS_INSN_TYPE (CSTBIT_INS))
        {
        {
          op_index = instruction->flags & REVERSE_MATCH ? 0 : 1;
          op_index = instruction->flags & REVERSE_MATCH ? 0 : 1;
          if (instruction->operands[op_index].op_type == abs16)
          if (instruction->operands[op_index].op_type == abs16)
            a->constant |= 0xFFFF0000;
            a->constant |= 0xFFFF0000;
        }
        }
      func (stream, "%s", "0x");
      func (stream, "%s", "0x");
      number = (relative ? memaddr : 0)
      number = (relative ? memaddr : 0)
               + (sign_flag ? -a->constant : a->constant);
               + (sign_flag ? -a->constant : a->constant);
      (*info->print_address_func) (number, info);
      (*info->print_address_func) (number, info);
      break;
      break;
    default:
    default:
      break;
      break;
    }
    }
}
}
 
 
/* Print all the arguments of CURRINSN instruction.  */
/* Print all the arguments of CURRINSN instruction.  */
 
 
static void
static void
print_arguments (ins *currInsn, bfd_vma memaddr, struct disassemble_info *info)
print_arguments (ins *currInsn, bfd_vma memaddr, struct disassemble_info *info)
{
{
  int i;
  int i;
 
 
  for (i = 0; i < currInsn->nargs; i++)
  for (i = 0; i < currInsn->nargs; i++)
    {
    {
      processing_argument_number = i;
      processing_argument_number = i;
 
 
      print_arg (&currInsn->arg[i], memaddr, info);
      print_arg (&currInsn->arg[i], memaddr, info);
 
 
      if (i != currInsn->nargs - 1)
      if (i != currInsn->nargs - 1)
        info->fprintf_func (info->stream, ", ");
        info->fprintf_func (info->stream, ", ");
    }
    }
}
}
 
 
/* Build the instruction's arguments.  */
/* Build the instruction's arguments.  */
 
 
static void
static void
make_instruction (void)
make_instruction (void)
{
{
  int i;
  int i;
  unsigned int shift;
  unsigned int shift;
 
 
  for (i = 0; i < currInsn.nargs; i++)
  for (i = 0; i < currInsn.nargs; i++)
    {
    {
      argument a;
      argument a;
 
 
      memset (&a, 0, sizeof (a));
      memset (&a, 0, sizeof (a));
      a.type = getargtype (instruction->operands[i].op_type);
      a.type = getargtype (instruction->operands[i].op_type);
      if (instruction->operands[i].op_type == cst4
      if (instruction->operands[i].op_type == cst4
          || instruction->operands[i].op_type == rbase_dispu4)
          || instruction->operands[i].op_type == rbase_dispu4)
        cst4flag = 1;
        cst4flag = 1;
      a.size = getbits (instruction->operands[i].op_type);
      a.size = getbits (instruction->operands[i].op_type);
      shift = instruction->operands[i].shift;
      shift = instruction->operands[i].shift;
 
 
      make_argument (&a, shift);
      make_argument (&a, shift);
      currInsn.arg[i] = a;
      currInsn.arg[i] = a;
    }
    }
 
 
  /* Calculate instruction size (in bytes).  */
  /* Calculate instruction size (in bytes).  */
  currInsn.size = instruction->size + (size_changed ? 1 : 0);
  currInsn.size = instruction->size + (size_changed ? 1 : 0);
  /* Now in bits.  */
  /* Now in bits.  */
  currInsn.size *= 2;
  currInsn.size *= 2;
}
}
 
 
/* Retrieve a single word from a given memory address.  */
/* Retrieve a single word from a given memory address.  */
 
 
static wordU
static wordU
get_word_at_PC (bfd_vma memaddr, struct disassemble_info *info)
get_word_at_PC (bfd_vma memaddr, struct disassemble_info *info)
{
{
  bfd_byte buffer[4];
  bfd_byte buffer[4];
  int status;
  int status;
  wordU insn = 0;
  wordU insn = 0;
 
 
  status = info->read_memory_func (memaddr, buffer, 2, info);
  status = info->read_memory_func (memaddr, buffer, 2, info);
 
 
  if (status == 0)
  if (status == 0)
    insn = (wordU) bfd_getl16 (buffer);
    insn = (wordU) bfd_getl16 (buffer);
 
 
  return insn;
  return insn;
}
}
 
 
/* Retrieve multiple words (3) from a given memory address.  */
/* Retrieve multiple words (3) from a given memory address.  */
 
 
static void
static void
get_words_at_PC (bfd_vma memaddr, struct disassemble_info *info)
get_words_at_PC (bfd_vma memaddr, struct disassemble_info *info)
{
{
  int i;
  int i;
  bfd_vma mem;
  bfd_vma mem;
 
 
  for (i = 0, mem = memaddr; i < 3; i++, mem += 2)
  for (i = 0, mem = memaddr; i < 3; i++, mem += 2)
    words[i] = get_word_at_PC (mem, info);
    words[i] = get_word_at_PC (mem, info);
 
 
  allWords =
  allWords =
    ((ULONGLONG) words[0] << 32) + ((unsigned long) words[1] << 16) + words[2];
    ((ULONGLONG) words[0] << 32) + ((unsigned long) words[1] << 16) + words[2];
}
}
 
 
/* Prints the instruction by calling print_arguments after proper matching.  */
/* Prints the instruction by calling print_arguments after proper matching.  */
 
 
int
int
print_insn_crx (memaddr, info)
print_insn_crx (memaddr, info)
     bfd_vma memaddr;
     bfd_vma memaddr;
     struct disassemble_info *info;
     struct disassemble_info *info;
{
{
  int is_decoded;     /* Nonzero means instruction has a match.  */
  int is_decoded;     /* Nonzero means instruction has a match.  */
 
 
  /* Initialize global variables.  */
  /* Initialize global variables.  */
  cst4flag = 0;
  cst4flag = 0;
  size_changed = 0;
  size_changed = 0;
 
 
  /* Retrieve the encoding from current memory location.  */
  /* Retrieve the encoding from current memory location.  */
  get_words_at_PC (memaddr, info);
  get_words_at_PC (memaddr, info);
  /* Find a matching opcode in table.  */
  /* Find a matching opcode in table.  */
  is_decoded = match_opcode ();
  is_decoded = match_opcode ();
  /* If found, print the instruction's mnemonic and arguments.  */
  /* If found, print the instruction's mnemonic and arguments.  */
  if (is_decoded > 0 && (words[0] << 16 || words[1]) != 0)
  if (is_decoded > 0 && (words[0] << 16 || words[1]) != 0)
    {
    {
      info->fprintf_func (info->stream, "%s", instruction->mnemonic);
      info->fprintf_func (info->stream, "%s", instruction->mnemonic);
      if ((currInsn.nargs = get_number_of_operands ()) != 0)
      if ((currInsn.nargs = get_number_of_operands ()) != 0)
        info->fprintf_func (info->stream, "\t");
        info->fprintf_func (info->stream, "\t");
      make_instruction ();
      make_instruction ();
      print_arguments (&currInsn, memaddr, info);
      print_arguments (&currInsn, memaddr, info);
      return currInsn.size;
      return currInsn.size;
    }
    }
 
 
  /* No match found.  */
  /* No match found.  */
  info->fprintf_func (info->stream,"%s ",ILLEGAL);
  info->fprintf_func (info->stream,"%s ",ILLEGAL);
  return 2;
  return 2;
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.