[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
#if 0
#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)))
#else
#define CGEN_DIS_HASH(buffer, value) m32r_cgen_dis_hash(buffer, value)
extern unsigned int m32r_cgen_dis_hash(const char *, CGEN_INSN_INT);
#endif

/* -- */
\f
/* -- opc.c */
unsigned int
m32r_cgen_dis_hash (buf, value)
     const char * buf ATTRIBUTE_UNUSED;
     CGEN_INSN_INT value;
{
  unsigned int x;
                                                                                
  if (value & 0xffff0000) /* 32bit instructions */
    value = (value >> 16) & 0xffff;
                                                                                
  x = (value>>8) & 0xf0;
  if (x == 0x40 || x == 0xe0 || x == 0x60 || x == 0x50)
    return x;
                                                                                
  if (x == 0x70 || x == 0xf0)
    return x | ((value>>8) & 0x0f);
                                                                                
  if (x == 0x30)
    return x | ((value & 0x70) >> 4);
  else
    return x | ((value & 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;
          if (value & 0x8000)
             value |= 0xffff0000;
        }
      *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;
  int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
  char *x;

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

  status = (*info->read_memory_func) (pc - ((!big_p && (pc & 3) != 0) ? 2 : 0),
                                      buf, buflen, info);
  if (status != 0)
    {
      (*info->memory_error_func) (status, pc, info);
      return -1;
    }

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

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

  x = (big_p ? &buf[0] : &buf[1]);
  if (*x & 0x80)
    {
      /* Parallel.  */
      (*info->fprintf_func) (info->stream, " || ");
      *x &= 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
e866a257 AC	30	/* This file is an addendum to m32r.cpu. Heavy use of C code isn't
	31	appropriate in .cpu files, so it resides here. This especially applies
	32	to assembly/disassembly where parsing/printing can be quite involved.
	33	Such things aren't really part of the specification of the cpu, per se,
	34	so .cpu files provide the general framework and .opc files handle the
	35	nitty-gritty details as necessary.
	36
	37	Each section is delimited with start and end markers.
	38
	39	<arch>-opc.h additions use: "-- opc.h"
	40	<arch>-opc.c additions use: "-- opc.c"
	41	<arch>-asm.c additions use: "-- asm.c"
	42	<arch>-dis.c additions use: "-- dis.c"
	43	<arch>-ibd.h additions use: "-- ibd.h"
	44	*/
	45	\f
	46	/* -- opc.h */
	47
	48	#undef CGEN_DIS_HASH_SIZE
	49	#define CGEN_DIS_HASH_SIZE 256
	50	#undef CGEN_DIS_HASH
8ee9a8b2	51	#if 0
e866a257 AC	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)))
8ee9a8b2 NC	59	#else
	60	#define CGEN_DIS_HASH(buffer, value) m32r_cgen_dis_hash(buffer, value)
	61	extern unsigned int m32r_cgen_dis_hash(const char *, CGEN_INSN_INT);
	62	#endif
e866a257	63
8ee9a8b2 NC	64	/* -- */
	65	\f
	66	/* -- opc.c */
	67	unsigned int
	68	m32r_cgen_dis_hash (buf, value)
	69	const char * buf ATTRIBUTE_UNUSED;
	70	CGEN_INSN_INT value;
	71	{
	72	unsigned int x;
	73
	74	if (value & 0xffff0000) /* 32bit instructions */
	75	value = (value >> 16) & 0xffff;
	76
	77	x = (value>>8) & 0xf0;
	78	if (x == 0x40 \|\| x == 0xe0 \|\| x == 0x60 \|\| x == 0x50)
	79	return x;
	80
	81	if (x == 0x70 \|\| x == 0xf0)
	82	return x \| ((value>>8) & 0x0f);
	83
	84	if (x == 0x30)
	85	return x \| ((value & 0x70) >> 4);
	86	else
	87	return x \| ((value & 0xf0) >> 4);
	88	}
	89
e866a257 AC	90	/* -- */
	91	\f
	92	/* -- asm.c */
	93	static const char * parse_hash
	94	PARAMS ((CGEN_CPU_DESC, const char *, int, unsigned long ));
	95	static const char * parse_hi16
	96	PARAMS ((CGEN_CPU_DESC, const char *, int, unsigned long ));
	97	static const char * parse_slo16
	98	PARAMS ((CGEN_CPU_DESC, const char *, int, long ));
	99	static const char * parse_ulo16
	100	PARAMS ((CGEN_CPU_DESC, const char *, int, unsigned long ));
	101
	102	/* Handle '#' prefixes (i.e. skip over them). */
	103
	104	static const char *
	105	parse_hash (cd, strp, opindex, valuep)
	106	CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
	107	const char **strp;
	108	int opindex ATTRIBUTE_UNUSED;
	109	unsigned long *valuep ATTRIBUTE_UNUSED;
	110	{
	111	if (**strp == '#')
	112	++*strp;
	113	return NULL;
	114	}
	115
	116	/* Handle shigh(), high(). */
	117
	118	static const char *
	119	parse_hi16 (cd, strp, opindex, valuep)
	120	CGEN_CPU_DESC cd;
	121	const char **strp;
	122	int opindex;
	123	unsigned long *valuep;
	124	{
	125	const char *errmsg;
	126	enum cgen_parse_operand_result result_type;
	127	bfd_vma value;
	128
	129	if (**strp == '#')
	130	++*strp;
	131
	132	if (strncasecmp (*strp, "high(", 5) == 0)
	133	{
	134	*strp += 5;
	135	errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_HI16_ULO,
	136	&result_type, &value);
	137	if (**strp != ')')
	138	return "missing `)'";
	139	++*strp;
	140	if (errmsg == NULL
	141	&& result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
	142	value >>= 16;
	143	*valuep = value;
	144	return errmsg;
	145	}
	146	else if (strncasecmp (*strp, "shigh(", 6) == 0)
	147	{
	148	*strp += 6;
	149	errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_HI16_SLO,
	150	&result_type, &value);
	151	if (**strp != ')')
	152	return "missing `)'";
	153	++*strp;
154	if (errmsg == NULL
155	&& result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
156	value = (value >> 16) + (value & 0x8000 ? 1 : 0);
157	*valuep = value;
158	return errmsg;
159	}
160
161	return cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
162	}
163
164	/* Handle low() in a signed context. Also handle sda().
165	The signedness of the value doesn't matter to low(), but this also
166	handles the case where low() isn't present. */
167
168	static const char *
169	parse_slo16 (cd, strp, opindex, valuep)
170	CGEN_CPU_DESC cd;
171	const char **strp;
172	int opindex;
173	long *valuep;
174	{
175	const char *errmsg;
176	enum cgen_parse_operand_result result_type;
177	bfd_vma value;
178
179	if (**strp == '#')
180	++*strp;
181
182	if (strncasecmp (*strp, "low(", 4) == 0)
183	{
184	*strp += 4;
185	errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_LO16,
186	&result_type, &value);
187	if (**strp != ')')
188	return "missing `)'";
189	++*strp;
190	if (errmsg == NULL
191	&& result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
8ee9a8b2 NC	192	{
	193	value &= 0xffff;
	194	if (value & 0x8000)
	195	value \|= 0xffff0000;
	196	}
e866a257 AC	197	*valuep = value;
	198	return errmsg;
	199	}
	200
	201	if (strncasecmp (*strp, "sda(", 4) == 0)
	202	{
	203	*strp += 4;
	204	errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_SDA16,
	205	NULL, &value);
	206	if (**strp != ')')
	207	return "missing `)'";
	208	++*strp;
	209	*valuep = value;
	210	return errmsg;
	211	}
	212
	213	return cgen_parse_signed_integer (cd, strp, opindex, valuep);
	214	}
	215
	216	/* Handle low() in an unsigned context.
	217	The signedness of the value doesn't matter to low(), but this also
	218	handles the case where low() isn't present. */
	219
	220	static const char *
	221	parse_ulo16 (cd, strp, opindex, valuep)
	222	CGEN_CPU_DESC cd;
	223	const char **strp;
	224	int opindex;
	225	unsigned long *valuep;
	226	{
	227	const char *errmsg;
	228	enum cgen_parse_operand_result result_type;
	229	bfd_vma value;
	230
	231	if (**strp == '#')
	232	++*strp;
	233
	234	if (strncasecmp (*strp, "low(", 4) == 0)
	235	{
	236	*strp += 4;
	237	errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32R_LO16,
	238	&result_type, &value);
	239	if (**strp != ')')
	240	return "missing `)'";
	241	++*strp;
	242	if (errmsg == NULL
	243	&& result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
	244	value &= 0xffff;
	245	*valuep = value;
	246	return errmsg;
	247	}
	248
	249	return cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
	250	}
	251
	252	/* -- */
	253	\f
	254	/* -- dis.c */
	255	static void print_hash PARAMS ((CGEN_CPU_DESC, PTR, long, unsigned, bfd_vma, int));
	256	static int my_print_insn PARAMS ((CGEN_CPU_DESC, bfd_vma, disassemble_info *));
	257
	258	/* Immediate values are prefixed with '#'. */
	259
	260	#define CGEN_PRINT_NORMAL(cd, info, value, attrs, pc, length) \
261	do \
262	{ \
263	if (CGEN_BOOL_ATTR ((attrs), CGEN_OPERAND_HASH_PREFIX)) \
264	(*info->fprintf_func) (info->stream, "#"); \
265	} \
266	while (0)
267
268	/* Handle '#' prefixes as operands. */
269
270	static void
271	print_hash (cd, dis_info, value, attrs, pc, length)
272	CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
273	PTR dis_info;
274	long value ATTRIBUTE_UNUSED;
275	unsigned int attrs ATTRIBUTE_UNUSED;
276	bfd_vma pc ATTRIBUTE_UNUSED;
277	int length ATTRIBUTE_UNUSED;
278	{
279	disassemble_info info = (disassemble_info ) dis_info;
280	(*info->fprintf_func) (info->stream, "#");
281	}
282
283	#undef CGEN_PRINT_INSN
284	#define CGEN_PRINT_INSN my_print_insn
285
286	static int
287	my_print_insn (cd, pc, info)
288	CGEN_CPU_DESC cd;
289	bfd_vma pc;
290	disassemble_info *info;
291	{
292	char buffer[CGEN_MAX_INSN_SIZE];
293	char *buf = buffer;
294	int status;
295	int buflen = (pc & 3) == 0 ? 4 : 2;
8ee9a8b2 NC	296	int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG;
8ee9a8b2 NC	297	char *x;
e866a257 AC	298
	299	/* Read the base part of the insn. */
	300
8ee9a8b2 NC	301	status = (*info->read_memory_func) (pc - ((!big_p && (pc & 3) != 0) ? 2 : 0),
8ee9a8b2 NC	302	buf, buflen, info);
e866a257 AC	303	if (status != 0)
	304	{
	305	(*info->memory_error_func) (status, pc, info);
	306	return -1;
	307	}
	308
	309	/* 32 bit insn? */
8ee9a8b2 NC	310	x = (big_p ? &buf[0] : &buf[3]);
8ee9a8b2 NC	311	if ((pc & 3) == 0 && (*x & 0x80) != 0)
e866a257 AC	312	return print_insn (cd, pc, info, buf, buflen);
	313
	314	/* Print the first insn. */
	315	if ((pc & 3) == 0)
	316	{
8ee9a8b2	317	buf += (big_p ? 0 : 2);
e866a257 AC	318	if (print_insn (cd, pc, info, buf, 2) == 0)
e866a257 AC	319	(*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
8ee9a8b2	320	buf += (big_p ? 2 : -2);
e866a257 AC	321	}
e866a257 AC	322
8ee9a8b2 NC	323	x = (big_p ? &buf[0] : &buf[1]);
8ee9a8b2 NC	324	if (*x & 0x80)
e866a257 AC	325	{
	326	/* Parallel. */
	327	(*info->fprintf_func) (info->stream, " \|\| ");
8ee9a8b2	328	*x &= 0x7f;
e866a257 AC	329	}
	330	else
	331	(*info->fprintf_func) (info->stream, " -> ");
	332
	333	/* The "& 3" is to pass a consistent address.
	334	Parallel insns arguably both begin on the word boundary.
	335	Also, branch insns are calculated relative to the word boundary. */
	336	if (print_insn (cd, pc & ~ (bfd_vma) 3, info, buf, 2) == 0)
	337	(*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG);
	338
	339	return (pc & 3) ? 2 : 4;
	340	}
	341
	342	/* -- */