Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Typedefs | Enumerations | Functions | Variables
crx-dis.c File Reference
#include "dis-asm.h"
#include "sysdep.h"
#include "opcode/crx.h"

Go to the source code of this file.

Classes

struct  parameter
struct  cinv_entry

Defines

#define ILLEGAL   "illegal"
#define ESCAPE_16_BIT   0xE
#define EXTRACT(a, offs, n_bits)
#define SBM(offs)   ((((1 << (32 - offs)) -1) << (offs)))

Typedefs

typedef unsigned long dwordU
typedef unsigned short wordU
typedef enum REG_ARG_TYPE REG_ARG_TYPE

Enumerations

enum  REG_ARG_TYPE { REG_ARG = 0, USER_REG_ARG, COP_ARG, COPS_ARG }

Functions

static int get_number_of_operands (void)
static argtype getargtype (operand_type)
static int getbits (operand_type)
static char * getregname (reg)
static char * getcopregname (copreg, reg_type)
static char * getprocregname (int)
static char * gettrapstring (unsigned)
static char * getcinvstring (unsigned)
static void getregliststring (int, char *, enum REG_ARG_TYPE)
static wordU get_word_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 int powerof2 (int)
static int match_opcode (void)
static void make_instruction (void)
static void print_arguments (ins *, bfd_vma, struct disassemble_info *)
static void print_arg (argument *, bfd_vma, struct disassemble_info *)
static char * gettrapstring (unsigned int index)
static char * getcinvstring (unsigned int num)
static parameter makelongparameter (ULONGLONG val, int start, int end)
static void make_argument (argument *a, int start_bits)
int print_insn_crx (bfd_vma memaddr, struct disassemble_info *info)

Variables

const cinv_entry crx_cinvs []
int NUMCINVS = ((sizeof crx_cinvs)/(sizeof crx_cinvs[0]))
const instinstruction
ins currInsn
wordU words [3]
ULONGLONG allWords
int processing_argument_number
int cst4flag
int size_changed

Class Documentation

struct parameter

Definition at line 42 of file crx-dis.c.

Class Members
int nbits
dwordU val
struct cinv_entry

Definition at line 50 of file crx-dis.c.

Class Members
char * str
unsigned int value

Define Documentation

#define ESCAPE_16_BIT   0xE

Definition at line 29 of file crx-dis.c.

#define EXTRACT (   a,
  offs,
  n_bits 
)
Value:
(n_bits == 32 ? (((a) >> (offs)) & 0xffffffffL)   \
  : (((a) >> (offs)) & ((1 << (n_bits)) -1)))

Definition at line 32 of file crx-dis.c.

#define ILLEGAL   "illegal"

Definition at line 27 of file crx-dis.c.

#define SBM (   offs)    ((((1 << (32 - offs)) -1) << (offs)))

Definition at line 37 of file crx-dis.c.


Typedef Documentation

typedef unsigned long dwordU

Definition at line 39 of file crx-dis.c.

typedef enum REG_ARG_TYPE REG_ARG_TYPE
typedef unsigned short wordU

Definition at line 40 of file crx-dis.c.


Enumeration Type Documentation

Enumerator:
REG_ARG 
USER_REG_ARG 
COP_ARG 
COPS_ARG 

Definition at line 69 of file crx-dis.c.

  {
    /* General purpose register (r<N>).  */
    REG_ARG = 0,
    /* User register (u<N>).  */
    USER_REG_ARG,
    /* CO-Processor register (c<N>).  */
    COP_ARG,
    /* CO-Processor special register (cs<N>).  */
    COPS_ARG 
  }

Function Documentation

static unsigned long build_mask ( void  ) [static]

Definition at line 318 of file crx-dis.c.

{
  unsigned int print_flags;
  unsigned long mask;

  print_flags = instruction->flags & FMT_CRX;
  switch (print_flags)
    {
      case FMT_1:
       mask = 0xF0F00000;
       break;
      case FMT_2:
       mask = 0xFFF0FF00;
       break;
      case FMT_3:
       mask = 0xFFF00F00;
       break;
      case FMT_4:
       mask = 0xFFF0F000;
       break;
      case FMT_5:
       mask = 0xFFF0FFF0;
       break;
      default:
       mask = SBM(instruction->match_bits);
       break;
    }

  return mask;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int get_number_of_operands ( void  ) [static]

Definition at line 121 of file crx-dis.c.

{
  int i;

  for (i = 0; instruction->operands[i].op_type && i < MAX_OPERANDS; i++)
    ;

  return i;
}

Here is the caller graph for this function:

static wordU get_word_at_PC ( bfd_vma  memaddr,
struct disassemble_info info 
) [static]

Definition at line 684 of file crx-dis.c.

{
  bfd_byte buffer[4];
  int status;
  wordU insn = 0;

  status = info->read_memory_func (memaddr, buffer, 2, info);

  if (status == 0)
    insn = (wordU) bfd_getl16 (buffer);

  return insn;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void get_words_at_PC ( bfd_vma  memaddr,
struct disassemble_info info 
) [static]

Definition at line 701 of file crx-dis.c.

{
  int i;
  bfd_vma mem;

  for (i = 0, mem = memaddr; i < 3; i++, mem += 2)
    words[i] = get_word_at_PC (mem, info);

  allWords =
    ((ULONGLONG) words[0] << 32) + ((unsigned long) words[1] << 16) + words[2];
}

Here is the call graph for this function:

Here is the caller graph for this function:

static argtype getargtype ( operand_type  op) [static]

Definition at line 145 of file crx-dis.c.

{
  if (op < MAX_OPRD)
    return crx_optab[op].arg_type;
  else
    return nullargs;
}

Here is the caller graph for this function:

static int getbits ( operand_type  op) [static]

Definition at line 134 of file crx-dis.c.

{
  if (op < MAX_OPRD)
    return crx_optab[op].bit_size;
  else
    return 0;
}

Here is the caller graph for this function:

static char* getcinvstring ( unsigned  ) [static]

Here is the caller graph for this function:

static char* getcinvstring ( unsigned int  num) [static]

Definition at line 172 of file crx-dis.c.

{
  const cinv_entry *cinv;

  for (cinv = crx_cinvs; cinv < (crx_cinvs + NUMCINVS); cinv++)
    if (cinv->value == num)
      return cinv->str;

  return ILLEGAL;
}
char * getcopregname ( copreg  r,
reg_type  type 
) [static]

Definition at line 199 of file crx-dis.c.

{
  const reg_entry *reg;

  if (type == CRX_C_REGTYPE)
    reg = &crx_copregtab[r];
  else if (type == CRX_CS_REGTYPE)
    reg = &crx_copregtab[r+(cs0-c0)];
  else
    return ILLEGAL;

  return reg->name;
}

Here is the caller graph for this function:

static char * getprocregname ( int  index) [static]

Definition at line 217 of file crx-dis.c.

{
  const reg_entry *r;

  for (r = crx_regtab; r < crx_regtab + NUMREGS; r++)
    if (r->image == index)
      return r->name;

  return "ILLEGAL REGISTER";
}

Here is the caller graph for this function:

void getregliststring ( int  mask,
char *  string,
enum REG_ARG_TYPE  core_cop 
) [static]

Definition at line 244 of file crx-dis.c.

{
  char temp_string[5];
  int i;

  string[0] = '{';
  string[1] = '\0';


  /* A zero mask means HI/LO registers.  */
  if (mask == 0)
    {
      if (core_cop == USER_REG_ARG)
       strcat (string, "ulo,uhi");
      else
       strcat (string, "lo,hi");
    }
  else
    {
      for (i = 0; i < 16; i++)
       {
         if (mask & 0x1)
           {
             switch (core_cop)
             {
             case REG_ARG:
              sprintf (temp_string, "r%d", i);
              break;
             case USER_REG_ARG:
              sprintf (temp_string, "u%d", i);
              break;
             case COP_ARG:
              sprintf (temp_string, "c%d", i);
              break;
             case COPS_ARG:
              sprintf (temp_string, "cs%d", i);
              break;
             default:
              break;
             }
             strcat (string, temp_string);
             if (mask & 0xfffe)
              strcat (string, ",");
           }
         mask >>= 1;
       }
    }

  strcat (string, "}");
}

Here is the caller graph for this function:

char * getregname ( reg  r) [static]

Definition at line 186 of file crx-dis.c.

{
  const reg_entry *reg = &crx_regtab[r];

  if (reg->type != CRX_R_REGTYPE)
    return ILLEGAL;
  else
    return reg->name;
}

Here is the caller graph for this function:

static char* gettrapstring ( unsigned  ) [static]

Here is the caller graph for this function:

static char* gettrapstring ( unsigned int  index) [static]

Definition at line 157 of file crx-dis.c.

{
  const trap_entry *trap;

  for (trap = crx_traps; trap < crx_traps + NUMTRAPS; trap++)
    if (trap->entry == index)
      return trap->name;

  return ILLEGAL;
}

Here is the call graph for this function:

static void make_argument ( argument a,
int  start_bits 
) [static]

Definition at line 377 of file crx-dis.c.

{
  int inst_bit_size, total_size;
  parameter p;

  if ((instruction->size == 3) && a->size >= 16)
    inst_bit_size = 48;
  else
    inst_bit_size = 32;

  switch (a->type)
    {
    case arg_copr:
    case arg_copsr:
      p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
                          inst_bit_size - start_bits);
      a->cr = p.val;
      break;

    case arg_r:
      p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
                          inst_bit_size - start_bits);
      a->r = p.val;
      break;

    case arg_ic:
      p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
                          inst_bit_size - start_bits);

      if ((p.nbits == 4) && cst4flag)
        {
         if (IS_INSN_TYPE (CMPBR_INS) && (p.val == ESCAPE_16_BIT))
           {
             /* A special case, where the value is actually stored
               in the last 4 bits.  */
             p = makelongparameter (allWords, 44, 48);
             /* The size of the instruction should be incremented.  */
             size_changed = 1;
           }

          if (p.val == 6)
            p.val = -1;
          else if (p.val == 13)
            p.val = 48;
          else if (p.val == 5)
            p.val = -4;
          else if (p.val == 10)
            p.val = 32;
          else if (p.val == 11)
            p.val = 20;
          else if (p.val == 9)
            p.val = 16;
        }

      a->constant = p.val;
      break;

    case arg_idxr:
      a->scale = 0;
      total_size = a->size + 10;  /* sizeof(rbase + ridx + scl2) = 10.  */
      p = makelongparameter (allWords, inst_bit_size - total_size,
                          inst_bit_size - (total_size - 4));
      a->r = p.val;
      p = makelongparameter (allWords, inst_bit_size - (total_size - 4),
                          inst_bit_size - (total_size - 8));
      a->i_r = p.val;
      p = makelongparameter (allWords, inst_bit_size - (total_size - 8),
                          inst_bit_size - (total_size - 10));
      a->scale = p.val;
      p = makelongparameter (allWords, inst_bit_size - (total_size - 10),
                          inst_bit_size);
      a->constant = p.val;
      break;

    case arg_rbase:
      p = makelongparameter (allWords, inst_bit_size - (start_bits + 4),
                          inst_bit_size - start_bits);
      a->r = p.val;
      break;

    case arg_cr:
      if (a->size <= 8)
        {
          p = makelongparameter (allWords, inst_bit_size - (start_bits + 4),
                             inst_bit_size - start_bits);
          a->r = p.val;
          /* Case for opc4 r dispu rbase.  */
          p = makelongparameter (allWords, inst_bit_size - (start_bits + 8),
                             inst_bit_size - (start_bits + 4));
        }
      else
        {
         /* The 'rbase' start_bits is always relative to a 32-bit data type.  */
          p = makelongparameter (allWords, 32 - (start_bits + 4),
                             32 - start_bits);
          a->r = p.val;
          p = makelongparameter (allWords, 32 - start_bits,
                             inst_bit_size);
        }
      if ((p.nbits == 4) && cst4flag)
        {
          if (instruction->flags & DISPUW4)
           p.val *= 2;
          else if (instruction->flags & DISPUD4)
           p.val *= 4;
        }
      a->constant = p.val;
      break;

    case arg_c:
      p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
                          inst_bit_size - start_bits);
      a->constant = p.val;
      break;
    default:
      break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void make_instruction ( void  ) [static]

Definition at line 654 of file crx-dis.c.

{
  int i;
  unsigned int shift;

  for (i = 0; i < currInsn.nargs; i++)
    {
      argument a;

      memset (&a, 0, sizeof (a));
      a.type = getargtype (instruction->operands[i].op_type);
      if (instruction->operands[i].op_type == cst4
         || instruction->operands[i].op_type == rbase_dispu4)
       cst4flag = 1;
      a.size = getbits (instruction->operands[i].op_type);
      shift = instruction->operands[i].shift;

      make_argument (&a, shift);
      currInsn.arg[i] = a;
    }

  /* Calculate instruction size (in bytes).  */
  currInsn.size = instruction->size + (size_changed ? 1 : 0);
  /* Now in bits.  */
  currInsn.size *= 2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static parameter makelongparameter ( ULONGLONG  val,
int  start,
int  end 
) [static]

Definition at line 305 of file crx-dis.c.

{
  parameter p;

  p.val = (dwordU) EXTRACT(val, 48 - end, end - start);
  p.nbits = end - start;
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int match_opcode ( void  ) [static]

Definition at line 352 of file crx-dis.c.

{
  unsigned long mask;

  /* The instruction 'constant' opcode doewsn't exceed 32 bits.  */
  unsigned long doubleWord = words[1] + (words[0] << 16);

  /* Start searching from end of instruction table.  */
  instruction = &crx_instruction[NUMOPCODES - 2];

  /* Loop over instruction table until a full match is found.  */
  while (instruction >= crx_instruction)
    {
      mask = build_mask ();
      if ((doubleWord & mask) == BIN(instruction->match, instruction->match_bits))
       return 1;
      else
       instruction--;
    }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int powerof2 ( int  x) [static]

Definition at line 231 of file crx-dis.c.

{
  int product, i;

  for (i = 0, product = 1; i < x; i++)
    product *= 2;

  return product;
}

Here is the caller graph for this function:

static void print_arg ( argument a,
bfd_vma  memaddr,
struct disassemble_info info 
) [static]

Definition at line 499 of file crx-dis.c.

{
  LONGLONG longdisp, mask;
  int sign_flag = 0;
  int relative = 0;
  bfd_vma number;
  int op_index = 0;
  char string[200];
  PTR stream = info->stream;
  fprintf_ftype func = info->fprintf_func;

  switch (a->type)
    {
    case arg_copr:
      func (stream, "%s", getcopregname (a->cr, CRX_C_REGTYPE));
      break;

    case arg_copsr:
      func (stream, "%s", getcopregname (a->cr, CRX_CS_REGTYPE));
      break;

    case arg_r:
      if (IS_INSN_MNEMONIC ("mtpr") || IS_INSN_MNEMONIC ("mfpr"))
       func (stream, "%s", getprocregname (a->r));
      else
       func (stream, "%s", getregname (a->r));
      break;

    case arg_ic:
      if (IS_INSN_MNEMONIC ("excp"))
       func (stream, "%s", gettrapstring (a->constant));

      else if (IS_INSN_MNEMONIC ("cinv"))
       func (stream, "%s", getcinvstring (a->constant));

      else if (INST_HAS_REG_LIST)
        {
         REG_ARG_TYPE reg_arg_type = IS_INSN_TYPE (COP_REG_INS) ? 
                             COP_ARG : IS_INSN_TYPE (COPS_REG_INS) ? 
                             COPS_ARG : (instruction->flags & USER_REG) ?
                             USER_REG_ARG : REG_ARG;

          if ((reg_arg_type == COP_ARG) || (reg_arg_type == COPS_ARG))
           {
              /*  Check for proper argument number.  */
              if (processing_argument_number == 2)
                {
                  getregliststring (a->constant, string, reg_arg_type);
                  func (stream, "%s", string);
                }
              else
                func (stream, "$0x%lx", a->constant);
           }
         else
            {
              getregliststring (a->constant, string, reg_arg_type);
              func (stream, "%s", string);
            }
        }
      else
       func (stream, "$0x%lx", a->constant);
      break;

    case arg_idxr:
      func (stream, "0x%lx(%s,%s,%d)", a->constant, getregname (a->r),
           getregname (a->i_r), powerof2 (a->scale));
      break;

    case arg_rbase:
      func (stream, "(%s)", getregname (a->r));
      break;

    case arg_cr:
      func (stream, "0x%lx(%s)", a->constant, getregname (a->r));

      if (IS_INSN_TYPE (LD_STOR_INS_INC))
       func (stream, "+");
      break;

    case arg_c:
      /* 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 add support for cmp and branch instructions.  */
      if (IS_INSN_TYPE (BRANCH_INS) || IS_INSN_MNEMONIC ("bal")
         || IS_INSN_TYPE (CMPBR_INS) || IS_INSN_TYPE (DCR_BRANCH_INS)
         || IS_INSN_TYPE (COP_BRANCH_INS))
        {
         relative = 1;
          longdisp = a->constant;
          longdisp <<= 1;

          switch (a->size)
            {
            case 8:
           case 16:
           case 24:
           case 32:
             mask = ((LONGLONG)1 << a->size) - 1;
              if (longdisp & ((LONGLONG)1 << a->size))
                {
                  sign_flag = 1;
                  longdisp = ~(longdisp) + 1;
                }
              a->constant = (unsigned long int) (longdisp & mask);
              break;
            default:
             func (stream,
                  "Wrong offset used in branch/bal instruction");
              break;
            }

        }
      /* For branch Neq instruction it is 2*offset + 2.  */
      else if (IS_INSN_TYPE (BRANCH_NEQ_INS))
       a->constant = 2 * a->constant + 2;
      else if (IS_INSN_TYPE (LD_STOR_INS_INC)
         || IS_INSN_TYPE (LD_STOR_INS)
         || IS_INSN_TYPE (STOR_IMM_INS)
         || IS_INSN_TYPE (CSTBIT_INS))
        {
          op_index = instruction->flags & REVERSE_MATCH ? 0 : 1;
          if (instruction->operands[op_index].op_type == abs16)
           a->constant |= 0xFFFF0000;
        }
      func (stream, "%s", "0x");
      number = (relative ? memaddr : 0)
              + (sign_flag ? -a->constant : a->constant);
      (*info->print_address_func) (number, info);
      break;
    default:
      break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void print_arguments ( ins currInsn,
bfd_vma  memaddr,
struct disassemble_info info 
) [static]

Definition at line 636 of file crx-dis.c.

{
  int i;

  for (i = 0; i < currInsn->nargs; i++)
    {
      processing_argument_number = i;

      print_arg (&currInsn->arg[i], memaddr, info);

      if (i != currInsn->nargs - 1)
       info->fprintf_func (info->stream, ", ");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int print_insn_crx ( bfd_vma  memaddr,
struct disassemble_info info 
)

Definition at line 716 of file crx-dis.c.

{
  int is_decoded;     /* Nonzero means instruction has a match.  */

  /* Initialize global variables.  */
  cst4flag = 0;
  size_changed = 0;

  /* Retrieve the encoding from current memory location.  */
  get_words_at_PC (memaddr, info);
  /* Find a matching opcode in table.  */
  is_decoded = match_opcode ();
  /* If found, print the instruction's mnemonic and arguments.  */
  if (is_decoded > 0 && (words[0] << 16 || words[1]) != 0)
    {
      info->fprintf_func (info->stream, "%s", instruction->mnemonic);
      if ((currInsn.nargs = get_number_of_operands ()) != 0)
       info->fprintf_func (info->stream, "\t");
      make_instruction ();
      print_arguments (&currInsn, memaddr, info);
      return currInsn.size;
    }

  /* No match found.  */
  info->fprintf_func (info->stream,"%s ",ILLEGAL);
  return 2;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 91 of file crx-dis.c.

Initial value:
{
  {"[i]", 2}, {"[i,u]", 3}, {"[d]", 4}, {"[d,u]", 5}, 
  {"[d,i]", 6}, {"[d,i,u]", 7}, {"[b]", 8}, 
  {"[b,i]", 10}, {"[b,i,u]", 11}, {"[b,d]", 12}, 
  {"[b,d,u]", 13}, {"[b,d,i]", 14}, {"[b,d,i,u]", 15}
}

Definition at line 60 of file crx-dis.c.

Definition at line 95 of file crx-dis.c.

Definition at line 87 of file crx-dis.c.

Definition at line 85 of file crx-dis.c.

int NUMCINVS = ((sizeof crx_cinvs)/(sizeof crx_cinvs[0]))

Definition at line 83 of file crx-dis.c.

Definition at line 93 of file crx-dis.c.

Definition at line 98 of file crx-dis.c.

Definition at line 89 of file crx-dis.c.