/* Disassemble MSP430 instructions.
   Copyright (C) 2002-2023 Free Software Foundation, Inc.

   Contributed by Dmitry Diky <diwil@mail.ru>

   This file is part of the GNU opcodes library.

   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 <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <errno.h>

#include "disassemble.h"
#include "opintl.h"
#include "libiberty.h"

#define DASM_SECTION
#include "opcode/msp430.h"
#undef DASM_SECTION


#define PS(x)   (0xffff & (x))

static bool
msp430dis_read_two_bytes (bfd_vma            addr,
			  disassemble_info * info,
			  bfd_byte *         buffer,
			  char *             comm)
{
  int status;

  status = info->read_memory_func (addr, buffer, 2, info);
  if (status == 0)
    return true;

  /* PR 20150: A status of EIO means that there were no more bytes left
     to read in the current section.  This can happen when disassembling
     interrupt vectors for example.  Avoid cluttering the output with
     unhelpful error messages in this case.  */
  if (status == EIO)
    {
      if (comm)
	sprintf (comm, _("Warning: disassembly unreliable - not enough bytes available"));
    }
  else
    {
      info->memory_error_func (status, addr, info);
      if (comm)
	sprintf (comm, _("Error: read from memory failed"));
    }

  return false;
}

static bool
msp430dis_opcode_unsigned (bfd_vma            addr,
			   disassemble_info * info,
			   unsigned short *   return_val,
			   char *             comm)
{
  bfd_byte buffer[2];

  if (msp430dis_read_two_bytes (addr, info, buffer, comm))
    {
      * return_val = bfd_getl16 (buffer);
      return true;
    }
  else
    {
      * return_val = 0;
      return false;
    }
}

static bool
msp430dis_opcode_signed (bfd_vma            addr,
			 disassemble_info * info,
			 signed int *       return_val,
			 char *             comm)
{
  bfd_byte buffer[2];

  if (msp430dis_read_two_bytes (addr, info, buffer, comm))
    {
      int status;

      status = bfd_getl_signed_16 (buffer);
      if (status & 0x8000)
	status |= -1U << 16;
      * return_val = status;
      return true;
    }
  else
    {
      * return_val = 0;
      return false;
    }
}

static int
msp430_nooperands (struct msp430_opcode_s *opcode,
		   bfd_vma addr ATTRIBUTE_UNUSED,
		   unsigned short insn ATTRIBUTE_UNUSED,
		   char *comm,
		   int *cycles)
{
  /* Pop with constant.  */
  if (insn == 0x43b2)
    return 0;
  if (insn == opcode->bin_opcode)
    return 2;

  if (opcode->fmt == 0)
    {
      if ((insn & 0x0f00) != 0x0300 || (insn & 0x0f00) != 0x0200)
	return 0;

      strcpy (comm, "emulated...");
      *cycles = 1;
    }
  else
    {
      strcpy (comm, "return from interupt");
      *cycles = 5;
    }

  return 2;
}

static int
print_as2_reg_name (int regno, char * op1, char * comm1,
		    int c2, int c3, int cd)
{
  switch (regno)
    {
    case 2:
      sprintf (op1, "#4");
      sprintf (comm1, "r2 As==10");
      return c2;

    case 3:
      sprintf (op1, "#2");
      sprintf (comm1, "r3 As==10");
      return c3;

    default:
      /* Indexed register mode @Rn.  */
      sprintf (op1, "@r%d", regno);
      return cd;
    }
}

static int
print_as3_reg_name (int regno, char * op1, char * comm1,
		    int c2, int c3, int cd)
{
  switch (regno)
    {
    case 2:
      sprintf (op1, "#8");
      sprintf (comm1, "r2 As==11");
      return c2;

    case 3:
      sprintf (op1, "#-1");
      sprintf (comm1, "r3 As==11");
      return c3;

    default:
      /* Post incremented @Rn+.  */
      sprintf (op1, "@r%d+", regno);
      return cd;
    }
}

static int
msp430_singleoperand (disassemble_info *info,
		      struct msp430_opcode_s *opcode,
		      bfd_vma addr,
		      unsigned short insn,
		      char *op,
		      char *comm,
		      unsigned short extension_word,
		      int *cycles)
{
  int regs = 0, regd = 0;
  int ad = 0, as = 0;
  int where = 0;
  int cmd_len = 2;
  int dst = 0;
  int fmt;
  int extended_dst = extension_word & 0xf;

  regd = insn & 0x0f;
  regs = (insn & 0x0f00) >> 8;
  as = (insn & 0x0030) >> 4;
  ad = (insn & 0x0080) >> 7;

  if (opcode->fmt < 0)
    fmt = (- opcode->fmt) - 1;
  else
    fmt = opcode->fmt;

  switch (fmt)
    {
    case 0:			/* Emulated work with dst register.  */
      if (regs != 2 && regs != 3 && regs != 1)
	return 0;

      /* Check if not clr insn.  */
      if (opcode->bin_opcode == 0x4300 && (ad || as))
	return 0;

      /* Check if really inc, incd insns.  */
      if ((opcode->bin_opcode & 0xff00) == 0x5300 && as == 3)
	return 0;

      if (ad == 0)
	{
	  *cycles = 1;

	  /* Register.  */
	  if (regd == 0)
	    {
	      *cycles += 1;
	      sprintf (op, "r0");
	    }
	  else if (regd == 1)
	    sprintf (op, "r1");

	  else if (regd == 2)
	    sprintf (op, "r2");

	  else
	    sprintf (op, "r%d", regd);
	}
      else	/* ad == 1 msp430dis_opcode.  */
	{
	  if (regd == 0)
	    {
	      /* PC relative.  */
	      if (msp430dis_opcode_signed (addr + 2, info, &dst, comm))
		{
		  cmd_len += 2;
		  *cycles = 4;
		  sprintf (op, "0x%04x", dst);
		  sprintf (comm, "PC rel. abs addr 0x%04x",
			   PS ((short) (addr + 2) + dst));
		  if (extended_dst)
		    {
		      dst |= extended_dst << 16;
		      sprintf (op, "0x%05x", dst);
		      sprintf (comm, "PC rel. abs addr 0x%05lx",
			       (long)((addr + 2 + dst) & 0xfffff));
		    }
		}
	      else
		return -1;
	    }
	  else if (regd == 2)
	    {
	      /* Absolute.  */
	      if (msp430dis_opcode_signed (addr + 2, info, &dst, comm))
		{
		  cmd_len += 2;
		  *cycles = 4;
		  sprintf (op, "&0x%04x", PS (dst));
		  if (extended_dst)
		    {
		      dst |= extended_dst << 16;
		      sprintf (op, "&0x%05x", dst & 0xfffff);
		    }
		}
	      else
		return -1;
	    }
	  else
	    {
	      if (msp430dis_opcode_signed (addr + 2, info, &dst, comm))
		{
		  cmd_len += 2;
		  *cycles = 4;
		  if (extended_dst)
		    {
		      dst |= extended_dst << 16;
		      if (dst & 0x80000)
			dst |= -1U << 20;
		    }
		  sprintf (op, "%d(r%d)", dst, regd);
		}
	      else
		return -1;
	    }
	}
      break;

    case 2:	/* rrc, push, call, swpb, rra, sxt, push, call, reti etc...  */
      if (as == 0)
	{
	  if (regd == 3)
	    {
	      /* Constsnts.  */
	      sprintf (op, "#0");
	      sprintf (comm, "r3 As==00");
	    }
	  else
	    {
	      /* Register.  */
	      sprintf (op, "r%d", regd);
	    }
	  *cycles = 1;
	}
      else if (as == 2)
	{
	  * cycles = print_as2_reg_name (regd, op, comm, 1, 1, 3);
	}
      else if (as == 3)
	{
	  if (regd == 0)
	    {
	      *cycles = 3;
	      /* absolute. @pc+ */
	      if (msp430dis_opcode_signed (addr + 2, info, &dst, comm))
		{
		  cmd_len += 2;
		  sprintf (op, "#%d", dst);
		  if (dst > 9 || dst < 0)
		    sprintf (comm, "#0x%04x", PS (dst));
		  if (extended_dst)
		    {
		      dst |= extended_dst << 16;
		      if (dst & 0x80000)
			dst |= -1U << 20;
		      sprintf (op, "#%d", dst);
		      if (dst > 9 || dst < 0)
			sprintf (comm, "#0x%05x", dst);
		    }
		}
	      else
		return -1;
	    }
	  else
	    * cycles = print_as3_reg_name (regd, op, comm, 1, 1, 3);
	}
      else if (as == 1)
	{
	  *cycles = 4;
	  if (regd == 0)
	    {
	      /* PC relative.  */
	      if (msp430dis_opcode_signed (addr + 2, info, &dst, comm))
		{
		  cmd_len += 2;
		  sprintf (op, "0x%04x", PS (dst));
		  sprintf (comm, "PC rel. 0x%04x",
			   PS ((short) addr + 2 + dst));
		  if (extended_dst)
		    {
		      dst |= extended_dst << 16;
		      sprintf (op, "0x%05x", dst & 0xffff);
		      sprintf (comm, "PC rel. 0x%05lx",
			       (long)((addr + 2 + dst) & 0xfffff));
		    }
		}
	      else
		return -1;
	    }
	  else if (regd == 2)
	    {
	      /* Absolute.  */
	      if (msp430dis_opcode_signed (addr + 2, info, &dst, comm))
		{
		  cmd_len += 2;
		  sprintf (op, "&0x%04x", PS (dst));
		  if (extended_dst)
		    {
		      dst |= extended_dst << 16;
		      sprintf (op, "&0x%05x", dst & 0xfffff);
		    }
		}
	      else
		return -1;
	    }
	  else if (regd == 3)
	    {
	      *cycles = 1;
	      sprintf (op, "#1");
	      sprintf (comm, "r3 As==01");
	    }
	  else
	    {
	      /* Indexed.  */
	      if (msp430dis_opcode_signed (addr + 2, info, &dst, comm))
		{
		  cmd_len += 2;
		  if (extended_dst)
		    {
		      dst |= extended_dst << 16;
		      if (dst & 0x80000)
			dst |= -1U << 20;
		    }
		  sprintf (op, "%d(r%d)", dst, regd);
		  if (dst > 9 || dst < 0)
		    sprintf (comm, "%05x", dst);
		}
	      else
		return -1;
	    }
	}
      break;

    case 3:			/* Jumps.  */
      where = insn & 0x03ff;
      if (where & 0x200)
	where |= ~0x03ff;
      if (where > 512 || where < -511)
	return 0;

      where *= 2;
      sprintf (op, "$%+-8d", where + 2);
      sprintf (comm, "abs 0x%lx", (long) (addr + 2 + where));
      *cycles = 2;
      return 2;
      break;

    default:
      cmd_len = 0;
    }

  return cmd_len;
}

static int
msp430_doubleoperand (disassemble_info *info,
		      struct msp430_opcode_s *opcode,
		      bfd_vma addr,
		      unsigned short insn,
		      char *op1,
		      char *op2,
		      char *comm1,
		      char *comm2,
		      unsigned short extension_word,
		      int *cycles)
{
  int regs = 0, regd = 0;
  int ad = 0, as = 0;
  int cmd_len = 2;
  int dst = 0;
  int fmt;
  int extended_dst = extension_word & 0xf;
  int extended_src = (extension_word >> 7) & 0xf;

  regd = insn & 0x0f;
  regs = (insn & 0x0f00) >> 8;
  as = (insn & 0x0030) >> 4;
  ad = (insn & 0x0080) >> 7;

  if (opcode->fmt < 0)
    fmt = (- opcode->fmt) - 1;
  else
    fmt = opcode->fmt;

  if (fmt == 0)
    {
      /* Special case: rla and rlc are the only 2 emulated instructions that
	 fall into two operand instructions.  */
      /* With dst, there are only:
	 Rm       	Register,
         x(Rm)     	Indexed,
         0xXXXX    	Relative,
         &0xXXXX    	Absolute
         emulated_ins   dst
         basic_ins      dst, dst.  */

      if (regd != regs || as != ad)
	return 0;		/* May be 'data' section.  */

      if (ad == 0)
	{
	  /* Register mode.  */
	  if (regd == 3)
	    {
	      strcpy (comm1, _("Warning: illegal as emulation instr"));
	      return -1;
	    }

	  sprintf (op1, "r%d", regd);
	  *cycles = 1;
	}
      else			/* ad == 1 */
	{
	  if (regd == 0)
	    {
	      /* PC relative, Symbolic.  */
	      if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1))
		{
		  cmd_len += 4;
		  *cycles = 6;
		  sprintf (op1, "0x%04x", PS (dst));
		  sprintf (comm1, "PC rel. 0x%04x",
			   PS ((short) addr + 2 + dst));
		  if (extension_word)
		    {
		      dst |= extended_dst << 16;
		      if (dst & 0x80000)
			dst |= -1U << 20;
		      sprintf (op1, "0x%05x", dst & 0xfffff);
		      sprintf (comm1, "PC rel. 0x%05lx",
			       (long)((addr + 2 + dst) & 0xfffff));
		    }
		}
	      else
		return -1;
	    }
	  else if (regd == 2)
	    {
	      /* Absolute.  */
	      if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1))
		{
		  int src;

		  /* If the 'src' field is not the same as the dst
		     then this is not an rla instruction.  */
		  if (msp430dis_opcode_signed (addr + 4, info, &src, comm2))
		    {
		      if (src != dst)
			return 0;
		    }
		  else
		    return -1;
		  cmd_len += 4;
		  *cycles = 6;
		  sprintf (op1, "&0x%04x", PS (dst));
		  if (extension_word)
		    {
		      dst |= extended_dst << 16;
		      sprintf (op1, "&0x%05x", dst & 0xfffff);
		    }
		}
	      else
		return -1;
	    }
	  else
	    {
	      /* Indexed.  */
	      if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1))
		{
		  if (extension_word)
		    {
		      dst |= extended_dst << 16;
		      if (dst & 0x80000)
			dst |= -1U << 20;
		    }
		  cmd_len += 4;
		  *cycles = 6;
		  sprintf (op1, "%d(r%d)", dst, regd);
		  if (dst > 9 || dst < -9)
		    sprintf (comm1, "#0x%05x", dst);
		}
	      else
		return -1;
	    }
	}

      *op2 = 0;
      *comm2 = 0;

      return cmd_len;
    }

  /* Two operands exactly.  */
  if (ad == 0 && regd == 3)
    {
      /* R2/R3 are illegal as dest: may be data section.  */
      strcpy (comm1, _("Warning: illegal as 2-op instr"));
      return -1;
    }

  /* Source.  */
  if (as == 0)
    {
      *cycles = 1;
      if (regs == 3)
	{
	  /* Constants.  */
	  sprintf (op1, "#0");
	  sprintf (comm1, "r3 As==00");
	}
      else
	{
	  /* Register.  */
	  sprintf (op1, "r%d", regs);
	}
    }
  else if (as == 2)
    {
      * cycles = print_as2_reg_name (regs, op1, comm1, 1, 1, regs == 0 ? 3 : 2);
    }
  else if (as == 3)
    {
      if (regs == 0)
	{
	  *cycles = 3;
	  /* Absolute. @pc+.  */
	  if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1))
	    {
	      cmd_len += 2;
	      sprintf (op1, "#%d", dst);
	      if (dst > 9 || dst < 0)
		sprintf (comm1, "#0x%04x", PS (dst));
	      if (extension_word)
		{
		  dst &= 0xffff;
		  dst |= extended_src << 16;
		  if (dst & 0x80000)
		    dst |= -1U << 20;
		  sprintf (op1, "#%d", dst);
		  if (dst > 9 || dst < 0)
		    sprintf (comm1, "0x%05x", dst & 0xfffff);
		}
	    }
	  else
	    return -1;
	}
      else
	* cycles = print_as3_reg_name (regs, op1, comm1, 1, 1, 2);
    }
  else if (as == 1)
    {
      if (regs == 0)
	{
	  *cycles = 4;
	  /* PC relative.  */
	  if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1))
	    {
	      cmd_len += 2;
	      sprintf (op1, "0x%04x", PS (dst));
	      sprintf (comm1, "PC rel. 0x%04x",
		       PS ((short) addr + 2 + dst));
	      if (extension_word)
		{
		  dst &= 0xffff;
		  dst |= extended_src << 16;
		  if (dst & 0x80000)
		    dst |= -1U << 20;
		  sprintf (op1, "0x%05x", dst & 0xfffff);
		  sprintf (comm1, "PC rel. 0x%05lx",
			   (long) ((addr + 2 + dst) & 0xfffff));
		}
	    }
	  else
	    return -1;
	}
      else if (regs == 2)
	{
	  *cycles = 2;
	  /* Absolute.  */
	  if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1))
	    {
	      cmd_len += 2;
	      sprintf (op1, "&0x%04x", PS (dst));
	      sprintf (comm1, "0x%04x", PS (dst));
	      if (extension_word)
		{
		  dst &= 0xffff;
		  dst |= extended_src << 16;
		  sprintf (op1, "&0x%05x", dst & 0xfffff);
		  * comm1 = 0;
		}
	    }
	  else
	    return -1;
	}
      else if (regs == 3)
	{
	  *cycles = 1;
	  sprintf (op1, "#1");
	  sprintf (comm1, "r3 As==01");
	}
      else
	{
	  *cycles = 3;
	  /* Indexed.  */
	  if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1))
	    {
	      cmd_len += 2;
	      if (extension_word)
		{
		  dst &= 0xffff;
		  dst |= extended_src << 16;
		  if (dst & 0x80000)
		    dst |= -1U << 20;
		}
	      sprintf (op1, "%d(r%d)", dst, regs);
	      if (dst > 9 || dst < -9)
		sprintf (comm1, "0x%05x", dst);
	    }
	  else
	    return -1;
	}
    }

  /* Destination. Special care needed on addr + XXXX.  */

  if (ad == 0)
    {
      /* Register.  */
      if (regd == 0)
	{
	  *cycles += 1;
	  sprintf (op2, "r0");
	}
      else if (regd == 1)
	sprintf (op2, "r1");

      else if (regd == 2)
	sprintf (op2, "r2");

      else
	sprintf (op2, "r%d", regd);
    }
  else	/* ad == 1.  */
    {
      * cycles += 3;

      if (regd == 0)
	{
	  /* PC relative.  */
	  *cycles += 1;
	  if (msp430dis_opcode_signed (addr + cmd_len, info, &dst, comm2))
	    {
	      sprintf (op2, "0x%04x", PS (dst));
	      sprintf (comm2, "PC rel. 0x%04x",
		       PS ((short) addr + cmd_len + dst));
	      if (extension_word)
		{
		  dst |= extended_dst << 16;
		  if (dst & 0x80000)
		    dst |= -1U << 20;
		  sprintf (op2, "0x%05x", dst & 0xfffff);
		  sprintf (comm2, "PC rel. 0x%05lx",
			   (long)((addr + cmd_len + dst) & 0xfffff));
		}
	    }
	  else
	    return -1;
	  cmd_len += 2;
	}
      else if (regd == 2)
	{
	  /* Absolute.  */
	  if (msp430dis_opcode_signed (addr + cmd_len, info, &dst, comm2))
	    {
	      cmd_len += 2;
	      sprintf (op2, "&0x%04x", PS (dst));
	      if (extension_word)
		{
		  dst |= extended_dst << 16;
		  sprintf (op2, "&0x%05x", dst & 0xfffff);
		}
	    }
	  else
	    return -1;
	}
      else
	{
	  if (msp430dis_opcode_signed (addr + cmd_len, info, &dst, comm2))
	    {
	      cmd_len += 2;
	      if (dst > 9 || dst < 0)
		sprintf (comm2, "0x%04x", PS (dst));
	      if (extension_word)
		{
		  dst |= extended_dst << 16;
		  if (dst & 0x80000)
		    dst |= -1U << 20;
		  if (dst > 9 || dst < 0)
		    sprintf (comm2, "0x%05x", dst & 0xfffff);
		}
	      sprintf (op2, "%d(r%d)", dst, regd);
	    }
	  else
	    return -1;
	}
    }

  return cmd_len;
}

static int
msp430_branchinstr (disassemble_info *info,
		    struct msp430_opcode_s *opcode ATTRIBUTE_UNUSED,
		    bfd_vma addr ATTRIBUTE_UNUSED,
		    unsigned short insn,
		    char *op1,
		    char *comm1,
		    int *cycles)
{
  int regs = 0, regd = 0;
  int as = 0;
  int cmd_len = 2;
  int dst = 0;
  unsigned short udst = 0;

  regd = insn & 0x0f;
  regs = (insn & 0x0f00) >> 8;
  as = (insn & 0x0030) >> 4;

  if (regd != 0)	/* Destination register is not a PC.  */
    return 0;

  /* dst is a source register.  */
  if (as == 0)
    {
      /* Constants.  */
      if (regs == 3)
	{
	  *cycles = 1;
	  sprintf (op1, "#0");
	  sprintf (comm1, "r3 As==00");
	}
      else
	{
	  /* Register.  */
	  *cycles = 1;
	  sprintf (op1, "r%d", regs);
	}
    }
  else if (as == 2)
    {
      * cycles = print_as2_reg_name (regs, op1, comm1, 2, 1, 2);
    }
  else if (as == 3)
    {
      if (regs == 0)
	{
	  /* Absolute. @pc+  */
	  *cycles = 3;
	  if (msp430dis_opcode_unsigned (addr + 2, info, &udst, comm1))
	    {
	      cmd_len += 2;
	      sprintf (op1, "#0x%04x", PS (udst));
	    }
	  else
	    return -1;
	}
      else
	* cycles = print_as3_reg_name (regs, op1, comm1, 1, 1, 2);
    }
  else if (as == 1)
    {
      * cycles = 3;

      if (regs == 0)
	{
	  /* PC relative.  */
	  if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1))
	    {
	      cmd_len += 2;
	      (*cycles)++;
	      sprintf (op1, "0x%04x", PS (dst));
	      sprintf (comm1, "PC rel. 0x%04x",
		       PS ((short) addr + 2 + dst));
	    }
	  else
	    return -1;
	}
      else if (regs == 2)
	{
	  /* Absolute.  */
	  if (msp430dis_opcode_unsigned (addr + 2, info, &udst, comm1))
	    {
	      cmd_len += 2;
	      sprintf (op1, "&0x%04x", PS (udst));
	    }
	  else
	    return -1;
	}
      else if (regs == 3)
	{
	  (*cycles)--;
	  sprintf (op1, "#1");
	  sprintf (comm1, "r3 As==01");
	}
      else
	{
	  /* Indexed.  */
	  if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1))
	    {
	      cmd_len += 2;
	      sprintf (op1, "%d(r%d)", dst, regs);
	    }
	  else
	    return -1;
	}
    }

  return cmd_len;
}

static int
msp430x_calla_instr (disassemble_info * info,
		     bfd_vma            addr,
		     unsigned short     insn,
		     char *             op1,
		     char *             comm1,
		     int *              cycles)
{
  unsigned int   ureg = insn & 0xf;
  int            reg = insn & 0xf;
  int            am = (insn & 0xf0) >> 4;
  int            cmd_len = 2;
  unsigned short udst = 0;
  int            dst = 0;

  switch (am)
    {
    case 4: /* CALLA Rdst */
      *cycles = 1;
      sprintf (op1, "r%d", reg);
      break;

    case 5: /* CALLA x(Rdst) */
      *cycles = 3;
      if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1))
	{
	  cmd_len += 2;
	  sprintf (op1, "%d(r%d)", dst, reg);
	  if (reg == 0)
	    sprintf (comm1, "PC rel. 0x%05lx", (long) (addr + 2 + dst));
	  else
	    sprintf (comm1, "0x%05x", dst);
	}
      else
	return -1;
      break;

    case 6: /* CALLA @Rdst */
      *cycles = 2;
      sprintf (op1, "@r%d", reg);
      break;

    case 7: /* CALLA @Rdst+ */
      *cycles = 2;
      sprintf (op1, "@r%d+", reg);
      break;

    case 8: /* CALLA &abs20 */
      if (msp430dis_opcode_unsigned (addr + 2, info, &udst, comm1))
	{
	  cmd_len += 2;
	  *cycles = 4;
	  sprintf (op1, "&%d", (ureg << 16) + udst);
	  sprintf (comm1, "0x%05x", (ureg << 16) + udst);
	}
      else
	return -1;
      break;

    case 9: /* CALLA pcrel-sym */
      if (msp430dis_opcode_signed (addr + 2, info, &dst, comm1))
	{
	  cmd_len += 2;
	  *cycles = 4;
	  sprintf (op1, "%d(PC)", (reg << 16) + dst);
	  sprintf (comm1, "PC rel. 0x%05lx",
		   (long) (addr + 2 + dst + (reg << 16)));
	}
      else
	return -1;
      break;

    case 11: /* CALLA #imm20 */
      if (msp430dis_opcode_unsigned (addr + 2, info, &udst, comm1))
	{
	  cmd_len += 2;
	  *cycles = 4;
	  sprintf (op1, "#%d", (ureg << 16) + udst);
	  sprintf (comm1, "0x%05x", (ureg << 16) + udst);
	}
      else
	return -1;
      break;

    default:
      strcpy (comm1, _("Warning: unrecognised CALLA addressing mode"));
      return -1;
    }

  return cmd_len;
}

int
print_insn_msp430 (bfd_vma addr, disassemble_info *info)
{
  void *stream = info->stream;
  fprintf_ftype prin = info->fprintf_func;
  struct msp430_opcode_s *opcode;
  char op1[32], op2[32], comm1[64], comm2[64];
  int cmd_len = 0;
  unsigned short insn;
  int cycles = 0;
  char *bc = "";
  unsigned short extension_word = 0;
  unsigned short bits;

  if (! msp430dis_opcode_unsigned (addr, info, &insn, NULL))
    return -1;

  if (((int) addr & 0xffff) > 0xffdf)
    {
      (*prin) (stream, "interrupt service routine at 0x%04x", 0xffff & insn);
      return 2;
    }

  *comm1 = 0;
  *comm2 = 0;

  /* Check for an extension word.  */
  if ((insn & 0xf800) == 0x1800)
    {
      extension_word = insn;
      addr += 2;
      if (! msp430dis_opcode_unsigned (addr, info, &insn, NULL))
	return -1;
   }

  for (opcode = msp430_opcodes; opcode->name; opcode++)
    {
      if ((insn & opcode->bin_mask) == opcode->bin_opcode
	  && opcode->bin_opcode != 0x9300)
	{
	  *op1 = 0;
	  *op2 = 0;
	  *comm1 = 0;
	  *comm2 = 0;

	  /* r0 as destination. Ad should be zero.  */
	  if (opcode->insn_opnumb == 3
	      && (insn & 0x000f) == 0
	      && (insn & 0x0080) == 0)
	    {
	      int ret =
		msp430_branchinstr (info, opcode, addr, insn, op1, comm1,
				    &cycles);

	      if (ret == -1)
		return -1;
	      cmd_len += ret;
	      if (cmd_len)
		break;
	    }

	  switch (opcode->insn_opnumb)
	    {
	      int n;
	      int reg;
	      int ret;

	    case 4:
	      ret = msp430x_calla_instr (info, addr, insn,
					 op1, comm1, & cycles);
	      if (ret == -1)
		return -1;
	      cmd_len += ret;
	      break;

	    case 5: /* PUSHM/POPM */
	      n = (insn & 0xf0) >> 4;
	      reg = (insn & 0xf);

	      sprintf (op1, "#%d", n + 1);
	      if (opcode->bin_opcode == 0x1400)
		/* PUSHM */
		sprintf (op2, "r%d", reg);
	      else
		/* POPM */
		sprintf (op2, "r%d", reg + n);
	      if (insn & 0x100)
		sprintf (comm1, "16-bit words");
	      else
		{
		  sprintf (comm1, "20-bit words");
		  bc =".a";
		}

	      cycles = 2; /*FIXME*/
	      cmd_len = 2;
	      break;

	    case 6: /* RRAM, RRCM, RRUM, RLAM.  */
	      n = ((insn >> 10) & 0x3) + 1;
	      reg = (insn & 0xf);
	      if ((insn & 0x10) == 0)
		bc =".a";
	      sprintf (op1, "#%d", n);
	      sprintf (op2, "r%d", reg);
	      cycles = 2; /*FIXME*/
	      cmd_len = 2;
	      break;

	    case 8: /* ADDA, CMPA, SUBA.  */
	      reg = (insn & 0xf);
	      n = (insn >> 8) & 0xf;
	      if (insn & 0x40)
		{
		  sprintf (op1, "r%d", n);
		  cmd_len = 2;
		}
	      else
		{
		  n <<= 16;
		  if (msp430dis_opcode_unsigned (addr + 2, info, &bits, comm1))
		    {
		      n |= bits;
		      sprintf (op1, "#%d", n);
		      if (n > 9 || n < 0)
			sprintf (comm1, "0x%05x", n);
		    }
		  else
		    return -1;
		  cmd_len = 4;
		}
	      sprintf (op2, "r%d", reg);
	      cycles = 2; /*FIXME*/
	      break;

	    case 9: /* MOVA */
	      reg = (insn & 0xf);
	      n = (insn >> 8) & 0xf;
	      switch ((insn >> 4) & 0xf)
		{
		case 0: /* MOVA @Rsrc, Rdst */
		  cmd_len = 2;
		  sprintf (op1, "@r%d", n);
		  if (strcmp (opcode->name, "bra") != 0)
		    sprintf (op2, "r%d", reg);
		  break;

		case 1: /* MOVA @Rsrc+, Rdst */
		  cmd_len = 2;
		  if (strcmp (opcode->name, "reta") != 0)
		    {
		      sprintf (op1, "@r%d+", n);
		      if (strcmp (opcode->name, "bra") != 0)
			sprintf (op2, "r%d", reg);
		    }
		  break;

		case 2: /* MOVA &abs20, Rdst */
		  cmd_len = 4;
		  n <<= 16;
		  if (msp430dis_opcode_unsigned (addr + 2, info, &bits, comm1))
		    {
		      n |= bits;
		      sprintf (op1, "&%d", n);
		      if (n > 9 || n < 0)
			sprintf (comm1, "0x%05x", n);
		      if (strcmp (opcode->name, "bra") != 0)
			sprintf (op2, "r%d", reg);
		    }
		  else
		    return -1;
		  break;

		case 3: /* MOVA x(Rsrc), Rdst */
		  cmd_len = 4;
		  if (strcmp (opcode->name, "bra") != 0)
		    sprintf (op2, "r%d", reg);
		  reg = n;
		  if (msp430dis_opcode_signed (addr + 2, info, &n, comm1))
		    {
		      sprintf (op1, "%d(r%d)", n, reg);
		      if (n > 9 || n < 0)
			{
			  if (reg == 0)
			    sprintf (comm1, "PC rel. 0x%05lx",
				     (long) (addr + 2 + n));
			  else
			    sprintf (comm1, "0x%05x", n);
			}
		    }
		  else
		    return -1;
		  break;

		case 6: /* MOVA Rsrc, &abs20 */
		  cmd_len = 4;
		  reg <<= 16;
		  if (msp430dis_opcode_unsigned (addr + 2, info, &bits, comm2))
		    {
		      reg |= bits;
		      sprintf (op1, "r%d", n);
		      sprintf (op2, "&%d", reg);
		      if (reg > 9 || reg < 0)
			sprintf (comm2, "0x%05x", reg);
		    }
		  else
		    return -1;
		  break;

		case 7: /* MOVA Rsrc, x(Rdst) */
		  cmd_len = 4;
		  sprintf (op1, "r%d", n);
		  if (msp430dis_opcode_signed (addr + 2, info, &n, comm2))
		    {
		      sprintf (op2, "%d(r%d)", n, reg);
		      if (n > 9 || n < 0)
			{
			  if (reg == 0)
			    sprintf (comm2, "PC rel. 0x%05lx",
				     (long) (addr + 2 + n));
			  else
			    sprintf (comm2, "0x%05x", n);
			}
		    }
		  else
		    return -1;
		  break;

		case 8: /* MOVA #imm20, Rdst */
		  cmd_len = 4;
		  n <<= 16;
		  if (msp430dis_opcode_unsigned (addr + 2, info, &bits, comm1))
		    {
		      n |= bits;
		      if (n & 0x80000)
			n |= -1U << 20;
		      sprintf (op1, "#%d", n);
		      if (n > 9 || n < 0)
			sprintf (comm1, "0x%05x", n);
		      if (strcmp (opcode->name, "bra") != 0)
			sprintf (op2, "r%d", reg);
		    }
		  else
		    return -1;
		  break;

		case 12: /* MOVA Rsrc, Rdst */
		  cmd_len = 2;
		  sprintf (op1, "r%d", n);
		  if (strcmp (opcode->name, "bra") != 0)
		    sprintf (op2, "r%d", reg);
		  break;

		default:
		  break;
		}
	      cycles = 2; /* FIXME */
	      break;
	    }

	  if (cmd_len)
	    break;

	  switch (opcode->insn_opnumb)
	    {
	      int ret;

	    case 0:
	      cmd_len += msp430_nooperands (opcode, addr, insn, comm1, &cycles);
	      break;
	    case 2:
	      ret =
		msp430_doubleoperand (info, opcode, addr, insn, op1, op2,
				      comm1, comm2,
				      extension_word,
				      &cycles);

	      if (ret == -1)
		return -1;
	      cmd_len += ret;
	      if (insn & BYTE_OPERATION)
		{
		  if (extension_word != 0 && ((extension_word & BYTE_OPERATION) == 0))
		    bc = ".a";
		  else
		    bc = ".b";
		}
	      else if (extension_word)
		{
		  if (extension_word & BYTE_OPERATION)
		    bc = ".w";
		  else
		    {
		      bc = ".?";
		      sprintf (comm2, _("Warning: reserved use of A/L and B/W bits detected"));
		    }
		}

	      break;
	    case 1:
	      ret =
		msp430_singleoperand (info, opcode, addr, insn, op1, comm1,
				      extension_word,
				      &cycles);

	      if (ret == -1)
		return -1;
	      cmd_len += ret;
	      if (extension_word
		  && (strcmp (opcode->name, "swpb") == 0
		      || strcmp (opcode->name, "sxt") == 0))
		{
		  if (insn & BYTE_OPERATION)
		    {
		      bc = ".?";
		      sprintf (comm2, _("Warning: reserved use of A/L and B/W bits detected"));
		    }
		  else if (extension_word & BYTE_OPERATION)
		    bc = ".w";
		  else
		    bc = ".a";
		}
	      else if (insn & BYTE_OPERATION && opcode->fmt != 3)
		{
		  if (extension_word != 0 && ((extension_word & BYTE_OPERATION) == 0))
		    bc = ".a";
		  else
		    bc = ".b";
		}
	      else if (extension_word)
		{
		  if (extension_word & (1 << 6))
		    bc = ".w";
		  else
		    {
		      bc = ".?";
		      sprintf (comm2, _("Warning: reserved use of A/L and B/W bits detected"));
		    }
		}
	      break;
	    default:
	      break;
	    }
	}

      if (cmd_len)
	break;
    }

  if (cmd_len < 1)
    {
      /* Unknown opcode, or invalid combination of operands.  */
      if (extension_word)
	{
	  prin (stream, ".word	0x%04x, 0x%04x;	????", extension_word, PS (insn));
	  if (*comm1)
	    prin (stream, "\t %s", comm1);
	  return 4;
	}
      (*prin) (stream, ".word	0x%04x;	????", PS (insn));
      return 2;
    }

  /* Display the repeat count (if set) for extended register mode.  */
  if (cmd_len == 2 && ((extension_word & 0xf) != 0))
    {
      if (extension_word & (1 << 7))
	prin (stream, "rpt r%d { ", extension_word & 0xf);
      else
	prin (stream, "rpt #%d { ", (extension_word & 0xf) + 1);
    }

  /* Special case:  RRC with an extension word and the ZC bit set is actually RRU.  */
  if (extension_word
      && (extension_word & IGNORE_CARRY_BIT)
      && strcmp (opcode->name, "rrc") == 0)
    (*prin) (stream, "rrux%s", bc);
  else if (extension_word && opcode->name[strlen (opcode->name) - 1] != 'x')
    (*prin) (stream, "%sx%s", opcode->name, bc);
  else
    (*prin) (stream, "%s%s", opcode->name, bc);

  if (*op1)
    (*prin) (stream, "\t%s", op1);
  if (*op2)
    (*prin) (stream, ",");

  if (strlen (op1) < 7)
    (*prin) (stream, "\t");
  if (!strlen (op1))
    (*prin) (stream, "\t");

  if (*op2)
    (*prin) (stream, "%s", op2);
  if (strlen (op2) < 8)
    (*prin) (stream, "\t");

  if (*comm1 || *comm2)
    (*prin) (stream, ";");
  else if (cycles)
    {
      if (*op2)
	(*prin) (stream, ";");
      else
	{
	  if (strlen (op1) < 7)
	    (*prin) (stream, ";");
	  else
	    (*prin) (stream, "\t;");
	}
    }
  if (*comm1)
    (*prin) (stream, "%s", comm1);
  if (*comm1 && *comm2)
    (*prin) (stream, ",");
  if (*comm2)
    (*prin) (stream, " %s", comm2);

  if (extension_word)
    cmd_len += 2;

  return cmd_len;
}