[thirdparty/binutils-gdb.git] / opcodes / h8500-dis.c

/* Disassemble h8500 instructions.
   Copyright (C) 1993, 94, 95, 1998 Free Software Foundation, Inc.

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 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>

#define DISASSEMBLER_TABLE
#define DEFINE_TABLE

#include "h8500-opc.h"
#include "dis-asm.h"
#include "opintl.h"

/* Maximum length of an instruction.  */
#define MAXLEN 8

#include <setjmp.h>

struct private
{
  /* Points to first byte not fetched.  */
  bfd_byte *max_fetched;
  bfd_byte the_buffer[MAXLEN];
  bfd_vma insn_start;
  jmp_buf bailout;
};

/* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
   to ADDR (exclusive) are valid.  Returns 1 for success, longjmps
   on error.  */
#define FETCH_DATA(info, addr) \
  ((addr) <= ((struct private *)(info->private_data))->max_fetched \
   ? 1 : fetch_data ((info), (addr)))

static int
fetch_data (info, addr)
     struct disassemble_info *info;
     bfd_byte *addr;
{
  int status;
  struct private *priv = (struct private *) info->private_data;
  bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);

  status = (*info->read_memory_func) (start,
				      priv->max_fetched,
				      addr - priv->max_fetched,
				      info);
  if (status != 0)
    {
      (*info->memory_error_func) (status, start, info);
      longjmp (priv->bailout, 1);
    }
  else
    priv->max_fetched = addr;
  return 1;
}

static char *crname[] =
{"sr", "ccr", "*", "br", "ep", "dp", "*", "tp"};

int
print_insn_h8500 (addr, info)
     bfd_vma addr;
     disassemble_info *info;
{
  h8500_opcode_info *opcode;
  void *stream = info->stream;
  fprintf_ftype func = info->fprintf_func;

  struct private priv;
  bfd_byte *buffer = priv.the_buffer;

  info->private_data = (PTR) & priv;
  priv.max_fetched = priv.the_buffer;
  priv.insn_start = addr;
  if (setjmp (priv.bailout) != 0)
    /* Error return.  */
    return -1;

if (0)  {
    static    int one;
    if (!one ) 
      {
	one = 1;
	for (opcode = h8500_table; opcode->name; opcode++)
	  {
	    if ((opcode->bytes[0].contents & 0x8) == 0)
	      printf("%s\n", opcode->name);
	  }
      }
  }


  /* Run down the table to find the one which matches */
  for (opcode = h8500_table; opcode->name; opcode++)
    {
      int byte;
      int rn = 0;
      int rd = 0;
      int rs = 0;
      int disp = 0;
      int abs = 0;
      int imm = 0;
      int pcrel = 0;
      int qim = 0;
      int i;
      int cr = 0;
      for (byte = 0; byte < opcode->length; byte++)
	{
	  FETCH_DATA (info, buffer + byte + 1);
	  if ((buffer[byte] & opcode->bytes[byte].mask)
	      != (opcode->bytes[byte].contents))
	    {
	      goto next;
	    }
	  else
	    {
	      /* extract any info parts */
	      switch (opcode->bytes[byte].insert)
		{
		case 0:
		case FP:
		  break;
		default:
		  /* xgettext:c-format */
		  func (stream, _("can't cope with insert %d\n"),
			opcode->bytes[byte].insert);
		  break;
		case RN:
		  rn = buffer[byte] & 0x7;
		  break;
		case RS:
		  rs = buffer[byte] & 0x7;
		  break;
		case CRB:
		  cr = buffer[byte] & 0x7;
		  if (cr == 0)
		    goto next;
		  break;
		case CRW:
		  cr = buffer[byte] & 0x7;
		  if (cr != 0)
		    goto next;
		  break;
		case DISP16:
		  FETCH_DATA (info, buffer + byte + 2);
		  disp = (buffer[byte] << 8) | (buffer[byte + 1]);
		  break;
		case FPIND_D8:
		case DISP8:
		  disp = ((char) (buffer[byte]));
		  break;
		case RD:
		case RDIND:
		  rd = buffer[byte] & 0x7;
		  break;
		case ABS24:
		  FETCH_DATA (info, buffer + byte + 3);
		  abs =
		    (buffer[byte] << 16)
		    | (buffer[byte + 1] << 8)
		    | (buffer[byte + 2]);
		  break;
		case ABS16:
		  FETCH_DATA (info, buffer + byte + 2);
		  abs = (buffer[byte] << 8) | (buffer[byte + 1]);
		  break;
		case ABS8:
		  abs = (buffer[byte]);
		  break;
		case IMM16:
		  FETCH_DATA (info, buffer + byte + 2);
		  imm = (buffer[byte] << 8) | (buffer[byte + 1]);
		  break;
		case IMM4:
		  imm = (buffer[byte]) & 0xf;
		  break;
		case IMM8:
		case RLIST:
		  imm = (buffer[byte]);
		  break;
		case PCREL16:
		  FETCH_DATA (info, buffer + byte + 2);
		  pcrel = (buffer[byte] << 8) | (buffer[byte + 1]);
		  break;
		case PCREL8:
		  pcrel = (buffer[byte]);
		  break;
		case QIM:
		  switch (buffer[byte] & 0x7)
		    {
		    case 0:
		      qim = 1;
		      break;
		    case 1:
		      qim = 2;
		      break;
		    case 4:
		      qim = -1;
		      break;
		    case 5:
		      qim = -2;
		      break;
		    }
		  break;

		}
	    }
	}
      /* We get here when all the masks have passed so we can output the
	 operands*/
      FETCH_DATA (info, buffer + opcode->length);
      for (i = 0; i < opcode->length; i++)
	{
	  (func) (stream, "%02x ", buffer[i]);
	}
      for (; i < 6; i++)
	{
	  (func) (stream, "   ");
	}
      (func) (stream, "%s\t", opcode->name);
      for (i = 0; i < opcode->nargs; i++)
	{
	  if (i)
	    (func) (stream, ",");
	  switch (opcode->arg_type[i])
	    {
	    case FP:
	      func (stream, "fp");
	      break;
	    case RNIND_D16:
	      func (stream, "@(0x%x:16,r%d)", disp, rn);
	      break;
	    case RNIND_D8:
	      func (stream, "@(0x%x:8 (%d),r%d)", disp & 0xff, disp, rn);
	      break;
	    case RDIND_D16:
	      func (stream, "@(0x%x:16,r%d)", disp, rd);
	      break;
	    case RDIND_D8:
	      func (stream, "@(0x%x:8 (%d), r%d)", disp & 0xff, disp, rd);
	      break;
	    case FPIND_D8:
	      func (stream, "@(0x%x:8 (%d), fp)", disp & 0xff, disp, rn);
	      break;
	    case CRB:
	    case CRW:
	      func (stream, "%s", crname[cr]);
	      break;
	    case RN:
	      func (stream, "r%d", rn);
	      break;
	    case RD:
	      func (stream, "r%d", rd);
	      break;
	    case RS:
	      func (stream, "r%d", rs);
	      break;
	    case RNDEC:
	      func (stream, "@-r%d", rn);
	      break;
	    case RNINC:
	      func (stream, "@r%d+", rn);
	      break;
	    case RNIND:
	      func (stream, "@r%d", rn);
	      break;
	    case RDIND:
	      func (stream, "@r%d", rd);
	      break;
	    case SPINC:
	      func (stream, "@sp+");
	      break;
	    case SPDEC:
	      func (stream, "@-sp");
	      break;
	    case ABS24:
	      func (stream, "@0x%0x:24", abs);
	      break;
	    case ABS16:
	      func (stream, "@0x%0x:16", abs & 0xffff);
	      break;
	    case ABS8:
	      func (stream, "@0x%0x:8", abs & 0xff);
	      break;
	    case IMM16:
	      func (stream, "#0x%0x:16", imm & 0xffff);
	      break;
	    case RLIST:
	      {
		int i;
		int nc = 0;
		func (stream, "(");
		for (i = 0; i < 8; i++)
		  {
		    if (imm & (1 << i))
		      {
			func (stream, "r%d", i);
			if (nc)
			  func (stream, ",");
			nc = 1;
		      }
		  }
		func (stream, ")");
	      }
	      break;
	    case IMM8:
	      func (stream, "#0x%0x:8", imm & 0xff);
	      break;
	    case PCREL16:
	      func (stream, "0x%0x:16", (pcrel + addr + opcode->length) & 0xffff);
	      break;
	    case PCREL8:
	      func (stream, "#0x%0x:8",
		    ((char) pcrel + addr + opcode->length) & 0xffff);
	      break;
	    case QIM:
	      func (stream, "#%d:q", qim);
	      break;
	    case IMM4:
	      func (stream, "#%d:4", imm);
	      break;
	    }
	}
      return opcode->length;
    next:;
    }

  /* Couldn't understand anything */
  /* xgettext:c-format */
  func (stream, _("%02x\t\t*unknown*"), buffer[0]);
  return 1;

}
Commit	Line	Data
252b5132 RH	1	/* Disassemble h8500 instructions.
	2	Copyright (C) 1993, 94, 95, 1998 Free Software Foundation, Inc.
	3
	4	This program 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. */
	17
	18	#include <stdio.h>
	19
	20	#define DISASSEMBLER_TABLE
	21	#define DEFINE_TABLE
	22
	23	#include "h8500-opc.h"
	24	#include "dis-asm.h"
	25	#include "opintl.h"
	26
	27	/* Maximum length of an instruction. */
	28	#define MAXLEN 8
	29
	30	#include <setjmp.h>
	31
	32	struct private
	33	{
	34	/* Points to first byte not fetched. */
	35	bfd_byte *max_fetched;
	36	bfd_byte the_buffer[MAXLEN];
	37	bfd_vma insn_start;
	38	jmp_buf bailout;
	39	};
	40
	41	/* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
	42	to ADDR (exclusive) are valid. Returns 1 for success, longjmps
	43	on error. */
	44	#define FETCH_DATA(info, addr) \
	45	((addr) <= ((struct private *)(info->private_data))->max_fetched \
	46	? 1 : fetch_data ((info), (addr)))
	47
	48	static int
	49	fetch_data (info, addr)
	50	struct disassemble_info *info;
	51	bfd_byte *addr;
	52	{
	53	int status;
	54	struct private priv = (struct private ) info->private_data;
	55	bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
	56
	57	status = (*info->read_memory_func) (start,
	58	priv->max_fetched,
	59	addr - priv->max_fetched,
	60	info);
	61	if (status != 0)
	62	{
	63	(*info->memory_error_func) (status, start, info);
	64	longjmp (priv->bailout, 1);
65	}
66	else
67	priv->max_fetched = addr;
68	return 1;
69	}
70
71	static char *crname[] =
72	{"sr", "ccr", "", "br", "ep", "dp", "", "tp"};
73
74	int
75	print_insn_h8500 (addr, info)
76	bfd_vma addr;
77	disassemble_info *info;
78	{
79	h8500_opcode_info *opcode;
80	void *stream = info->stream;
81	fprintf_ftype func = info->fprintf_func;
82
83	struct private priv;
84	bfd_byte *buffer = priv.the_buffer;
85
86	info->private_data = (PTR) & priv;
87	priv.max_fetched = priv.the_buffer;
88	priv.insn_start = addr;
89	if (setjmp (priv.bailout) != 0)
90	/* Error return. */
91	return -1;
92
93	if (0) {
94	static int one;
95	if (!one )
96	{
97	one = 1;
98	for (opcode = h8500_table; opcode->name; opcode++)
99	{
100	if ((opcode->bytes[0].contents & 0x8) == 0)
101	printf("%s\n", opcode->name);
102	}
103	}
104	}
105
106
107	/* Run down the table to find the one which matches */
108	for (opcode = h8500_table; opcode->name; opcode++)
109	{
110	int byte;
111	int rn = 0;
112	int rd = 0;
113	int rs = 0;
114	int disp = 0;
115	int abs = 0;
116	int imm = 0;
117	int pcrel = 0;
118	int qim = 0;
119	int i;
120	int cr = 0;
121	for (byte = 0; byte < opcode->length; byte++)
122	{
123	FETCH_DATA (info, buffer + byte + 1);
124	if ((buffer[byte] & opcode->bytes[byte].mask)
125	!= (opcode->bytes[byte].contents))
126	{
127	goto next;
128	}
129	else
130	{
131	/* extract any info parts */
132	switch (opcode->bytes[byte].insert)
133	{
134	case 0:
135	case FP:
136	break;
137	default:
138	/* xgettext:c-format */
139	func (stream, _("can't cope with insert %d\n"),
140	opcode->bytes[byte].insert);
141	break;
142	case RN:
143	rn = buffer[byte] & 0x7;
144	break;
145	case RS:
146	rs = buffer[byte] & 0x7;
147	break;
148	case CRB:
149	cr = buffer[byte] & 0x7;
150	if (cr == 0)
151	goto next;
152	break;
153	case CRW:
154	cr = buffer[byte] & 0x7;
155	if (cr != 0)
156	goto next;
157	break;
158	case DISP16:
159	FETCH_DATA (info, buffer + byte + 2);
160	disp = (buffer[byte] << 8) \| (buffer[byte + 1]);
161	break;
162	case FPIND_D8:
163	case DISP8:
164	disp = ((char) (buffer[byte]));
165	break;
166	case RD:
167	case RDIND:
168	rd = buffer[byte] & 0x7;
169	break;
170	case ABS24:
171	FETCH_DATA (info, buffer + byte + 3);
172	abs =
173	(buffer[byte] << 16)
174	\| (buffer[byte + 1] << 8)
175	\| (buffer[byte + 2]);
176	break;
177	case ABS16:
178	FETCH_DATA (info, buffer + byte + 2);
179	abs = (buffer[byte] << 8) \| (buffer[byte + 1]);
180	break;
181	case ABS8:
182	abs = (buffer[byte]);
183	break;
184	case IMM16:
185	FETCH_DATA (info, buffer + byte + 2);
186	imm = (buffer[byte] << 8) \| (buffer[byte + 1]);
187	break;
188	case IMM4:
189	imm = (buffer[byte]) & 0xf;
190	break;
191	case IMM8:
192	case RLIST:
193	imm = (buffer[byte]);
194	break;
195	case PCREL16:
196	FETCH_DATA (info, buffer + byte + 2);
197	pcrel = (buffer[byte] << 8) \| (buffer[byte + 1]);
198	break;
199	case PCREL8:
200	pcrel = (buffer[byte]);
201	break;
202	case QIM:
203	switch (buffer[byte] & 0x7)
204	{
205	case 0:
206	qim = 1;
207	break;
208	case 1:
209	qim = 2;
210	break;
211	case 4:
212	qim = -1;
213	break;
214	case 5:
215	qim = -2;
216	break;
217	}
218	break;
219
220	}
221	}
222	}
223	/* We get here when all the masks have passed so we can output the
224	operands*/
225	FETCH_DATA (info, buffer + opcode->length);
226	for (i = 0; i < opcode->length; i++)
227	{
228	(func) (stream, "%02x ", buffer[i]);
229	}
230	for (; i < 6; i++)
231	{
232	(func) (stream, " ");
233	}
234	(func) (stream, "%s\t", opcode->name);
235	for (i = 0; i < opcode->nargs; i++)
236	{
237	if (i)
238	(func) (stream, ",");
239	switch (opcode->arg_type[i])
240	{
241	case FP:
242	func (stream, "fp");
243	break;
244	case RNIND_D16:
245	func (stream, "@(0x%x:16,r%d)", disp, rn);
246	break;
247	case RNIND_D8:
248	func (stream, "@(0x%x:8 (%d),r%d)", disp & 0xff, disp, rn);
249	break;
250	case RDIND_D16:
251	func (stream, "@(0x%x:16,r%d)", disp, rd);
252	break;
253	case RDIND_D8:
254	func (stream, "@(0x%x:8 (%d), r%d)", disp & 0xff, disp, rd);
255	break;
256	case FPIND_D8:
257	func (stream, "@(0x%x:8 (%d), fp)", disp & 0xff, disp, rn);
258	break;
259	case CRB:
260	case CRW:
261	func (stream, "%s", crname[cr]);
262	break;
263	case RN:
264	func (stream, "r%d", rn);
265	break;
266	case RD:
267	func (stream, "r%d", rd);
268	break;
269	case RS:
270	func (stream, "r%d", rs);
271	break;
272	case RNDEC:
273	func (stream, "@-r%d", rn);
274	break;
275	case RNINC:
276	func (stream, "@r%d+", rn);
277	break;
278	case RNIND:
279	func (stream, "@r%d", rn);
280	break;
281	case RDIND:
282	func (stream, "@r%d", rd);
283	break;
284	case SPINC:
285	func (stream, "@sp+");
286	break;
287	case SPDEC:
288	func (stream, "@-sp");
289	break;
290	case ABS24:
291	func (stream, "@0x%0x:24", abs);
292	break;
293	case ABS16:
294	func (stream, "@0x%0x:16", abs & 0xffff);
295	break;
296	case ABS8:
297	func (stream, "@0x%0x:8", abs & 0xff);
298	break;
299	case IMM16:
300	func (stream, "#0x%0x:16", imm & 0xffff);
301	break;
302	case RLIST:
303	{
304	int i;
305	int nc = 0;
306	func (stream, "(");
307	for (i = 0; i < 8; i++)
308	{
309	if (imm & (1 << i))
310	{
311	func (stream, "r%d", i);
312	if (nc)
313	func (stream, ",");
314	nc = 1;
315	}
316	}
317	func (stream, ")");
318	}
319	break;
320	case IMM8:
321	func (stream, "#0x%0x:8", imm & 0xff);
322	break;
323	case PCREL16:
324	func (stream, "0x%0x:16", (pcrel + addr + opcode->length) & 0xffff);
325	break;
326	case PCREL8:
327	func (stream, "#0x%0x:8",
328	((char) pcrel + addr + opcode->length) & 0xffff);
329	break;
330	case QIM:
331	func (stream, "#%d:q", qim);
332	break;
333	case IMM4:
334	func (stream, "#%d:4", imm);
335	break;
336	}
337	}
338	return opcode->length;
339	next:;
340	}
341
342	/* Couldn't understand anything */
343	/* xgettext:c-format */
344	func (stream, _("%02x\t\tunknown"), buffer[0]);
345	return 1;
346
347	}