[binutils.git] / opcodes / tic80-dis.c

/* Print TI TMS320C80 (MVP) instructions
   Copyright 1996 Free Software Foundation, Inc.

This file 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 2 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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include <stdio.h>

#include "ansidecl.h"
#include "opcode/tic80.h"
#include "dis-asm.h"

#define M_SI(insn,op) ((((op) -> flags & TIC80_OPERAND_M_SI) != 0) && ((insn) & (1 << 17)))
#define M_LI(insn,op) ((((op) -> flags & TIC80_OPERAND_M_LI) != 0) && ((insn) & (1 << 15)))

int 
print_insn_tic80 (memaddr, info)
     bfd_vma memaddr;
     struct disassemble_info *info;
{
  bfd_byte buffer[4];
  int status;
  unsigned long insn[2];
  const struct tic80_opcode *opcode;
  const struct tic80_opcode *opcode_end;
  const unsigned char *opindex;
  const struct tic80_operand *operand;
  int close_paren;
  int length = 4;

  status = (*info->read_memory_func) (memaddr, buffer, 4, info);
  if (status != 0)
    {
      (*info->memory_error_func) (status, memaddr, info);
      return -1;
    }

  if (info -> endian == BFD_ENDIAN_LITTLE)
    {
      insn[0] = bfd_getl32 (buffer);
    }
  else if (info -> endian == BFD_ENDIAN_BIG)
    {
      insn[0] = bfd_getb32 (buffer);
    }
  else
    {
      /* FIXME: Should probably just default to one or the other */
      abort ();
    }

  /* Find the first opcode match in the opcodes table.  FIXME: there should
     be faster ways to find one (hash table or binary search), but don't
     worry too much about it until other TIc80 support is finished. */

  opcode_end = tic80_opcodes + tic80_num_opcodes;
  for (opcode = tic80_opcodes; opcode < opcode_end; opcode++)
    {
      if ((insn[0] & opcode -> mask) == opcode -> opcode)
	{
	  break;
	}
    }

  if (opcode == opcode_end)
    {
      /* No match found, just print the bits as a .word directive */
      (*info -> fprintf_func) (info -> stream, ".word %#08lx", insn[0]);
    }
  else
    {
      /* Match found, decode the instruction.  */
      (*info -> fprintf_func) (info -> stream, "%s", opcode -> name);

      /* Now extract and print the operands. */
      if (opcode -> operands[0] != 0)
	{
	  (*info -> fprintf_func) (info -> stream, "\t");
	}
      for (opindex = opcode -> operands; *opindex != 0; opindex++)
	{
	  long value;

	  operand = tic80_operands + *opindex;

	  /* Extract the value from the instruction.  */
	  if (operand -> extract)
	    {
	      value = (*operand -> extract) (insn[0], (int *) NULL);
	    }
	  else if (operand -> bits == 32)
	    {
	      status = (*info->read_memory_func) (memaddr + 4, buffer, 4, info);
	      if (status != 0)
		{
		  (*info->memory_error_func) (status, memaddr, info);
		  return -1;
		}

	      if (info -> endian == BFD_ENDIAN_LITTLE)
		{
		  insn[1] = bfd_getl32 (buffer);
		}
	      else if (info -> endian == BFD_ENDIAN_BIG)
		{
		  insn[1] = bfd_getb32 (buffer);
		}
	      value = (long) insn[1];
	      length += 4;
	    }
	  else
	    {
	      value = (insn[0] >> operand -> shift) & ((1 << operand -> bits) - 1);
	      if ((operand -> flags & TIC80_OPERAND_SIGNED) != 0
		  && (value & (1 << (operand -> bits - 1))) != 0)
		value -= 1 << operand -> bits;
	    }

	  /* If this operand is enclosed in parenthesis, then print
	     the open paren, otherwise just print the regular comma
	     separator, except for the first operand. */

	  if ((operand -> flags & TIC80_OPERAND_PARENS) == 0)
	    {
	      close_paren = 0;
	      if (opindex != opcode -> operands)
		{
		  (*info -> fprintf_func) (info -> stream, ",");
		}
	    }
	  else
	    {
	      close_paren = 1;
	      (*info -> fprintf_func) (info -> stream, "(");
	    }

	  /* Print the operand as directed by the flags.  */

	  if ((operand -> flags & TIC80_OPERAND_GPR) != 0)
	    {
	      (*info -> fprintf_func) (info -> stream, "r%ld", value);
	      if (M_SI (insn[0], operand) || M_LI (insn[0], operand))
		{
		  (*info -> fprintf_func) (info -> stream, ":m");
		}
	    }
	  else if ((operand -> flags & TIC80_OPERAND_FPA) != 0)
	    {
	      (*info -> fprintf_func) (info -> stream, "a%ld", value);
	    }
	  else if ((operand -> flags & TIC80_OPERAND_RELATIVE) != 0)
	    {
	      (*info -> print_address_func) (memaddr + 4 * value, info);
	    }
	  else if ((operand -> flags & TIC80_OPERAND_BITNUM) != 0)
	    {
	      char *syms[30] = {
		"eq.b", "ne.b", "gt.b", "le.b", "lt.b", "ge.b",
		"hi.b", "ls.b", "lo.b", "hs.b", "eq.h", "ne.h",
		"gt.h", "le.h", "lt.h", "ge.h", "hi.h", "ls.h",
		"lo.h", "hs.h", "eq.w", "ne.w", "gt.w", "le.w",
		"lt.w", "ge.w", "hi.w", "ls.w", "lo.w", "hs.w"
	      };
	      int bitnum = ~value & 0x1F;

	      if (bitnum < 30)
		{
		  /* Found a value within range */
		  (*info -> fprintf_func) (info -> stream, "%s", syms[bitnum]);
		}
	      else
		{
		  /* Not in range, just print as bit number */
		  (*info -> fprintf_func) (info -> stream, "%ld", bitnum);
		}
	    }
	  else if ((operand -> flags & TIC80_OPERAND_CC) != 0)
	    {
	      char *syms[24] = {
		"nev.b", "gt0.b", "eq0.b", "ge0.b", "lt0.b", "ne0.b", "le0.b", "alw.b",
		"nev.h", "gt0.h", "eq0.h", "ge0.h", "lt0.h", "ne0.h", "le0.h", "alw.h",
		"nev.w", "gt0.w", "eq0.w", "ge0.w", "lt0.w", "ne0.w", "le0.w", "alw.w"
	      };
	      if (value < 24)
		{
		  /* Found a value within range */
		  (*info -> fprintf_func) (info -> stream, "%s", syms[value]);
		}
	      else
		{
		  /* Not in range, just print as decimal digit. */
		  (*info -> fprintf_func) (info -> stream, "%ld", value);
		}
	    }
	  else if ((operand -> flags & TIC80_OPERAND_CR) != 0)
	    {
	      char *tmp;
	      switch (value)
		{
		case 0:		tmp = "EPC";		break;
		case 1:		tmp = "EIP";		break;
		case 2:		tmp = "CONFIG";		break;
		case 4:		tmp = "INTPEN";		break;
		case 6:		tmp = "IE";		break;
		case 8:		tmp = "FPST";		break;
		case 0xA:	tmp = "PPERROR";	break;
		case 0xD:	tmp = "PKTREQ";		break;
		case 0xE:	tmp = "TCOUNT";		break;
		case 0xF:	tmp = "TSCALE";		break;
		case 0x10:	tmp = "FLTOP";		break;
		case 0x11:	tmp = "FLTADR";		break;
		case 0x12:	tmp = "FLTTAG";		break;
		case 0x13:	tmp = "FLTDTL";		break;
		case 0x14:	tmp = "FLTDTH";		break;
		case 0x20:	tmp = "SYSSTK";		break;
		case 0x21:	tmp = "SYSTMP";		break;
		case 0x30:	tmp = "MPC";		break;
		case 0x31:	tmp = "MIP";		break;
		case 0x33:	tmp = "ECOMCNTL";	break;
		case 0x34:	tmp = "ANASTAT";	break;
		case 0x39:	tmp = "BRK1";		break;
		case 0x3A:	tmp = "BRK2";		break;
		case 0x200:	tmp = "ITAG0";		break;
		case 0x201:	tmp = "ITAG1";		break;
		case 0x202:	tmp = "ITAG2";		break;
		case 0x203:	tmp = "ITAG3";		break;
		case 0x204:	tmp = "ITAG4";		break;
		case 0x205:	tmp = "ITAG5";		break;
		case 0x206:	tmp = "ITAG6";		break;
		case 0x207:	tmp = "ITAG7";		break;
		case 0x208:	tmp = "ITAG8";		break;
		case 0x209:	tmp = "ITAG9";		break;
		case 0x20A:	tmp = "ITAG10";		break;
		case 0x20B:	tmp = "ITAG11";		break;
		case 0x20C:	tmp = "ITAG12";		break;
		case 0x20D:	tmp = "ITAG13";		break;
		case 0x20E:	tmp = "ITAG14";		break;
		case 0x20F:	tmp = "ITAG15";		break;
		case 0x300:	tmp = "ILRU";		break;
		case 0x400:	tmp = "DTAG0";		break;
		case 0x401:	tmp = "DTAG1";		break;
		case 0x402:	tmp = "DTAG2";		break;
		case 0x403:	tmp = "DTAG3";		break;
		case 0x404:	tmp = "DTAG4";		break;
		case 0x405:	tmp = "DTAG5";		break;
		case 0x406:	tmp = "DTAG6";		break;
		case 0x407:	tmp = "DTAG7";		break;
		case 0x408:	tmp = "DTAG8";		break;
		case 0x409:	tmp = "DTAG9";		break;
		case 0x40A:	tmp = "DTAG10";		break;
		case 0x40B:	tmp = "DTAG11";		break;
		case 0x40C:	tmp = "DTAG12";		break;
		case 0x40D:	tmp = "DTAG13";		break;
		case 0x40E:	tmp = "DTAG14";		break;
		case 0x40F:	tmp = "DTAG15";		break;
		case 0x500:	tmp = "DLRU";		break;
		case 0x4000:	tmp = "IN0P";		break;
		case 0x4001:	tmp = "IN1P";		break;
		case 0x4002:	tmp = "OUTP";		break;
		default:	tmp = NULL;		break;
		}
	      if (tmp != NULL)
		{
		  (*info -> fprintf_func) (info -> stream, "%s", tmp);
		}
	      else
		{
		  (*info -> fprintf_func) (info -> stream, "%#lx", value);
		}
	    }
	  else
	    {
	      if ((value > 999 || value < -999)
		  || operand -> flags & TIC80_OPERAND_BITFIELD)
		{
		  (*info -> fprintf_func) (info -> stream, "%#lx", value);
		}
	      else
		{
		  (*info -> fprintf_func) (info -> stream, "%ld", value);
		}
	    }

	  /* If we printed an open paren before printing this operand, close
	     it now. The flag gets reset on each loop. */

	  if (close_paren)
	    {
	      (*info -> fprintf_func) (info -> stream, ")");
	    }
	}
    }

  return (length);
}
Commit	Line	Data
6357e7f6 FF	1	/* Print TI TMS320C80 (MVP) instructions
	2	Copyright 1996 Free Software Foundation, Inc.
	3
	4	This file is free software; you can redistribute it and/or modify
	5	it under the terms of the GNU General Public License as published by
	6	the Free Software Foundation; either version 2 of the License, or
	7	(at your option) any later version.
	8
	9	This program is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
	13
	14	You should have received a copy of the GNU General Public License
	15	along with this program; if not, write to the Free Software
	16	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
a79d0193 FF	17
	18	#include <stdio.h>
	19
	20	#include "ansidecl.h"
	21	#include "opcode/tic80.h"
	22	#include "dis-asm.h"
	23
937fe722 FF	24	#define M_SI(insn,op) ((((op) -> flags & TIC80_OPERAND_M_SI) != 0) && ((insn) & (1 << 17)))
	25	#define M_LI(insn,op) ((((op) -> flags & TIC80_OPERAND_M_LI) != 0) && ((insn) & (1 << 15)))
	26
a79d0193 FF	27	int
	28	print_insn_tic80 (memaddr, info)
	29	bfd_vma memaddr;
	30	struct disassemble_info *info;
	31	{
872dc6f0 FF	32	bfd_byte buffer[4];
	33	int status;
	34	unsigned long insn[2];
	35	const struct tic80_opcode *opcode;
	36	const struct tic80_opcode *opcode_end;
	37	const unsigned char *opindex;
	38	const struct tic80_operand *operand;
937fe722	39	int close_paren;
872dc6f0 FF	40	int length = 4;
	41
	42	status = (*info->read_memory_func) (memaddr, buffer, 4, info);
	43	if (status != 0)
	44	{
	45	(*info->memory_error_func) (status, memaddr, info);
	46	return -1;
	47	}
	48
	49	if (info -> endian == BFD_ENDIAN_LITTLE)
	50	{
	51	insn[0] = bfd_getl32 (buffer);
	52	}
	53	else if (info -> endian == BFD_ENDIAN_BIG)
	54	{
	55	insn[0] = bfd_getb32 (buffer);
	56	}
	57	else
	58	{
	59	/* FIXME: Should probably just default to one or the other */
	60	abort ();
	61	}
	62
	63	/* Find the first opcode match in the opcodes table. FIXME: there should
	64	be faster ways to find one (hash table or binary search), but don't
	65	worry too much about it until other TIc80 support is finished. */
	66
	67	opcode_end = tic80_opcodes + tic80_num_opcodes;
	68	for (opcode = tic80_opcodes; opcode < opcode_end; opcode++)
	69	{
	70	if ((insn[0] & opcode -> mask) == opcode -> opcode)
	71	{
	72	break;
	73	}
	74	}
	75
	76	if (opcode == opcode_end)
	77	{
	78	/* No match found, just print the bits as a .word directive */
	79	(*info -> fprintf_func) (info -> stream, ".word %#08lx", insn[0]);
	80	}
	81	else
	82	{
	83	/* Match found, decode the instruction. */
	84	(*info -> fprintf_func) (info -> stream, "%s", opcode -> name);
	85
	86	/* Now extract and print the operands. */
872dc6f0 FF	87	if (opcode -> operands[0] != 0)
	88	{
	89	(*info -> fprintf_func) (info -> stream, "\t");
	90	}
	91	for (opindex = opcode -> operands; *opindex != 0; opindex++)
	92	{
	93	long value;
	94
	95	operand = tic80_operands + *opindex;
	96
	97	/* Extract the value from the instruction. */
	98	if (operand -> extract)
	99	{
	100	value = (operand -> extract) (insn[0], (int ) NULL);
	101	}
	102	else if (operand -> bits == 32)
	103	{
	104	status = (*info->read_memory_func) (memaddr + 4, buffer, 4, info);
	105	if (status != 0)
	106	{
	107	(*info->memory_error_func) (status, memaddr, info);
	108	return -1;
	109	}
	110
	111	if (info -> endian == BFD_ENDIAN_LITTLE)
	112	{
	113	insn[1] = bfd_getl32 (buffer);
	114	}
	115	else if (info -> endian == BFD_ENDIAN_BIG)
	116	{
	117	insn[1] = bfd_getb32 (buffer);
	118	}
	119	value = (long) insn[1];
	120	length += 4;
	121	}
	122	else
	123	{
	124	value = (insn[0] >> operand -> shift) & ((1 << operand -> bits) - 1);
	125	if ((operand -> flags & TIC80_OPERAND_SIGNED) != 0
	126	&& (value & (1 << (operand -> bits - 1))) != 0)
	127	value -= 1 << operand -> bits;
	128	}
	129
937fe722 FF	130	/* If this operand is enclosed in parenthesis, then print
	131	the open paren, otherwise just print the regular comma
	132	separator, except for the first operand. */
	133
	134	if ((operand -> flags & TIC80_OPERAND_PARENS) == 0)
872dc6f0	135	{
937fe722 FF	136	close_paren = 0;
	137	if (opindex != opcode -> operands)
	138	{
	139	(*info -> fprintf_func) (info -> stream, ",");
	140	}
	141	}
	142	else
	143	{
	144	close_paren = 1;
	145	(*info -> fprintf_func) (info -> stream, "(");
872dc6f0 FF	146	}
	147
	148	/* Print the operand as directed by the flags. */
937fe722	149
872dc6f0 FF	150	if ((operand -> flags & TIC80_OPERAND_GPR) != 0)
	151	{
	152	(*info -> fprintf_func) (info -> stream, "r%ld", value);
937fe722 FF	153	if (M_SI (insn[0], operand) \|\| M_LI (insn[0], operand))
	154	{
	155	(*info -> fprintf_func) (info -> stream, ":m");
	156	}
872dc6f0 FF	157	}
	158	else if ((operand -> flags & TIC80_OPERAND_FPA) != 0)
	159	{
	160	(*info -> fprintf_func) (info -> stream, "a%ld", value);
	161	}
	162	else if ((operand -> flags & TIC80_OPERAND_RELATIVE) != 0)
	163	{
1f8c8c60	164	(info -> print_address_func) (memaddr + 4 value, info);
872dc6f0	165	}
1f8c8c60	166	else if ((operand -> flags & TIC80_OPERAND_BITNUM) != 0)
872dc6f0	167	{
1f8c8c60 FF	168	char *syms[30] = {
	169	"eq.b", "ne.b", "gt.b", "le.b", "lt.b", "ge.b",
	170	"hi.b", "ls.b", "lo.b", "hs.b", "eq.h", "ne.h",
	171	"gt.h", "le.h", "lt.h", "ge.h", "hi.h", "ls.h",
	172	"lo.h", "hs.h", "eq.w", "ne.w", "gt.w", "le.w",
	173	"lt.w", "ge.w", "hi.w", "ls.w", "lo.w", "hs.w"
	174	};
	175	int bitnum = ~value & 0x1F;
	176
	177	if (bitnum < 30)
	178	{
	179	/* Found a value within range */
	180	(*info -> fprintf_func) (info -> stream, "%s", syms[bitnum]);
	181	}
872dc6f0 FF	182	else
872dc6f0 FF	183	{
1f8c8c60 FF	184	/* Not in range, just print as bit number */
	185	(*info -> fprintf_func) (info -> stream, "%ld", bitnum);
	186	}
	187	}
	188	else if ((operand -> flags & TIC80_OPERAND_CC) != 0)
	189	{
	190	char *syms[24] = {
	191	"nev.b", "gt0.b", "eq0.b", "ge0.b", "lt0.b", "ne0.b", "le0.b", "alw.b",
	192	"nev.h", "gt0.h", "eq0.h", "ge0.h", "lt0.h", "ne0.h", "le0.h", "alw.h",
	193	"nev.w", "gt0.w", "eq0.w", "ge0.w", "lt0.w", "ne0.w", "le0.w", "alw.w"
	194	};
	195	if (value < 24)
	196	{
	197	/* Found a value within range */
	198	(*info -> fprintf_func) (info -> stream, "%s", syms[value]);
	199	}
	200	else
	201	{
	202	/* Not in range, just print as decimal digit. */
	203	(*info -> fprintf_func) (info -> stream, "%ld", value);
	204	}
	205	}
	206	else if ((operand -> flags & TIC80_OPERAND_CR) != 0)
	207	{
	208	char *tmp;
	209	switch (value)
	210	{
	211	case 0: tmp = "EPC"; break;
	212	case 1: tmp = "EIP"; break;
	213	case 2: tmp = "CONFIG"; break;
	214	case 4: tmp = "INTPEN"; break;
	215	case 6: tmp = "IE"; break;
	216	case 8: tmp = "FPST"; break;
	217	case 0xA: tmp = "PPERROR"; break;
	218	case 0xD: tmp = "PKTREQ"; break;
	219	case 0xE: tmp = "TCOUNT"; break;
	220	case 0xF: tmp = "TSCALE"; break;
	221	case 0x10: tmp = "FLTOP"; break;
	222	case 0x11: tmp = "FLTADR"; break;
	223	case 0x12: tmp = "FLTTAG"; break;
	224	case 0x13: tmp = "FLTDTL"; break;
	225	case 0x14: tmp = "FLTDTH"; break;
	226	case 0x20: tmp = "SYSSTK"; break;
	227	case 0x21: tmp = "SYSTMP"; break;
	228	case 0x30: tmp = "MPC"; break;
	229	case 0x31: tmp = "MIP"; break;
	230	case 0x33: tmp = "ECOMCNTL"; break;
	231	case 0x34: tmp = "ANASTAT"; break;
	232	case 0x39: tmp = "BRK1"; break;
	233	case 0x3A: tmp = "BRK2"; break;
	234	case 0x200: tmp = "ITAG0"; break;
	235	case 0x201: tmp = "ITAG1"; break;
	236	case 0x202: tmp = "ITAG2"; break;
	237	case 0x203: tmp = "ITAG3"; break;
	238	case 0x204: tmp = "ITAG4"; break;
	239	case 0x205: tmp = "ITAG5"; break;
	240	case 0x206: tmp = "ITAG6"; break;
	241	case 0x207: tmp = "ITAG7"; break;
	242	case 0x208: tmp = "ITAG8"; break;
	243	case 0x209: tmp = "ITAG9"; break;
	244	case 0x20A: tmp = "ITAG10"; break;
	245	case 0x20B: tmp = "ITAG11"; break;
	246	case 0x20C: tmp = "ITAG12"; break;
	247	case 0x20D: tmp = "ITAG13"; break;
248	case 0x20E: tmp = "ITAG14"; break;
249	case 0x20F: tmp = "ITAG15"; break;
250	case 0x300: tmp = "ILRU"; break;
251	case 0x400: tmp = "DTAG0"; break;
252	case 0x401: tmp = "DTAG1"; break;
253	case 0x402: tmp = "DTAG2"; break;
254	case 0x403: tmp = "DTAG3"; break;
255	case 0x404: tmp = "DTAG4"; break;
256	case 0x405: tmp = "DTAG5"; break;
257	case 0x406: tmp = "DTAG6"; break;
258	case 0x407: tmp = "DTAG7"; break;
259	case 0x408: tmp = "DTAG8"; break;
260	case 0x409: tmp = "DTAG9"; break;
261	case 0x40A: tmp = "DTAG10"; break;
262	case 0x40B: tmp = "DTAG11"; break;
263	case 0x40C: tmp = "DTAG12"; break;
264	case 0x40D: tmp = "DTAG13"; break;
265	case 0x40E: tmp = "DTAG14"; break;
266	case 0x40F: tmp = "DTAG15"; break;
267	case 0x500: tmp = "DLRU"; break;
268	case 0x4000: tmp = "IN0P"; break;
269	case 0x4001: tmp = "IN1P"; break;
270	case 0x4002: tmp = "OUTP"; break;
271	default: tmp = NULL; break;
272	}
273	if (tmp != NULL)
274	{
275	(*info -> fprintf_func) (info -> stream, "%s", tmp);
276	}
277	else
278	{
279	(*info -> fprintf_func) (info -> stream, "%#lx", value);
872dc6f0	280	}
872dc6f0 FF	281	}
	282	else
	283	{
	284	if ((value > 999 \|\| value < -999)
	285	\|\| operand -> flags & TIC80_OPERAND_BITFIELD)
	286	{
	287	(*info -> fprintf_func) (info -> stream, "%#lx", value);
	288	}
	289	else
	290	{
	291	(*info -> fprintf_func) (info -> stream, "%ld", value);
	292	}
	293	}
	294
937fe722 FF	295	/* If we printed an open paren before printing this operand, close
937fe722 FF	296	it now. The flag gets reset on each loop. */
872dc6f0	297
937fe722	298	if (close_paren)
872dc6f0	299	{
937fe722	300	(*info -> fprintf_func) (info -> stream, ")");
872dc6f0 FF	301	}
	302	}
	303	}
	304
	305	return (length);
a79d0193	306	}