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

/* Disassemble h8500 instructions.
   Copyright (C) 1993 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include <stdio.h>

#define DISASSEMBLER_TABLE
#define DEFINE_TABLE

#include "h8500-opc.h"
#include "dis-asm.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);
    }
  else
    priv->max_fetched = addr;
  return 1;
}

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

int
print_insn_h8500 (addr, info)
     unsigned long 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;

  /* Run down the table to find the one which matches */
  for (opcode = h8500_table; opcode->name; opcode++)
    {
      int byte;
      int rn;
      int rd;
      int rs;
      int disp;
      int abs;
      int imm;
      int pcrel;
      int qim;
      int i;
      int cr;
      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:
		  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))
		      {
			if (nc)
			  func (stream, ",");
			nc += 1;
		      }
		    func (stream, "r%d", i);
		  }
		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 */
  func (stream, "%02x\t\t*unknown*", buffer[0]);
  return 1;

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