Subversion Repositories or1k

/* Instruction printing code for the OpenRISC 1000
 
   Copyright (C) 2002, 2005, 2007 Free Software Foundation, Inc.
   Copyright (C) 2008 Embecosm Limited
 
   Contributed by Damjan Lampret <lampret@opencores.org>.
   Modified from a29k port.
   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
   This file is part of the GNU opcodes library.
 
   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 3 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, see <http://www.gnu.org/licenses/>.  */
 
/*-----------------------------------------------------------------------------
   This version for the OpenRISC 1000 architecture is an update by Jeremy
   Bennett for GDB 6.8. All code converted to ANSI C style and in general to
   GDB format.
 
   Signed immediate constants are printed as such (the old version printed
   them as unsigned hex). Where appropriate symbolic names are used for
   immediate branch and jump targets.
   --------------------------------------------------------------------------*/
 
 
#include "dis-asm.h"
#include "opcode/or32.h"
#include "safe-ctype.h"
#include <string.h>
#include <stdlib.h>
 
 
#define EXTEND29(x) ((x) & (unsigned long) 0x10000000 ? ((x) | (unsigned long) 0xf0000000) : ((x)))
 
/* A cop out - this is in defs.h, but including that from the main GDB
   component would be a pain. Really the dependency on CORE_ADDR ought to be
   added to the or1k-tdep.c, rather than being here. Something for the
   future. */
typedef bfd_vma CORE_ADDR;
 
 
/* Function to look up an address as a symbol. Found in the GDB area */
extern int
build_address_symbolic (CORE_ADDR   addr,
			int         do_demangle,
			char      **name,
			int        *offset,
			char      **filename,
			int        *line,
			int        *unmapped);
 
 
/*!----------------------------------------------------------------------------
   Map 4 bytes of instruction into one 32-bit word for big-endian target
 
   @param[in]  insn_ch  The 4 bytes of the instruction
   @param[out] insn     The 32-bit word
   --------------------------------------------------------------------------*/
 
static void
find_bytes_big (unsigned char *insn_ch,
		unsigned long *insn)
{
  *insn =
    ((unsigned long) insn_ch[0] << 24) +
    ((unsigned long) insn_ch[1] << 16) +
    ((unsigned long) insn_ch[2] << 8) +
    ((unsigned long) insn_ch[3]);
 
}	/* find_bytes_big() */
 
 
/*!----------------------------------------------------------------------------
   Map 4 bytes of instruction into one 32-bit word for little-endian target
 
   @param[in]  insn_ch  The 4 bytes of the instruction
   @param[out] insn     The 32-bit word
   --------------------------------------------------------------------------*/
 
static void
find_bytes_little (unsigned char *insn_ch,
		   unsigned long *insn)
{
  *insn =
    ((unsigned long) insn_ch[3] << 24) +
    ((unsigned long) insn_ch[2] << 16) +
    ((unsigned long) insn_ch[1] << 8) +
    ((unsigned long) insn_ch[0]);
 
}	/* find_bytes_little() */
 
 
/*!----------------------------------------------------------------------------
   Extract an instruction field
 
   @param[in] param_ch     The character identifying the field
   @param[in] enc_initial  A string with 1 char for each bit in the
                           instruction, the char indicating the field the bit
                           belongs to
   @param[in] insn         The instruction
 
   @return  The value of the field
   --------------------------------------------------------------------------*/
 
static unsigned long
or32_extract (char               param_ch,
	      char              *enc_initial,
	      unsigned long int  insn)
{
  char              *enc;
  unsigned long int  ret       = 0;
  int                opc_pos   = 0;
  int                param_pos = 0;
 
  for (enc = enc_initial; *enc != '\0'; enc++)
    {
      if (*enc == param_ch)
	{
	  if ((enc - 2    >= enc_initial) &&
	      (*(enc - 2) == '0')         &&
	      (*(enc - 1) == 'x'))
	    {
	      continue;
	    }
	  else
	    {
	      param_pos++;
	    }
	}
    }
 
  opc_pos = 32;
 
  for (enc = enc_initial; *enc != '\0'; )
    {
      if ((*enc == '0') && (*(enc + 1) == 'x'))
	{
	  opc_pos -= 4;
 
	  if ((param_ch == '0') || (param_ch == '1'))
	    {
	      unsigned long tmp = strtoul (enc, NULL, 16);
 
	      if (param_ch == '0') {
		tmp = 15 - tmp;
	      }
 
	      ret |= tmp << opc_pos;
	    }
 
	  enc += 3;
	}
      else if ((*enc == '0') || (*enc == '1'))
	{
	  opc_pos--;
 
	  if (param_ch == *enc) {
	    ret |= 1 << opc_pos;
	  }
 
	  enc++;
	}
      else if (*enc == param_ch)
	{
	  opc_pos--;
	  param_pos--;
	  ret += ((insn >> opc_pos) & 0x1) << param_pos;
 
	  if (!param_pos               &&
	      letter_signed (param_ch) &&
	      ret >> (letter_range (param_ch) - 1))
	    {
	      ret |= 0xffffffff << letter_range(param_ch);
	    }
	  enc++;
	}
      else if (ISALPHA (*enc))
	{
	  opc_pos--;
	  enc++;
	}
      else if (*enc == '-')
	{
	  opc_pos--;
	  enc++;
	}
      else
	{
	  enc++;
	}
    }
 
  return ret;
 
}	/* or32_extract() */
 
 
/*!----------------------------------------------------------------------------
   Test if an instruction matches an encoding
 
   @param[in] insn      The instruction
   @param[in] encoding  The encoding
 
   @return  1 (true) if they match, 0 otherwise
   --------------------------------------------------------------------------*/
 
static int
or32_opcode_match (unsigned long insn, char *encoding)
{
  unsigned long ones, zeros;
 
  ones  = or32_extract ('1', encoding, insn);
  zeros = or32_extract ('0', encoding, insn);
 
  if ((insn & ones) != ones)
    {
      return 0;
    }
 
  if ((~insn & zeros) != zeros)
    {
      return 0;
    }
 
  return 1;
 
}	/* or32_opcode_match() */
 
 
/*!----------------------------------------------------------------------------
   Print register to INFO->STREAM.
 
   Used only by print_insn.
 
   @param[in] param_ch  The character encoding the field of interest
   @param[in] encoding  The encoding
   @param[in] insn      The instruction
   @param[in] info      Info about the disassembly, in particular with the
                        stream to write to.
   --------------------------------------------------------------------------*/
 
static void
or32_print_register (char param_ch,
		     char *encoding,
		     unsigned long insn,
		     struct disassemble_info *info)
{
  int regnum = or32_extract (param_ch, encoding, insn);
 
  switch (param_ch)
    {
    case 'A':
    case 'B':
    case 'D':
      (*info->fprintf_func) (info->stream, "r%d", regnum);
      break;
 
    default:
      if (regnum < 16)
	{
	  (*info->fprintf_func) (info->stream, "r%d", regnum);
	}
      else if (regnum < 32)
	{
	  (*info->fprintf_func) (info->stream, "r%d", regnum-16);
	}
      else
	{
	  (*info->fprintf_func) (info->stream, "X%d", regnum);
	}
    }
}	/* or32_print_register() */
 
 
 
/*!----------------------------------------------------------------------------
   Print immediate to INFO->STREAM.
 
   Used only by print_insn.
 
   Fixed in GDB 6.8 to print signed immediate fields correctly and to set the
   target fields of jump and branch to symbols if possible.
 
   @param[in] memaddr   Address of this instruction
   @param[in] param_ch  The character encoding the field of interest
   @param[in] encoding  The encoding
   @param[in] insn      The instruction
   @param[in] info      Info about the disassembly, in particular with the
                        stream to write to.
   --------------------------------------------------------------------------*/
 
/* Print immediate to INFO->STREAM. Used only by print_insn.  */
 
static void
or32_print_immediate( bfd_vma                  memaddr,
		      char                     param_ch,
		      char                    *encoding,
		      unsigned long            insn,
		      struct disassemble_info *info)
{
  int imm = or32_extract(param_ch, encoding, insn);
 
  if ('N' == param_ch)
    {
      CORE_ADDR  target_addr = (CORE_ADDR)(memaddr + (4 * imm));
      char      *name        = NULL;
      char      *filename    = NULL;
      int        unmapped    = 0;
      int        offset      = 0;
      int        line        = 0;
 
      if( 0 == build_address_symbolic( target_addr, 1, &name, &offset,
				       &filename, &line, &unmapped ))
	{
	  (*info->fprintf_func) (info->stream, "<" );
 
	  if( unmapped )
	    {
	      (*info->fprintf_func) (info->stream, "*");
	    }
 
	  (*info->fprintf_func) (info->stream, "%s", name);
 
	  if( offset )
	    {
	      (*info->fprintf_func) (info->stream, "+%d", offset);
	    }
 
	  (*info->fprintf_func) (info->stream, ">" );
	}
      else
	{
	  (*info->fprintf_func) (info->stream, "0x%x", imm);
	}
    }
  else if (letter_signed(param_ch))
    {
      (*info->fprintf_func) (info->stream, "%d", imm);
    }
  else
    {
      (*info->fprintf_func) (info->stream, "0x%x", imm);
    }
}	/* or32_print_immediate() */
 
 
/*!----------------------------------------------------------------------------
   Print one instruction
 
   Print one instruction from MEMADDR on INFO->STREAM.
 
   @param[in] memaddr   Address of the instruction to print
   @param[in] info      Info about the disassembly, in particular with the
                        stream to write to.
 
   @return   The size of the instruction (always 4 on or32).
   --------------------------------------------------------------------------*/
 
static int
print_insn (bfd_vma                  memaddr,
	    struct disassemble_info *info)
{
  /* The raw instruction.  */
  unsigned char insn_ch[4];
  /* Address. Will be sign extened 27-bit.  */
  unsigned long addr;
  /* The four bytes of the instruction.  */
  unsigned long insn;
 
  typedef void (*find_byte_func_type) (unsigned char *, unsigned long *);
 
  find_byte_func_type find_byte_func = (find_byte_func_type) info->private_data;
  struct or32_opcode const *opcode;
 
  int status =
    (*info->read_memory_func) (memaddr, (bfd_byte *) &insn_ch[0], 4, info);
 
  if (status != 0)
    {
      (*info->memory_error_func) (status, memaddr, info);
      return -1;
    }
 
  (*find_byte_func) (&insn_ch[0], &insn);
 
  for (opcode = &or32_opcodes[0];
       opcode < &or32_opcodes[or32_num_opcodes];
       ++opcode)
    {
      if (or32_opcode_match (insn, opcode->encoding))
        {
          char *s;
 
          (*info->fprintf_func) (info->stream, "%-8s ", opcode->name);
 
          for (s = opcode->args; *s != '\0'; ++s)
            {
              switch (*s)
                {
                case '\0':
                  return 4;
 
                case 'r':
                  or32_print_register (*++s, opcode->encoding, insn, info);
                  break;
 
                case 'X':
                  addr = or32_extract ('X', opcode->encoding, insn) << 2;
 
                  /* Calulate the correct address.  XXX is this really correct
		     ??  */
                  addr = memaddr + EXTEND29 (addr);
 
                  (*info->print_address_func)
                    (addr, info);
                  break;
 
                default:
                  if (strchr (opcode->encoding, *s))
		    {
		      or32_print_immediate (memaddr, *s, opcode->encoding,
					    insn, info);
		    }
                  else
		    {
		      (*info->fprintf_func) (info->stream, "%c", *s);
		    }
		}
            }
 
          return 4;
        }
    }
 
  /* This used to be %8x for binutils.  */
  (*info->fprintf_func) (info->stream, ".word 0x%08lx", insn);
  return 4;
 
}	/* print_insn() */
 
 
/*!----------------------------------------------------------------------------
   Disassemble a big-endian or32 instruction
 
   Print one instruction from MEMADDR on INFO->STREAM.
 
   @param[in] memaddr   Address of the instruction to print
   @param[in] info      Info about the disassembly, in particular with the
                        stream to write to.
 
   @return   The size of the instruction (always 4 on or32).
   --------------------------------------------------------------------------*/
 
int
print_insn_big_or32 (bfd_vma                  memaddr,
		     struct disassemble_info *info)
{
  info->private_data = find_bytes_big;
 
  return print_insn (memaddr, info);
 
}	/* print_insn_big_or32() */
 
 
/*!----------------------------------------------------------------------------
   Disassemble a little-endian or32 instruction
 
   Print one instruction from MEMADDR on INFO->STREAM.
 
   @param[in] memaddr   Address of the instruction to print
   @param[in] info      Info about the disassembly, in particular with the
                        stream to write to.
 
   @return   The size of the instruction (always 4 on or32).
   --------------------------------------------------------------------------*/
 
int
print_insn_little_or32 (bfd_vma                  memaddr,
			struct disassemble_info *info)
{
  info->private_data = find_bytes_little;
 
  return print_insn (memaddr, info);
 
}	/* print_insn_little_or32() */