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

/* Disassemble h8300 instructions.
   Copyright (C) 1993, 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.  */

#define DEFINE_TABLE

#define h8_opcodes h8ops
#include "opcode/h8300.h"
#include "dis-asm.h"
#include "opintl.h"


/* Run through the opcodes and sort them into order to make them easy
   to disassemble
 */
static void
bfd_h8_disassemble_init ()
{
  unsigned int i;


  struct h8_opcode *p;

  for (p = h8_opcodes; p->name; p++)
    {
      int n1 = 0;
      int n2 = 0;

      if ((int) p->data.nib[0] < 16)
	{
	  n1 = (int) p->data.nib[0];
	}
      else
	n1 = 0;
      if ((int) p->data.nib[1] < 16)
	{
	  n2 = (int) p->data.nib[1];
	}
      else
	n2 = 0;

      /* Just make sure there are an even number of nibbles in it, and
	 that the count is the same s the length */
      for (i = 0; p->data.nib[i] != E; i++)
	/*EMPTY*/ ;
      if (i & 1)
	abort ();
      p->length = i / 2;
    }

}


unsigned int
bfd_h8_disassemble (addr, info, mode)
     bfd_vma addr;
     disassemble_info *info;
     int mode;
{
  /* Find the first entry in the table for this opcode */
  static CONST char *regnames[] =
    {
      "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
      "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l"};
  
  static CONST char *wregnames[] =
    {
      "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
      "e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7"
      };
  
  static CONST char *lregnames[] =
    {
      "er0", "er1", "er2", "er3", "er4", "er5", "er6", "er7",
      "er0", "er1", "er2", "er3", "er4", "er5", "er6", "er7"
      }
  ;

  int rs = 0;
  int rd = 0;
  int rdisp = 0;
  int abs = 0;
  int bit = 0;
  int plen = 0;
  static boolean init = 0;
  struct h8_opcode *q = h8_opcodes;
  char CONST **pregnames = mode != 0 ? lregnames : wregnames;
  int status;
  int l;
  
  unsigned char data[20];  
  void *stream = info->stream;
  fprintf_ftype fprintf = info->fprintf_func;

  if (!init)
    {
      bfd_h8_disassemble_init ();
      init = 1;
    }

  status = info->read_memory_func(addr, data, 2, info);
  if (status != 0) 
    {
      info->memory_error_func(status, addr, info);
      return -1;
    }
  for (l = 2; status == 0 && l < 10; l+=2)
    {
      status = info->read_memory_func(addr+l, data+l, 2, info);
    }
  
  
  /* Find the exact opcode/arg combo */
  while (q->name)
    {
      op_type *nib;
      unsigned int len = 0;

      nib = q->data.nib;
      
      while (1)
	{
	  op_type looking_for = *nib;
	  int thisnib = data[len >> 1];
	  
	  thisnib = (len & 1) ? (thisnib & 0xf) : ((thisnib >> 4) & 0xf);
	  
	  if (looking_for < 16 && looking_for >=0) 
	    {
	      
	      if (looking_for != thisnib) 
		goto fail;
	    }
	  
	  else 
	    {
	      
	      if ((int) looking_for & (int) B31)
		{
		  if (! (((int) thisnib & 0x8) != 0)) 
		    goto fail;
		  looking_for = (op_type) ((int) looking_for & ~(int) B31);
		}
	      if ((int) looking_for & (int) B30)
		{
		  if (!(((int) thisnib & 0x8) == 0)) 
		    goto fail;
		  looking_for = (op_type) ((int) looking_for & ~(int) B30);
		}

	      if (looking_for & DBIT)
		{
		  if ((looking_for & 5) != (thisnib &5)) goto fail;
		  abs = (thisnib & 0x8) ? 2 : 1;
		}		  
	      
	      else  if (looking_for & (REG | IND|INC|DEC))
		{
		  if (looking_for & SRC)
		    {
		      rs = thisnib;
		    }
		  else
		    {
		      rd = thisnib;
		    }
		}
	      else if (looking_for & L_16)
		{
		  abs = (data[len >> 1]) * 256 + data[(len + 2) >> 1];
		  plen = 16;
	      
		}
	      else if(looking_for & ABSJMP)
		{
		  abs =
		    (data[1] << 16)
		      | (data[2] << 8)
			| (data[3]);
		}
	      else if(looking_for & MEMIND)
		{
		  abs = data[1];
		}
	      else if (looking_for & L_32)
		{
		  int i = len >> 1;
		  abs = (data[i] << 24)
		    | (data[i + 1] << 16)
		      | (data[i + 2] << 8)
			| (data[i+ 3]);

		  plen =32;
	      
		}
	      else if (looking_for & L_24)
		{
		  int i = len >> 1;
		  abs = (data[i] << 16) | (data[i + 1] << 8)|  (data[i+2]);
		  plen =24;
		}
	      else if (looking_for & IGNORE)
		{
		  
		}
	      else if (looking_for & DISPREG)
		{
		  rdisp = thisnib;
		}
	      else if (looking_for & KBIT)
		{
		  switch (thisnib) 
		    {
		    case 9:
		      abs = 4;
		      break;
		    case 8:
		      abs = 2;
		      break;
		    case 0:
		      abs = 1;
		      break;
		    default:
		      goto fail;
		    }
		}
	      else if (looking_for & L_8)
		{
		  plen = 8;		  
		  abs = data[len >> 1];
		}
	      else if (looking_for & L_3)
		{
		  bit = thisnib & 0x7;
		}
	      else if (looking_for & L_2)
		{
		  plen = 2;
		  abs = thisnib & 0x3;
		}
	      else if (looking_for & MACREG)
		{
		  abs = (thisnib == 3);
		}
	      else if (looking_for == E)
		{

		  {
		    int i;

		    for (i = 0; i < q->length; i++)
		      {
			fprintf (stream, "%02x ", data[i]);
		      }
		    for (; i < 6; i++)
		      {
			fprintf (stream, "   ");
		      }
		  }
		  fprintf (stream, "%s\t", q->name);

		  /* Gross.  Disgusting.  */
		  if (strcmp (q->name, "ldm.l") == 0)
		    {
		      int count, high;

		      count = (data[1] >> 4) & 0x3;
		      high = data[3] & 0x7;

		      fprintf (stream, "@sp+,er%d-er%d", high - count, high);
		      return q->length;
		    }

		  if (strcmp (q->name, "stm.l") == 0)
		    {
		      int count, low;

		      count = (data[1] >> 4) & 0x3;
		      low = data[3] & 0x7;

		      fprintf (stream, "er%d-er%d,@-sp", low, low + count);
		      return q->length;
		    }

		  /* Fill in the args */
		  {
		    op_type *args = q->args.nib;
		    int hadone = 0;


		    while (*args != E)
		      {
			int x = *args;
			if (hadone)
			  fprintf (stream, ",");


			if (x & L_3)
			  {
			    fprintf (stream, "#0x%x", (unsigned) bit);
			  }
			else if (x & (IMM|KBIT|DBIT))
			  {
			    /* Bletch.  For shal #2,er0 and friends.  */
			    if (*(args+1) & SRC_IN_DST)
			      abs = 2;

			    fprintf (stream, "#0x%x", (unsigned) abs);
			  }
			else if (x & REG)
			  {
			    int rn = (x & DST) ? rd : rs;
			    switch (x & SIZE)
			      {
			      case L_8:
				fprintf (stream, "%s", regnames[rn]);
				break;
			      case L_16:
				fprintf (stream, "%s", wregnames[rn]);
				break;
			      case L_P:
			      case L_32:
				fprintf (stream, "%s", lregnames[rn]);
				break;
		    
			      }
			  }
			else if (x & MACREG)
			  {
			    fprintf (stream, "mac%c", abs ? 'l' : 'h');
			  }
			else if (x & INC)
			  {
			    fprintf (stream, "@%s+", pregnames[rs]);
			  }
			else if (x & DEC)
			  {
			    fprintf (stream, "@-%s", pregnames[rd]);
			  }

			else if (x & IND)
			  {
			    int rn = (x & DST) ? rd : rs;
			    fprintf (stream, "@%s", pregnames[rn]);
			  }

			else if (x & ABS8MEM)
			  {
			    fprintf (stream, "@0x%x:8", (unsigned) abs);
			  }

			else if (x & (ABS|ABSJMP))
			  {
			    fprintf (stream, "@0x%x:%d", (unsigned) abs, plen);
			  }

			else if (x & MEMIND)
			  {
			    fprintf (stream, "@@%d (%x)", abs, abs);
			  }

			else if (x & PCREL)
			  {
			    if (x & L_16) 
			      {
				abs  +=2;
				fprintf (stream, ".%s%d (%x)", (short) abs > 0 ? "+" : "", (short) abs,
					 addr + (short) abs + 2);
			      }
			    else {
			      fprintf (stream, ".%s%d (%x)", (char) abs > 0 ? "+" : "", (char) abs,
				       addr + (char) abs + 2);
			    }
			  }
			else if (x & DISP)
			  {
			    fprintf (stream, "@(0x%x:%d,%s)", abs,plen, pregnames[rdisp]);
			  }

			else if (x & CCR)
			  {
			    fprintf (stream, "ccr");
			  }
			else if (x & EXR)
			  {
			    fprintf (stream, "exr");
			  }
			else
			  /* xgettext:c-format */
			  fprintf (stream, _("Hmmmm %x"), x);
			hadone = 1;
			args++;
		      }
		  }
		  return q->length;
		}

      
	      else
		{
		  /* xgettext:c-format */
		  fprintf (stream, _("Don't understand %x \n"), looking_for);
		}
	    }
	  
	  len++;
	  nib++;
	}
      
    fail:
      q++;
    }

  /* Fell of the end */
  fprintf (stream, "%02x %02x        .word\tH'%x,H'%x",
	   data[0], data[1],
	   data[0], data[1]);
  return 2;
}

int 
print_insn_h8300 (addr, info)
bfd_vma addr; 
disassemble_info *info;
{
  return bfd_h8_disassemble (addr, info , 0);
}

int 
print_insn_h8300h (addr, info)
bfd_vma addr;
disassemble_info *info;
{
  return bfd_h8_disassemble (addr, info , 1);
}

int 
print_insn_h8300s (addr, info)
bfd_vma addr;
disassemble_info *info;
{
  return bfd_h8_disassemble (addr, info , 2);
}
Commit	Line	Data
252b5132 RH	1	/* Disassemble h8300 instructions.
	2	Copyright (C) 1993, 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	#define DEFINE_TABLE
	19
	20	#define h8_opcodes h8ops
	21	#include "opcode/h8300.h"
	22	#include "dis-asm.h"
	23	#include "opintl.h"
	24
	25
	26	/* Run through the opcodes and sort them into order to make them easy
	27	to disassemble
	28	*/
	29	static void
	30	bfd_h8_disassemble_init ()
	31	{
	32	unsigned int i;
	33
	34
	35	struct h8_opcode *p;
	36
	37	for (p = h8_opcodes; p->name; p++)
	38	{
	39	int n1 = 0;
	40	int n2 = 0;
	41
	42	if ((int) p->data.nib[0] < 16)
	43	{
	44	n1 = (int) p->data.nib[0];
	45	}
	46	else
	47	n1 = 0;
	48	if ((int) p->data.nib[1] < 16)
	49	{
	50	n2 = (int) p->data.nib[1];
	51	}
	52	else
	53	n2 = 0;
	54
	55	/* Just make sure there are an even number of nibbles in it, and
	56	that the count is the same s the length */
	57	for (i = 0; p->data.nib[i] != E; i++)
	58	/EMPTY/ ;
	59	if (i & 1)
	60	abort ();
	61	p->length = i / 2;
	62	}
	63
	64	}
65
66
67	unsigned int
68	bfd_h8_disassemble (addr, info, mode)
69	bfd_vma addr;
70	disassemble_info *info;
71	int mode;
72	{
73	/* Find the first entry in the table for this opcode */
74	static CONST char *regnames[] =
75	{
76	"r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
77	"r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l"};
78
79	static CONST char *wregnames[] =
80	{
81	"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
82	"e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7"
83	};
84
85	static CONST char *lregnames[] =
86	{
87	"er0", "er1", "er2", "er3", "er4", "er5", "er6", "er7",
88	"er0", "er1", "er2", "er3", "er4", "er5", "er6", "er7"
89	}
90	;
91
92	int rs = 0;
93	int rd = 0;
94	int rdisp = 0;
95	int abs = 0;
96	int bit = 0;
97	int plen = 0;
98	static boolean init = 0;
99	struct h8_opcode *q = h8_opcodes;
100	char CONST **pregnames = mode != 0 ? lregnames : wregnames;
101	int status;
102	int l;
103
104	unsigned char data[20];
105	void *stream = info->stream;
106	fprintf_ftype fprintf = info->fprintf_func;
107
108	if (!init)
109	{
110	bfd_h8_disassemble_init ();
111	init = 1;
112	}
113
114	status = info->read_memory_func(addr, data, 2, info);
115	if (status != 0)
116	{
117	info->memory_error_func(status, addr, info);
118	return -1;
119	}
120	for (l = 2; status == 0 && l < 10; l+=2)
121	{
122	status = info->read_memory_func(addr+l, data+l, 2, info);
123	}
124
125
126
127	/* Find the exact opcode/arg combo */
128	while (q->name)
129	{
130	op_type *nib;
131	unsigned int len = 0;
132
133	nib = q->data.nib;
134
135	while (1)
136	{
137	op_type looking_for = *nib;
138	int thisnib = data[len >> 1];
139
140	thisnib = (len & 1) ? (thisnib & 0xf) : ((thisnib >> 4) & 0xf);
141
142	if (looking_for < 16 && looking_for >=0)
143	{
144
145	if (looking_for != thisnib)
146	goto fail;
147	}
148
149	else
150	{
151
152	if ((int) looking_for & (int) B31)
153	{
154	if (! (((int) thisnib & 0x8) != 0))
155	goto fail;
156	looking_for = (op_type) ((int) looking_for & ~(int) B31);
157	}
158	if ((int) looking_for & (int) B30)
159	{
160	if (!(((int) thisnib & 0x8) == 0))
161	goto fail;
162	looking_for = (op_type) ((int) looking_for & ~(int) B30);
163	}
164
165	if (looking_for & DBIT)
166	{
167	if ((looking_for & 5) != (thisnib &5)) goto fail;
168	abs = (thisnib & 0x8) ? 2 : 1;
169	}
170
171	else if (looking_for & (REG \| IND\|INC\|DEC))
172	{
173	if (looking_for & SRC)
174	{
175	rs = thisnib;
176	}
177	else
178	{
179	rd = thisnib;
180	}
181	}
182	else if (looking_for & L_16)
183	{
184	abs = (data[len >> 1]) * 256 + data[(len + 2) >> 1];
185	plen = 16;
186
187	}
188	else if(looking_for & ABSJMP)
189	{
190	abs =
191	(data[1] << 16)
192	\| (data[2] << 8)
193	\| (data[3]);
194	}
195	else if(looking_for & MEMIND)
196	{
197	abs = data[1];
198	}
199	else if (looking_for & L_32)
200	{
201	int i = len >> 1;
202	abs = (data[i] << 24)
203	\| (data[i + 1] << 16)
204	\| (data[i + 2] << 8)
205	\| (data[i+ 3]);
206
207	plen =32;
208
209	}
210	else if (looking_for & L_24)
211	{
212	int i = len >> 1;
213	abs = (data[i] << 16) \| (data[i + 1] << 8)\| (data[i+2]);
214	plen =24;
215	}
216	else if (looking_for & IGNORE)
217	{
218
219	}
220	else if (looking_for & DISPREG)
221	{
222	rdisp = thisnib;
223	}
224	else if (looking_for & KBIT)
225	{
226	switch (thisnib)
227	{
228	case 9:
229	abs = 4;
230	break;
231	case 8:
232	abs = 2;
233	break;
234	case 0:
235	abs = 1;
236	break;
237	default:
238	goto fail;
239	}
240	}
241	else if (looking_for & L_8)
242	{
243	plen = 8;
244	abs = data[len >> 1];
245	}
246	else if (looking_for & L_3)
247	{
248	bit = thisnib & 0x7;
249	}
250	else if (looking_for & L_2)
251	{
252	plen = 2;
253	abs = thisnib & 0x3;
254	}
255	else if (looking_for & MACREG)
256	{
257	abs = (thisnib == 3);
258	}
259	else if (looking_for == E)
260	{
261
262	{
263	int i;
264
265	for (i = 0; i < q->length; i++)
266	{
267	fprintf (stream, "%02x ", data[i]);
268	}
269	for (; i < 6; i++)
270	{
271	fprintf (stream, " ");
272	}
273	}
274	fprintf (stream, "%s\t", q->name);
275
276	/* Gross. Disgusting. */
277	if (strcmp (q->name, "ldm.l") == 0)
278	{
279	int count, high;
280
281	count = (data[1] >> 4) & 0x3;
282	high = data[3] & 0x7;
283
284	fprintf (stream, "@sp+,er%d-er%d", high - count, high);
285	return q->length;
286	}
287
288	if (strcmp (q->name, "stm.l") == 0)
289	{
290	int count, low;
291
292	count = (data[1] >> 4) & 0x3;
293	low = data[3] & 0x7;
294
295	fprintf (stream, "er%d-er%d,@-sp", low, low + count);
296	return q->length;
297	}
298
299	/* Fill in the args */
300	{
301	op_type *args = q->args.nib;
302	int hadone = 0;
303
304
305	while (*args != E)
306	{
307	int x = *args;
308	if (hadone)
309	fprintf (stream, ",");
310
311
312	if (x & L_3)
313	{
314	fprintf (stream, "#0x%x", (unsigned) bit);
315	}
316	else if (x & (IMM\|KBIT\|DBIT))
317	{
318	/* Bletch. For shal #2,er0 and friends. */
319	if (*(args+1) & SRC_IN_DST)
320	abs = 2;
321
322	fprintf (stream, "#0x%x", (unsigned) abs);
323	}
324	else if (x & REG)
325	{
326	int rn = (x & DST) ? rd : rs;
327	switch (x & SIZE)
328	{
329	case L_8:
330	fprintf (stream, "%s", regnames[rn]);
331	break;
332	case L_16:
333	fprintf (stream, "%s", wregnames[rn]);
334	break;
335	case L_P:
336	case L_32:
337	fprintf (stream, "%s", lregnames[rn]);
338	break;
339
340	}
341	}
342	else if (x & MACREG)
343	{
344	fprintf (stream, "mac%c", abs ? 'l' : 'h');
345	}
346	else if (x & INC)
347	{
348	fprintf (stream, "@%s+", pregnames[rs]);
349	}
350	else if (x & DEC)
351	{
352	fprintf (stream, "@-%s", pregnames[rd]);
353	}
354
355	else if (x & IND)
356	{
357	int rn = (x & DST) ? rd : rs;
358	fprintf (stream, "@%s", pregnames[rn]);
359	}
360
361	else if (x & ABS8MEM)
362	{
363	fprintf (stream, "@0x%x:8", (unsigned) abs);
364	}
365
366	else if (x & (ABS\|ABSJMP))
367	{
368	fprintf (stream, "@0x%x:%d", (unsigned) abs, plen);
369	}
370
371	else if (x & MEMIND)
372	{
373	fprintf (stream, "@@%d (%x)", abs, abs);
374	}
375
376	else if (x & PCREL)
377	{
378	if (x & L_16)
379	{
380	abs +=2;
381	fprintf (stream, ".%s%d (%x)", (short) abs > 0 ? "+" : "", (short) abs,
382	addr + (short) abs + 2);
383	}
384	else {
385	fprintf (stream, ".%s%d (%x)", (char) abs > 0 ? "+" : "", (char) abs,
386	addr + (char) abs + 2);
387	}
388	}
389	else if (x & DISP)
390	{
391	fprintf (stream, "@(0x%x:%d,%s)", abs,plen, pregnames[rdisp]);
392	}
393
394	else if (x & CCR)
395	{
396	fprintf (stream, "ccr");
397	}
398	else if (x & EXR)
399	{
400	fprintf (stream, "exr");
401	}
402	else
403	/* xgettext:c-format */
404	fprintf (stream, _("Hmmmm %x"), x);
405	hadone = 1;
406	args++;
407	}
408	}
409	return q->length;
410	}
411
412
413	else
414	{
415	/* xgettext:c-format */
416	fprintf (stream, _("Don't understand %x \n"), looking_for);
417	}
418	}
419
420	len++;
421	nib++;
422	}
423
424	fail:
425	q++;
426	}
427
428	/* Fell of the end */
429	fprintf (stream, "%02x %02x .word\tH'%x,H'%x",
430	data[0], data[1],
431	data[0], data[1]);
432	return 2;
433	}
434
435	int
436	print_insn_h8300 (addr, info)
437	bfd_vma addr;
438	disassemble_info *info;
439	{
440	return bfd_h8_disassemble (addr, info , 0);
441	}
442
443	int
444	print_insn_h8300h (addr, info)
445	bfd_vma addr;
446	disassemble_info *info;
447	{
448	return bfd_h8_disassemble (addr, info , 1);
449	}
450
451	int
452	print_insn_h8300s (addr, info)
453	bfd_vma addr;
454	disassemble_info *info;
455	{
456	return bfd_h8_disassemble (addr, info , 2);
457	}