[deliverable/binutils-gdb.git] / cpu / m32r.opc

/* M32R opcode support.  -*- C -*-

   Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.

   Contributed by Red Hat Inc; developed under contract from
   Mitsubishi Electric Corporation.

   This file is part of the GNU Binutils.

   Contributed by Red Hat Inc; developed under contract from Fujitsu.

   This file is part of the GNU Binutils.

   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.

*/


/* This file is an addendum to m32r.cpu.  Heavy use of C code isn't
   appropriate in .cpu files, so it resides here.  This especially applies
   to assembly/disassembly where parsing/printing can be quite involved.
   Such things aren't really part of the specification of the cpu, per se,
   so .cpu files provide the general framework and .opc files handle the
   nitty-gritty details as necessary.

   Each section is delimited with start and end markers.

   <arch>-opc.h additions use: "-- opc.h"
   <arch>-opc.c additions use: "-- opc.c"
   <arch>-asm.c additions use: "-- asm.c"
   <arch>-dis.c additions use: "-- dis.c"
   <arch>-ibd.h additions use: "-- ibd.h"
*/
\f
/* -- opc.h */

#undef  CGEN_DIS_HASH_SIZE
#define CGEN_DIS_HASH_SIZE 256
#undef  CGEN_DIS_HASH
#define X(b) (((unsigned char *) (b))[0] & 0xf0)
#define CGEN_DIS_HASH(buffer, value) \
(X (buffer) | \
 (X (buffer) == 0x40 || X (buffer) == 0xe0 || X (buffer) == 0x60 || X (buffer) == 0x50 ? 0 \
  : X (buffer) == 0x70 || X (buffer) == 0xf0 ? (((unsigned char *) (buffer))[0] & 0xf) \
  : X (buffer) == 0x30 ? ((((unsigned char *) (buffer))[1] & 0x70) >> 4) \
  : ((((unsigned char *) (buffer))[1] & 0xf0) >> 4)))

/* -- */
\f
/* -- asm.c */
static const char * parse_hash
  PARAMS ((CGEN_CPU_DESC, const char **, int, unsigned long *));
static const char * parse_hi16
  PARAMS ((CGEN_CPU_DESC, const char **, int, unsigned long *));
static const char * parse_slo16
  PARAMS ((CGEN_CPU_DESC, const char **, int, long *));
static const char * parse_ulo16
  PARAMS ((CGEN_CPU_DESC, const char **, int, unsigned long *));

/* Handle '#' prefixes (i.e. skip over them).  */

static const char *
parse_hash (cd, strp, opindex, valuep)
     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
     const char **strp;
     int opindex ATTRIBUTE_UNUSED;
     unsigned long *valuep ATTRIBUTE_UNUSED;
{
  if (**strp == '#')
    ++*strp;
  return NULL;
}

/* Handle shigh(), high().  */

static const char *
parse_hi16 (cd, strp, opindex, valuep)
     CGEN_CPU_DESC cd;
     const char **strp;
     int opindex;
     unsigned long *valuep;
{
  const char *errmsg;
  enum cgen_parse_operand_result result_type;
  bfd_vma value;

  if (**strp == '#')
    ++*strp;

  if (strncasecmp (*strp, "high(", 5) == 0)
    {
      *strp += 5;
      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_HI16_ULO,
				   &result_type, &value);
      if (**strp != ')')
	return "missing `)'";
      ++*strp;
      if (errmsg == NULL
  	  && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
	value >>= 16;
      *valuep = value;
      return errmsg;
    }
  else if (strncasecmp (*strp, "shigh(", 6) == 0)
    {
      *strp += 6;
      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_HI16_SLO,
 				   &result_type, &value);
      if (**strp != ')')
	return "missing `)'";
      ++*strp;
      if (errmsg == NULL
	  && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
	value = (value >> 16) + (value & 0x8000 ? 1 : 0);
      *valuep = value;
      return errmsg;
    }

  return cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
}

/* Handle low() in a signed context.  Also handle sda().
   The signedness of the value doesn't matter to low(), but this also
   handles the case where low() isn't present.  */

static const char *
parse_slo16 (cd, strp, opindex, valuep)
     CGEN_CPU_DESC cd;
     const char **strp;
     int opindex;
     long *valuep;
{
  const char *errmsg;
  enum cgen_parse_operand_result result_type;
  bfd_vma value;

  if (**strp == '#')
    ++*strp;

  if (strncasecmp (*strp, "low(", 4) == 0)
    {
      *strp += 4;
      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_LO16,
				   &result_type, &value);
      if (**strp != ')')
	return "missing `)'";
      ++*strp;
      if (errmsg == NULL
	  && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
	value &= 0xffff;
      *valuep = value;
      return errmsg;
    }

  if (strncasecmp (*strp, "sda(", 4) == 0)
    {
      *strp += 4;
      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_SDA16,
				   NULL, &value);
      if (**strp != ')')
	return "missing `)'";
      ++*strp;
      *valuep = value;
      return errmsg;
    }

  return cgen_parse_signed_integer (cd, strp, opindex, valuep);
}

/* Handle low() in an unsigned context.
   The signedness of the value doesn't matter to low(), but this also
   handles the case where low() isn't present.  */

static const char *
parse_ulo16 (cd, strp, opindex, valuep)
     CGEN_CPU_DESC cd;
     const char **strp;
     int opindex;
     unsigned long *valuep;
{
  const char *errmsg;
  enum cgen_parse_operand_result result_type;
  bfd_vma value;

  if (**strp == '#')
    ++*strp;

  if (strncasecmp (*strp, "low(", 4) == 0)
    {
      *strp += 4;
      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_LO16,
				   &result_type, &value);
      if (**strp != ')')
	return "missing `)'";
      ++*strp;
      if (errmsg == NULL
	  && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
	value &= 0xffff;
      *valuep = value;
      return errmsg;
    }

  return cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
}

/* -- */
\f
/* -- dis.c */
static void print_hash PARAMS ((CGEN_CPU_DESC, PTR, long, unsigned, bfd_vma, int));
static int my_print_insn PARAMS ((CGEN_CPU_DESC, bfd_vma, disassemble_info *));

/* Immediate values are prefixed with '#'.  */

#define CGEN_PRINT_NORMAL(cd, info, value, attrs, pc, length)	\
  do								\
    {								\
      if (CGEN_BOOL_ATTR ((attrs), CGEN_OPERAND_HASH_PREFIX))	\
        (*info->fprintf_func) (info->stream, "#");		\
    }								\
  while (0)

/* Handle '#' prefixes as operands.  */

static void
print_hash (cd, dis_info, value, attrs, pc, length)
     CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
     PTR dis_info;
     long value ATTRIBUTE_UNUSED;
     unsigned int attrs ATTRIBUTE_UNUSED;
     bfd_vma pc ATTRIBUTE_UNUSED;
     int length ATTRIBUTE_UNUSED;
{
  disassemble_info *info = (disassemble_info *) dis_info;
  (*info->fprintf_func) (info->stream, "#");
}

#undef  CGEN_PRINT_INSN
#define CGEN_PRINT_INSN my_print_insn

static int
my_print_insn (cd, pc, info)
     CGEN_CPU_DESC cd;
     bfd_vma pc;
     disassemble_info *info;
{
  char buffer[CGEN_MAX_INSN_SIZE];
  char *buf = buffer;
  int status;
  int buflen = (pc & 3) == 0 ? 4 : 2;

  /* Read the base part of the insn.  */

  status = (*info->read_memory_func) (pc, buf, buflen, info);
  if (status != 0)
    {
      (*info->memory_error_func) (status, pc, info);
      return -1;
    }

  /* 32 bit insn?  */
  if ((pc & 3) == 0 && (buf[0] & 0x80) != 0)
    return print_insn (cd, pc, info, buf, buflen);

  /* Print the first insn.  */
  if ((pc & 3) == 0)
    {
      if (print_insn (cd, pc, info, buf, 2) == 0)
	(*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
      buf += 2;
    }

  if (buf[0] & 0x80)
    {
      /* Parallel.  */
      (*info->fprintf_func) (info->stream, " || ");
      buf[0] &= 0x7f;
    }
  else
    (*info->fprintf_func) (info->stream, " -> ");

  /* The "& 3" is to pass a consistent address.
     Parallel insns arguably both begin on the word boundary.
     Also, branch insns are calculated relative to the word boundary.  */
  if (print_insn (cd, pc & ~ (bfd_vma) 3, info, buf, 2) == 0)
    (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);

  return (pc & 3) ? 2 : 4;
}

/* -- */
Commit	Line	Data
e866a257 AC	1	/* M32R opcode support. -- C --
	2
	3	Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
	4
	5	Contributed by Red Hat Inc; developed under contract from
	6	Mitsubishi Electric Corporation.
	7
	8	This file is part of the GNU Binutils.
	9
	10	Contributed by Red Hat Inc; developed under contract from Fujitsu.
	11
	12	This file is part of the GNU Binutils.
	13
	14	This program is free software; you can redistribute it and/or modify
	15	it under the terms of the GNU General Public License as published by
	16	the Free Software Foundation; either version 2 of the License, or
	17	(at your option) any later version.
	18
	19	This program is distributed in the hope that it will be useful,
	20	but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	GNU General Public License for more details.
	23
	24	You should have received a copy of the GNU General Public License
	25	along with this program; if not, write to the Free Software
	26	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	27
	28	*/
	29
	30
	31	/* This file is an addendum to m32r.cpu. Heavy use of C code isn't
	32	appropriate in .cpu files, so it resides here. This especially applies
	33	to assembly/disassembly where parsing/printing can be quite involved.
	34	Such things aren't really part of the specification of the cpu, per se,
	35	so .cpu files provide the general framework and .opc files handle the
	36	nitty-gritty details as necessary.
	37
	38	Each section is delimited with start and end markers.
	39
	40	<arch>-opc.h additions use: "-- opc.h"
	41	<arch>-opc.c additions use: "-- opc.c"
	42	<arch>-asm.c additions use: "-- asm.c"
	43	<arch>-dis.c additions use: "-- dis.c"
	44	<arch>-ibd.h additions use: "-- ibd.h"
	45	*/
	46	\f
	47	/* -- opc.h */
	48
	49	#undef CGEN_DIS_HASH_SIZE
	50	#define CGEN_DIS_HASH_SIZE 256
	51	#undef CGEN_DIS_HASH
	52	#define X(b) (((unsigned char *) (b))[0] & 0xf0)
	53	#define CGEN_DIS_HASH(buffer, value) \
	54	(X (buffer) \| \
	55	(X (buffer) == 0x40 \|\| X (buffer) == 0xe0 \|\| X (buffer) == 0x60 \|\| X (buffer) == 0x50 ? 0 \
	56	: X (buffer) == 0x70 \|\| X (buffer) == 0xf0 ? (((unsigned char *) (buffer))[0] & 0xf) \
	57	: X (buffer) == 0x30 ? ((((unsigned char *) (buffer))[1] & 0x70) >> 4) \
	58	: ((((unsigned char *) (buffer))[1] & 0xf0) >> 4)))
	59
	60	/* -- */
	61	\f
	62	/* -- asm.c */
	63	static const char * parse_hash
	64	PARAMS ((CGEN_CPU_DESC, const char *, int, unsigned long ));
65	static const char * parse_hi16
66	PARAMS ((CGEN_CPU_DESC, const char *, int, unsigned long ));
67	static const char * parse_slo16
68	PARAMS ((CGEN_CPU_DESC, const char *, int, long ));
69	static const char * parse_ulo16
70	PARAMS ((CGEN_CPU_DESC, const char *, int, unsigned long ));
71
72	/* Handle '#' prefixes (i.e. skip over them). */
73
74	static const char *
75	parse_hash (cd, strp, opindex, valuep)
76	CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
77	const char **strp;
78	int opindex ATTRIBUTE_UNUSED;
79	unsigned long *valuep ATTRIBUTE_UNUSED;
80	{
81	if (**strp == '#')
82	++*strp;
83	return NULL;
84	}
85
86	/* Handle shigh(), high(). */
87
88	static const char *
89	parse_hi16 (cd, strp, opindex, valuep)
90	CGEN_CPU_DESC cd;
91	const char **strp;
92	int opindex;
93	unsigned long *valuep;
94	{
95	const char *errmsg;
96	enum cgen_parse_operand_result result_type;
97	bfd_vma value;
98
99	if (**strp == '#')
100	++*strp;
101
102	if (strncasecmp (*strp, "high(", 5) == 0)
103	{
104	*strp += 5;
105	errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_HI16_ULO,
106	&result_type, &value);
107	if (**strp != ')')
108	return "missing `)'";
109	++*strp;
110	if (errmsg == NULL
111	&& result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
112	value >>= 16;
113	*valuep = value;
114	return errmsg;
115	}
116	else if (strncasecmp (*strp, "shigh(", 6) == 0)
117	{
118	*strp += 6;
119	errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_HI16_SLO,
120	&result_type, &value);
121	if (**strp != ')')
122	return "missing `)'";
123	++*strp;
124	if (errmsg == NULL
125	&& result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
126	value = (value >> 16) + (value & 0x8000 ? 1 : 0);
127	*valuep = value;
128	return errmsg;
129	}
130
131	return cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
132	}
133
134	/* Handle low() in a signed context. Also handle sda().
135	The signedness of the value doesn't matter to low(), but this also
136	handles the case where low() isn't present. */
137
138	static const char *
139	parse_slo16 (cd, strp, opindex, valuep)
140	CGEN_CPU_DESC cd;
141	const char **strp;
142	int opindex;
143	long *valuep;
144	{
145	const char *errmsg;
146	enum cgen_parse_operand_result result_type;
147	bfd_vma value;
148
149	if (**strp == '#')
150	++*strp;
151
152	if (strncasecmp (*strp, "low(", 4) == 0)
153	{
154	*strp += 4;
155	errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_LO16,
156	&result_type, &value);
157	if (**strp != ')')
158	return "missing `)'";
159	++*strp;
160	if (errmsg == NULL
161	&& result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
162	value &= 0xffff;
163	*valuep = value;
164	return errmsg;
165	}
166
167	if (strncasecmp (*strp, "sda(", 4) == 0)
168	{
169	*strp += 4;
170	errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_SDA16,
171	NULL, &value);
172	if (**strp != ')')
173	return "missing `)'";
174	++*strp;
175	*valuep = value;
176	return errmsg;
177	}
178
179	return cgen_parse_signed_integer (cd, strp, opindex, valuep);
180	}
181
182	/* Handle low() in an unsigned context.
183	The signedness of the value doesn't matter to low(), but this also
184	handles the case where low() isn't present. */
185
186	static const char *
187	parse_ulo16 (cd, strp, opindex, valuep)
188	CGEN_CPU_DESC cd;
189	const char **strp;
190	int opindex;
191	unsigned long *valuep;
192	{
193	const char *errmsg;
194	enum cgen_parse_operand_result result_type;
195	bfd_vma value;
196
197	if (**strp == '#')
198	++*strp;
199
200	if (strncasecmp (*strp, "low(", 4) == 0)
201	{
202	*strp += 4;
203	errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_LO16,
204	&result_type, &value);
205	if (**strp != ')')
206	return "missing `)'";
207	++*strp;
208	if (errmsg == NULL
209	&& result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
210	value &= 0xffff;
211	*valuep = value;
212	return errmsg;
213	}
214
215	return cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
216	}
217
218	/* -- */
219	\f
220	/* -- dis.c */
221	static void print_hash PARAMS ((CGEN_CPU_DESC, PTR, long, unsigned, bfd_vma, int));
222	static int my_print_insn PARAMS ((CGEN_CPU_DESC, bfd_vma, disassemble_info *));
223
224	/* Immediate values are prefixed with '#'. */
225
226	#define CGEN_PRINT_NORMAL(cd, info, value, attrs, pc, length) \
227	do \
228	{ \
229	if (CGEN_BOOL_ATTR ((attrs), CGEN_OPERAND_HASH_PREFIX)) \
230	(*info->fprintf_func) (info->stream, "#"); \
231	} \
232	while (0)
233
234	/* Handle '#' prefixes as operands. */
235
236	static void
237	print_hash (cd, dis_info, value, attrs, pc, length)
238	CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
239	PTR dis_info;
240	long value ATTRIBUTE_UNUSED;
241	unsigned int attrs ATTRIBUTE_UNUSED;
242	bfd_vma pc ATTRIBUTE_UNUSED;
243	int length ATTRIBUTE_UNUSED;
244	{
245	disassemble_info info = (disassemble_info ) dis_info;
246	(*info->fprintf_func) (info->stream, "#");
247	}
248
249	#undef CGEN_PRINT_INSN
250	#define CGEN_PRINT_INSN my_print_insn
251
252	static int
253	my_print_insn (cd, pc, info)
254	CGEN_CPU_DESC cd;
255	bfd_vma pc;
256	disassemble_info *info;
257	{
258	char buffer[CGEN_MAX_INSN_SIZE];
259	char *buf = buffer;
260	int status;
261	int buflen = (pc & 3) == 0 ? 4 : 2;
262
263	/* Read the base part of the insn. */
264
265	status = (*info->read_memory_func) (pc, buf, buflen, info);
266	if (status != 0)
267	{
268	(*info->memory_error_func) (status, pc, info);
269	return -1;
270	}
271
272	/* 32 bit insn? */
273	if ((pc & 3) == 0 && (buf[0] & 0x80) != 0)
274	return print_insn (cd, pc, info, buf, buflen);
275
276	/* Print the first insn. */
277	if ((pc & 3) == 0)
278	{
279	if (print_insn (cd, pc, info, buf, 2) == 0)
280	(*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
281	buf += 2;
282	}
283
284	if (buf[0] & 0x80)
285	{
286	/* Parallel. */
287	(*info->fprintf_func) (info->stream, " \|\| ");
288	buf[0] &= 0x7f;
289	}
290	else
291	(*info->fprintf_func) (info->stream, " -> ");
292
293	/* The "& 3" is to pass a consistent address.
294	Parallel insns arguably both begin on the word boundary.
295	Also, branch insns are calculated relative to the word boundary. */
296	if (print_insn (cd, pc & ~ (bfd_vma) 3, info, buf, 2) == 0)
297	(*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
298
299	return (pc & 3) ? 2 : 4;
300	}
301
302	/* -- */