Subversion Repositories open8_urisc

/* Disassemble Open8 instructions.
   Copyright 1999, 2000, 2002, 2004, 2005, 2006, 2007, 2008, 2010, 2011
   Free Software Foundation, Inc.
 
   Contributed by Kirk Hays <khays@hayshaus.com>
 
   This file is part of libopcodes.
 
   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
   the Free Software Foundation; either version 3, or (at your option)
   any later version.
 
   It 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., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
 
#include "sysdep.h"
#include "dis-asm.h"
#include "opintl.h"
#include "libiberty.h"
 
struct open8_opcodes_s
{
  char *name;
  char *constraints;
  char *opcode;
  int insn_size;		/* In bytes.  */
  int isa;
  unsigned long long opcode_bits;
  unsigned long long opcode_mask;
};
 
#define OPEN8_INSN(NAME, CONSTR, OPCODE, SIZE, ISA, BIN, MASK)	\
  {#NAME, CONSTR, OPCODE, SIZE, ISA, BIN, MASK},
 
const struct open8_opcodes_s open8_opcodes[] =
  {
#include "opcode/open8.h"
    {NULL, NULL, NULL, 0, 0, 0, 0}
  };
 
static const char * comment_start = "0x";
 
static int
open8_operand (unsigned long long insn,
	       int constraint,
	       char *buf,
	       int buf_len,
	       char *comment,
	       int comment_len,
	       int *sym,
	       bfd_vma *sym_addr)
{
  int ok = 1;
  *sym = 0;
 
  switch (constraint)
    {
      /* Any register operand.  */
    case 'r':
      snprintf (buf, buf_len, "r%d", (int) ((insn & REG_MASK) >> REG_SHIFT));
      break;
 
      /* Even numbered register.  */
    case 'e':
      snprintf (buf, buf_len, "r%d", (int) ((insn & EREG_MASK) >> EREG_SHIFT));
      break;
 
      /* Unsigned offset expression, 8 bits.  */
    case 'u':
      snprintf (buf, buf_len, "%u", (int) ((insn & U_MASK) >> U_SHIFT));
      break;
 
      /* Signed pc-relative offset expression, 8 bits.  */
    case 's':
      {
	int8_t t = ((insn & S_MASK) >> S_SHIFT);
	snprintf (buf, buf_len, "%d", (int)t);  /* Propagate sign bit.  */
      }
      break;
 
      /* Immediate value expression, signed, 8 bits.  */
    case 'i':
      {
	int8_t t = ((insn & I_MASK) >> I_SHIFT);
	snprintf (buf, buf_len, "%d", (int)t);  /* Propagate sign bit.  */
      }
      break;
 
      /* Immediate value expression, 3 bits.  */
    case 'n':
      {
	snprintf (buf, buf_len, "%u", (int) ((insn & N_MASK) >> N_SHIFT));
      }
      break;
 
      /* Immediate value expression, 3 bits, indexing PSR.  */
    case 'b':
      {
	snprintf (buf, buf_len, "%u", (int) ((insn & B_MASK) >> B_SHIFT));
      }
      break;
 
      /* Memory reference, 16 bits, unsigned.  */
    case 'M':
      {
	*sym = 1;
	*sym_addr = (bfd_vma) ((insn & M_MASK) >> M_SHIFT);
	snprintf (buf, buf_len, "%#lx", (unsigned long) *sym_addr);
	strncpy (comment, comment_start, comment_len);
      }
      break;
 
      /* JSR/JMP reference, 16 bits, unsigned.  */
    case 'h':
      {
	*sym = 1;
	*sym_addr = (bfd_vma) ((insn & H_MASK) >> H_SHIFT);
	snprintf (buf, buf_len, "%#lx", (unsigned long) *sym_addr);
	strncpy (comment, comment_start, comment_len);
      }
      break;
 
      /* JSR/JMP reference, 16 bits, unsigned, in composite branch.  */
    case 'H':
      {
	*sym = 1;
	*sym_addr = (bfd_vma) ((insn & BIG_H_MASK) >> BIG_H_SHIFT);
	snprintf (buf, buf_len, "%#lx", (unsigned long) *sym_addr);
	strncpy (comment, comment_start, comment_len);
      }
      break;
 
      /* autoincrement operator.  */
    case 'a':
      {
	if (insn & A_MASK)
	  {
	    snprintf (buf, buf_len, "%s", "++");
	  }
      }
      break;
 
      /* syntactic sugar - comma.  */
    case ',':
      {
	snprintf (buf, buf_len, "%s", ",");
      }
      break;
 
    default:
      {
	snprintf (buf, buf_len, "??");
	fprintf (stderr, _("unknown constraint `%c'"), constraint);
	ok = 0;
      }
    }
 
  return ok;
}
 
static unsigned long long
open8_dis_opcode (bfd_vma addr, disassemble_info *info)
{
  bfd_byte buffer[sizeof (unsigned long long)];
  int status;
 
  int readsize = sizeof buffer;
 
  /* Make sure we don't try to read past the end of the section.  */
  if (addr + readsize >= info->section->size)
    {
      readsize = info->section->size - addr;
      memset (buffer, 0, sizeof buffer);
    }
 
  status = info->read_memory_func (addr, buffer, readsize, info);
 
  if (status == 0)
    return bfd_getl64 (buffer);
 
  info->memory_error_func (status, addr, info);
  return -1;
}
 
 
int
print_insn_open8 (bfd_vma addr, disassemble_info *info)
{
  unsigned long long insn;
  const struct open8_opcodes_s *opcode;
  void *stream = info->stream;
  fprintf_ftype prin = info->fprintf_func;
  int ok = 0;
  char op1[20], op2[20], op3[20], comment1[40], comment2[40], comment3[40];
  int comma1 = 0, comma2 = 0;
  int sym_op1 = 0, sym_op2 = 0, sym_op3 = 0;
  bfd_vma sym_addr1, sym_addr2, sym_addr3;
 
  if (info->symtab_size == 0)
    comment_start = " ";
 
  insn = open8_dis_opcode (addr, info);
 
  /* Scan the opcode descriptors, looking for an opcode match.  */
  for (opcode = open8_opcodes;
       opcode->name;
       opcode++)
    {
      /* If the memory anded with the mask matches required opcode bits,
	 then we have a match.  */
      if ((insn & opcode->opcode_mask) == opcode->opcode_bits)
	{
	  break;
	}
    }
 
  op1[0] = 0;
  op2[0] = 0;
  op3[0] = 0;
  comment1[0] = 0;
  comment2[0] = 0;
  comment3[0] = 0;
 
  /* Parse the binary value using the constraints.  */
  if (opcode->name)
    {
      char *op = opcode->constraints;
 
      ok = 1;
 
      if (*op)
	{
	  /* Grab the first operand.  */
	  ok = open8_operand (insn, 
			      *op++, 
			      op1, 
			      sizeof op1 - strlen (op1), 
			      comment1,
			      sizeof comment1 - strlen (comment1),
			      &sym_op1, 
			      &sym_addr1);
 
	  /* Note a comma.  */
	  if (ok && *op == ',')
	    {
	      comma1++;
	      op++;
	    }
 
	  /* Grab the second operand.  */
	  if (ok && *op)
	    {
	      ok = open8_operand (insn, 
				  *op++, 
				  op2,
				  sizeof op2 - strlen (op2), 
				  (*comment1 
				   ? comment2 
				   : comment1),
				  (*comment1 
				   ? sizeof comment2 - strlen (comment2)
				   : sizeof comment1 - strlen (comment1)),
				  &sym_op2, 
				  &sym_addr2);
	    }
 
	  /* Note a comma.  */
	  if (ok && *op == ',')
	    {
	      comma2++;
	      op++;
	    }
 
	  /* Grab the third operand.  */
	  if (ok && *op)
	    {
	      ok = open8_operand (insn, 
				  *op++, 
				  op3,
				  sizeof op3 - strlen (op3),
				  (*comment1 
				   ? (*comment2
				      ? comment3
				      : comment2)
				   : comment1),
				  (*comment1 
				   ? (*comment2 
				      ? sizeof comment3 - strlen (comment3)
				      : sizeof comment2 - strlen (comment2))
				   : sizeof comment1 - strlen (comment1)),
				  &sym_op3, &sym_addr3);
	    }
 
	}
    }
 
  if (!ok)
    {
      /* Unknown opcode, or invalid combination of operands.  */
      snprintf (op1, sizeof op1, "0x%04x", (unsigned int)insn);
      op2[0] = 0;
      op3[0] = 0;
      snprintf (comment1, sizeof comment1, "????");
      comment2[0] = 0;
      comment3[0] = 0;
    }
 
  (*prin) (stream, "%s", ok ? opcode->name : ".word");
 
  if (*op1)
    (*prin) (stream, "\t%s", op1);
 
  if (comma1)
    (*prin) (stream, "%s",",");
 
  if (*op2)
    (*prin) (stream, " %s", op2);
 
  if (comma2)
    (*prin) (stream, "%s",",");
 
  if (*op3)
    (*prin) (stream, " %s", op3);
 
  if (*comment1)
    (*prin) (stream, "\t; %s", comment1);
 
  if (sym_op1)
    info->print_address_func (sym_addr1, info);
 
  if (*comment2)
    (*prin) (stream, " %s", comment2);
 
  if (sym_op2)
    info->print_address_func (sym_addr2, info);
 
  if (*comment3)
    (*prin) (stream, " %s", comment3);
 
  if (sym_op3)
    info->print_address_func (sym_addr3, info);
 
  return opcode->insn_size;
}