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

/* Morpho Technologies mRISC opcode support, for GNU Binutils.  -*- C -*-
   Copyright 2001 Free Software Foundation, Inc.

   Contributed by Red Hat Inc; developed under contract from
   Morpho Technologies.

   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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.

*/

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

/* Check applicability of instructions against machines.  */
#define CGEN_VALIDATE_INSN_SUPPORTED

/* Allows reason codes to be output when assembler errors occur.  */
#define CGEN_VERBOSE_ASSEMBLER_ERRORS

/* Override disassembly hashing - there are variable bits in the top
   byte of these instructions.  */
#define CGEN_DIS_HASH_SIZE 8
#define CGEN_DIS_HASH(buf, value) (((* (unsigned char *) (buf)) >> 5) % CGEN_DIS_HASH_SIZE)

#define CGEN_ASM_HASH_SIZE 127
#define CGEN_ASM_HASH(insn) ms1_asm_hash (insn)

extern unsigned int ms1_asm_hash (const char *);

extern int ms1_cgen_insn_supported (CGEN_CPU_DESC, const CGEN_INSN *);

\f
/* -- opc.c */
#include "safe-ctype.h"

/* Special check to ensure that instruction exists for given machine.  */

int
ms1_cgen_insn_supported (CGEN_CPU_DESC cd,
			 const CGEN_INSN *insn)
{
  int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH);

  /* No mach attribute?  Assume it's supported for all machs.  */
  if (machs == 0)
    return 1;
  
  return ((machs & cd->machs) != 0);
}

/* A better hash function for instruction mnemonics.  */

unsigned int
ms1_asm_hash (const char* insn)
{
  unsigned int hash;
  const char* m = insn;

  for (hash = 0; *m && ! ISSPACE (*m); m++)
    hash = (hash * 23) ^ (0x1F & TOLOWER (*m));

  /* printf ("%s %d\n", insn, (hash % CGEN_ASM_HASH_SIZE)); */

  return hash % CGEN_ASM_HASH_SIZE;
}

\f
/* -- asm.c */
/* Range checking for signed numbers.  Returns 0 if acceptable
   and 1 if the value is out of bounds for a signed quantity.  */

static int 
signed_out_of_bounds (long val)
{
  if ((val < -32768) || (val > 32767))
    return 1;
  return 0;
}

static const char *
parse_imm16 (CGEN_CPU_DESC cd,
	     const char **strp,
	     int opindex,
	     void *arg)
{
  signed long * valuep = (signed long *) arg;
  const char *errmsg;
  enum cgen_parse_operand_result result_type;
  bfd_reloc_code_real_type code = BFD_RELOC_NONE;
  bfd_vma value;

  /* Is it a control transfer instructions?  */ 
  if (opindex == (CGEN_OPERAND_TYPE) MS1_OPERAND_IMM16O)
    {
      code = BFD_RELOC_16_PCREL;
      errmsg = cgen_parse_address (cd, strp, opindex, code,
                                   & result_type, & value);
      if (errmsg == NULL)
	{
	  if (signed_out_of_bounds (value))
	    errmsg = _("Operand out of range. Must be between -32768 and 32767.");
	}
      *valuep = value;
      return errmsg;
    }

  /* If it's not a control transfer instruction, then
     we have to check for %OP relocating operators.  */
  if (strncmp (*strp, "%hi16", 5) == 0)
    {
      *strp += 5;
      code = BFD_RELOC_HI16;
    }
  else if (strncmp (*strp, "%lo16", 5) == 0)
    {
      *strp += 5;
      code = BFD_RELOC_LO16;
    }

  /* If we found a %OP relocating operator, then parse it as an address.
     If not, we need to parse it as an integer, either signed or unsigned
     depending on which operand type we have.  */
  if (code != BFD_RELOC_NONE)
    {
       /* %OP relocating operator found.  */
       errmsg = cgen_parse_address (cd, strp, opindex, code,
                                   & result_type, & value);
       if (errmsg == NULL)
	 {
           switch (result_type)
	     {
	     case (CGEN_PARSE_OPERAND_RESULT_NUMBER):
	       if (code == BFD_RELOC_HI16)
		 value = (value >> 16) & 0xFFFF;
	       else if (code == BFD_RELOC_LO16)
		 value = value  & 0xFFFF;
	       else 
		 errmsg = _("Biiiig Trouble in parse_imm16!");
	       break;

	     case (CGEN_PARSE_OPERAND_RESULT_QUEUED):
	       /* No special processing for this case.  */
	       break;

	     default:
	       errmsg = _("%operator operand is not a symbol");
	       break;
             }
	 }
       *valuep = value;
    }
  else
    {
      /* Parse hex values like 0xffff as unsigned, and sign extend
	 them manually.  */
      int parse_signed = (opindex == (CGEN_OPERAND_TYPE)MS1_OPERAND_IMM16);

      if ((*strp)[0] == '0'
	  && ((*strp)[1] == 'x' || (*strp)[1] == 'X'))
	parse_signed = 0;

      /* No relocating operator.  Parse as an number.  */
      if (parse_signed)
	{
          /* Parse as as signed integer.  */
 
          errmsg = cgen_parse_signed_integer (cd, strp, opindex, valuep);

          if (errmsg == NULL) 
	    {
#if 0
	      /* Manual range checking is needed for the signed case.  */
	      if (*valuep & 0x8000)
                value = 0xffff0000 | *valuep;
	      else 
                value = *valuep;

	      if (signed_out_of_bounds (value))
	        errmsg = _("Operand out of range. Must be between -32768 and 32767.");
	      /* Truncate to 16 bits. This is necessary
		 because cgen will have sign extended *valuep.  */
	      *valuep &= 0xFFFF; 
#endif
	    }
	}
      else  
	{
          /* MS1_OPERAND_IMM16Z.  Parse as an unsigned integer.  */
          errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, (unsigned long *) valuep);

	  if (opindex == (CGEN_OPERAND_TYPE) MS1_OPERAND_IMM16
	      && *valuep >= 0x8000
	      && *valuep <= 0xffff)
	    *valuep -= 0x10000;
	}
    }

  return errmsg;
}


static const char *
parse_dup (CGEN_CPU_DESC cd,
	   const char **strp,
	   int opindex,
	   unsigned long *valuep)
{
  const char *errmsg = NULL;

  if (strncmp (*strp, "dup", 3) == 0 || strncmp (*strp, "DUP", 3) == 0)
    {
      *strp += 3;
      *valuep = 1;
    }
  else if (strncmp (*strp, "xx", 2) == 0 || strncmp (*strp, "XX", 2) == 0)
    {
      *strp += 2;
      *valuep = 0;
    }
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);

  return errmsg;
}


static const char *
parse_ball (CGEN_CPU_DESC cd,
	    const char **strp,
	    int opindex,
	    unsigned long *valuep)
{
  const char *errmsg = NULL;

  if (strncmp (*strp, "all", 3) == 0 || strncmp (*strp, "ALL", 3) == 0)
    {
      *strp += 3;
      *valuep = 1;
    }
  else if (strncmp (*strp, "one", 3) == 0 || strncmp (*strp, "ONE", 3) == 0)
    {
      *strp += 3;
      *valuep = 0;
    }
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);

  return errmsg;
}

static const char *
parse_xmode (CGEN_CPU_DESC cd,
	     const char **strp,
	     int opindex,
	     unsigned long *valuep)
{
  const char *errmsg = NULL;

  if (strncmp (*strp, "pm", 2) == 0 || strncmp (*strp, "PM", 2) == 0)
    {
      *strp += 2;
      *valuep = 1;
    }
  else if (strncmp (*strp, "xm", 2) == 0 || strncmp (*strp, "XM", 2) == 0)
    {
      *strp += 2;
      *valuep = 0;
    }
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);

  return errmsg;
}

static const char *
parse_rc (CGEN_CPU_DESC cd,
	  const char **strp,
	  int opindex,
	  unsigned long *valuep)
{
  const char *errmsg = NULL;

  if (strncmp (*strp, "r", 1) == 0 || strncmp (*strp, "R", 1) == 0)
    {
      *strp += 1;
      *valuep = 1;
    }
  else if (strncmp (*strp, "c", 1) == 0 || strncmp (*strp, "C", 1) == 0)
    {
      *strp += 1;
      *valuep = 0;
    }
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);

  return errmsg;
}

static const char *
parse_cbrb (CGEN_CPU_DESC cd,
	    const char **strp,
	    int opindex,
	    unsigned long *valuep)
{
  const char *errmsg = NULL;

  if (strncmp (*strp, "rb", 2) == 0 || strncmp (*strp, "RB", 2) == 0)
    {
      *strp += 2;
      *valuep = 1;
    }
  else if (strncmp (*strp, "cb", 2) == 0 || strncmp (*strp, "CB", 2) == 0)
    {
      *strp += 2;
      *valuep = 0;
    }
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);

  return errmsg;
}

static const char *
parse_rbbc (CGEN_CPU_DESC cd,
	    const char **strp,
	    int opindex,
	    unsigned long *valuep)
{
  const char *errmsg = NULL;

  if (strncmp (*strp, "rt", 2) == 0 || strncmp (*strp, "RT", 2) == 0)
    {
      *strp += 2;
      *valuep = 0;
    }
  else if (strncmp (*strp, "br1", 3) == 0 || strncmp (*strp, "BR1", 3) == 0)
    {
      *strp += 3;
      *valuep = 1;
    }
  else if (strncmp (*strp, "br2", 3) == 0 || strncmp (*strp, "BR2", 3) == 0)
    {
      *strp += 3;
      *valuep = 2;
    }
  else if (strncmp (*strp, "cs", 2) == 0 || strncmp (*strp, "CS", 2) == 0)
    {
      *strp += 2;
      *valuep = 3;
    }
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);

  return errmsg;
}

static const char *
parse_type (CGEN_CPU_DESC cd,
	    const char **strp,
	    int opindex,
	    unsigned long *valuep)
{
  const char *errmsg = NULL;

  if (strncmp (*strp, "odd", 3) == 0 || strncmp (*strp, "ODD", 3) == 0)
    {
      *strp += 3;
      *valuep = 0;
    }
  else if (strncmp (*strp, "even", 4) == 0 || strncmp (*strp, "EVEN", 4) == 0)
    {
      *strp += 4;
      *valuep = 1;
    }
  else if (strncmp (*strp, "oe", 2) == 0 || strncmp (*strp, "OE", 2) == 0)
    {
      *strp += 2;
      *valuep = 2;
    }
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);

 if ((errmsg == NULL) && (*valuep == 3))
    errmsg = _("invalid operand.  type may have values 0,1,2 only.");

  return errmsg;
}

/* -- dis.c */
static void print_dollarhex (CGEN_CPU_DESC, PTR, long, unsigned, bfd_vma, int);

static void
print_dollarhex (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
		 void * dis_info,
		 long value,
		 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, "$%lx", value);

  if (0)
    print_normal (cd, dis_info, value, attrs, pc, length);
}


/* -- */
Commit	Line	Data
b081650b DB	1	/* Morpho Technologies mRISC opcode support, for GNU Binutils. -- C --
	2	Copyright 2001 Free Software Foundation, Inc.
	3
	4	Contributed by Red Hat Inc; developed under contract from
	5	Morpho Technologies.
	6
	7	This file is part of the GNU Binutils.
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2 of the License, or
	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with this program; if not, write to the Free Software
	21	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
	22
	23	*/
	24
	25	/*
	26	Each section is delimited with start and end markers.
	27
	28	<arch>-opc.h additions use: "-- opc.h"
	29	<arch>-opc.c additions use: "-- opc.c"
	30	<arch>-asm.c additions use: "-- asm.c"
	31	<arch>-dis.c additions use: "-- dis.c"
	32	<arch>-ibd.h additions use: "-- ibd.h"
	33	*/
	34	\f
	35	/* -- opc.h */
	36
	37	/* Check applicability of instructions against machines. */
	38	#define CGEN_VALIDATE_INSN_SUPPORTED
	39
	40	/* Allows reason codes to be output when assembler errors occur. */
	41	#define CGEN_VERBOSE_ASSEMBLER_ERRORS
	42
	43	/* Override disassembly hashing - there are variable bits in the top
	44	byte of these instructions. */
	45	#define CGEN_DIS_HASH_SIZE 8
	46	#define CGEN_DIS_HASH(buf, value) (((* (unsigned char *) (buf)) >> 5) % CGEN_DIS_HASH_SIZE)
	47
	48	#define CGEN_ASM_HASH_SIZE 127
	49	#define CGEN_ASM_HASH(insn) ms1_asm_hash (insn)
	50
	51	extern unsigned int ms1_asm_hash (const char *);
	52
	53	extern int ms1_cgen_insn_supported (CGEN_CPU_DESC, const CGEN_INSN *);
	54
	55	\f
	56	/* -- opc.c */
	57	#include "safe-ctype.h"
	58
	59	/* Special check to ensure that instruction exists for given machine. */
	60
	61	int
	62	ms1_cgen_insn_supported (CGEN_CPU_DESC cd,
	63	const CGEN_INSN *insn)
	64	{
65	int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH);
66
67	/* No mach attribute? Assume it's supported for all machs. */
68	if (machs == 0)
69	return 1;
70
71	return ((machs & cd->machs) != 0);
72	}
73
74	/* A better hash function for instruction mnemonics. */
75
76	unsigned int
77	ms1_asm_hash (const char* insn)
78	{
79	unsigned int hash;
80	const char* m = insn;
81
82	for (hash = 0; m && ! ISSPACE (m); m++)
83	hash = (hash * 23) ^ (0x1F & TOLOWER (*m));
84
85	/* printf ("%s %d\n", insn, (hash % CGEN_ASM_HASH_SIZE)); */
86
87	return hash % CGEN_ASM_HASH_SIZE;
88	}
89
90	\f
91	/* -- asm.c */
b081650b DB	92	/* Range checking for signed numbers. Returns 0 if acceptable
	93	and 1 if the value is out of bounds for a signed quantity. */
	94
	95	static int
	96	signed_out_of_bounds (long val)
	97	{
	98	if ((val < -32768) \|\| (val > 32767))
	99	return 1;
	100	return 0;
	101	}
	102
	103	static const char *
	104	parse_imm16 (CGEN_CPU_DESC cd,
	105	const char **strp,
	106	int opindex,
3ec2b351	107	void *arg)
b081650b	108	{
3ec2b351	109	signed long * valuep = (signed long *) arg;
b081650b DB	110	const char *errmsg;
	111	enum cgen_parse_operand_result result_type;
	112	bfd_reloc_code_real_type code = BFD_RELOC_NONE;
	113	bfd_vma value;
	114
	115	/* Is it a control transfer instructions? */
	116	if (opindex == (CGEN_OPERAND_TYPE) MS1_OPERAND_IMM16O)
	117	{
	118	code = BFD_RELOC_16_PCREL;
	119	errmsg = cgen_parse_address (cd, strp, opindex, code,
	120	& result_type, & value);
	121	if (errmsg == NULL)
	122	{
	123	if (signed_out_of_bounds (value))
	124	errmsg = _("Operand out of range. Must be between -32768 and 32767.");
	125	}
	126	*valuep = value;
	127	return errmsg;
	128	}
	129
	130	/* If it's not a control transfer instruction, then
	131	we have to check for %OP relocating operators. */
	132	if (strncmp (*strp, "%hi16", 5) == 0)
	133	{
	134	*strp += 5;
	135	code = BFD_RELOC_HI16;
	136	}
	137	else if (strncmp (*strp, "%lo16", 5) == 0)
	138	{
	139	*strp += 5;
	140	code = BFD_RELOC_LO16;
	141	}
	142
	143	/* If we found a %OP relocating operator, then parse it as an address.
	144	If not, we need to parse it as an integer, either signed or unsigned
	145	depending on which operand type we have. */
	146	if (code != BFD_RELOC_NONE)
	147	{
	148	/* %OP relocating operator found. */
	149	errmsg = cgen_parse_address (cd, strp, opindex, code,
	150	& result_type, & value);
	151	if (errmsg == NULL)
	152	{
	153	switch (result_type)
	154	{
	155	case (CGEN_PARSE_OPERAND_RESULT_NUMBER):
	156	if (code == BFD_RELOC_HI16)
	157	value = (value >> 16) & 0xFFFF;
	158	else if (code == BFD_RELOC_LO16)
	159	value = value & 0xFFFF;
	160	else
	161	errmsg = _("Biiiig Trouble in parse_imm16!");
	162	break;
	163
	164	case (CGEN_PARSE_OPERAND_RESULT_QUEUED):
	165	/* No special processing for this case. */
	166	break;
	167
	168	default:
	169	errmsg = _("%operator operand is not a symbol");
	170	break;
	171	}
	172	}
	173	*valuep = value;
174	}
175	else
176	{
177	/* Parse hex values like 0xffff as unsigned, and sign extend
178	them manually. */
179	int parse_signed = (opindex == (CGEN_OPERAND_TYPE)MS1_OPERAND_IMM16);
180
181	if ((*strp)[0] == '0'
182	&& ((strp)[1] == 'x' \|\| (strp)[1] == 'X'))
183	parse_signed = 0;
184
185	/* No relocating operator. Parse as an number. */
186	if (parse_signed)
187	{
188	/* Parse as as signed integer. */
189
190	errmsg = cgen_parse_signed_integer (cd, strp, opindex, valuep);
191
192	if (errmsg == NULL)
193	{
194	#if 0
195	/* Manual range checking is needed for the signed case. */
196	if (*valuep & 0x8000)
197	value = 0xffff0000 \| *valuep;
198	else
199	value = *valuep;
200
201	if (signed_out_of_bounds (value))
202	errmsg = _("Operand out of range. Must be between -32768 and 32767.");
203	/* Truncate to 16 bits. This is necessary
204	because cgen will have sign extended valuep. /
205	*valuep &= 0xFFFF;
206	#endif
207	}
208	}
209	else
210	{
211	/* MS1_OPERAND_IMM16Z. Parse as an unsigned integer. */
3ec2b351	212	errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, (unsigned long *) valuep);
b081650b	213
3ec2b351	214	if (opindex == (CGEN_OPERAND_TYPE) MS1_OPERAND_IMM16
b081650b DB	215	&& *valuep >= 0x8000
	216	&& *valuep <= 0xffff)
	217	*valuep -= 0x10000;
	218	}
	219	}
	220
	221	return errmsg;
	222	}
	223
	224
	225	static const char *
	226	parse_dup (CGEN_CPU_DESC cd,
	227	const char **strp,
	228	int opindex,
3ec2b351	229	unsigned long *valuep)
b081650b DB	230	{
	231	const char *errmsg = NULL;
	232
	233	if (strncmp (strp, "dup", 3) == 0 \|\| strncmp (strp, "DUP", 3) == 0)
	234	{
	235	*strp += 3;
	236	*valuep = 1;
	237	}
	238	else if (strncmp (strp, "xx", 2) == 0 \|\| strncmp (strp, "XX", 2) == 0)
	239	{
	240	*strp += 2;
	241	*valuep = 0;
	242	}
	243	else
	244	errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
	245
	246	return errmsg;
	247	}
	248
	249
	250	static const char *
	251	parse_ball (CGEN_CPU_DESC cd,
	252	const char **strp,
	253	int opindex,
3ec2b351	254	unsigned long *valuep)
b081650b DB	255	{
	256	const char *errmsg = NULL;
	257
	258	if (strncmp (strp, "all", 3) == 0 \|\| strncmp (strp, "ALL", 3) == 0)
	259	{
	260	*strp += 3;
	261	*valuep = 1;
	262	}
	263	else if (strncmp (strp, "one", 3) == 0 \|\| strncmp (strp, "ONE", 3) == 0)
	264	{
	265	*strp += 3;
	266	*valuep = 0;
	267	}
	268	else
	269	errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
	270
	271	return errmsg;
	272	}
	273
	274	static const char *
	275	parse_xmode (CGEN_CPU_DESC cd,
	276	const char **strp,
	277	int opindex,
3ec2b351	278	unsigned long *valuep)
b081650b DB	279	{
	280	const char *errmsg = NULL;
	281
	282	if (strncmp (strp, "pm", 2) == 0 \|\| strncmp (strp, "PM", 2) == 0)
	283	{
	284	*strp += 2;
	285	*valuep = 1;
	286	}
	287	else if (strncmp (strp, "xm", 2) == 0 \|\| strncmp (strp, "XM", 2) == 0)
	288	{
	289	*strp += 2;
	290	*valuep = 0;
	291	}
	292	else
	293	errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
	294
	295	return errmsg;
	296	}
	297
	298	static const char *
	299	parse_rc (CGEN_CPU_DESC cd,
	300	const char **strp,
	301	int opindex,
3ec2b351	302	unsigned long *valuep)
b081650b DB	303	{
	304	const char *errmsg = NULL;
	305
	306	if (strncmp (strp, "r", 1) == 0 \|\| strncmp (strp, "R", 1) == 0)
	307	{
	308	*strp += 1;
	309	*valuep = 1;
	310	}
	311	else if (strncmp (strp, "c", 1) == 0 \|\| strncmp (strp, "C", 1) == 0)
	312	{
	313	*strp += 1;
	314	*valuep = 0;
	315	}
	316	else
	317	errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
	318
	319	return errmsg;
	320	}
	321
	322	static const char *
	323	parse_cbrb (CGEN_CPU_DESC cd,
	324	const char **strp,
	325	int opindex,
3ec2b351	326	unsigned long *valuep)
b081650b DB	327	{
	328	const char *errmsg = NULL;
	329
	330	if (strncmp (strp, "rb", 2) == 0 \|\| strncmp (strp, "RB", 2) == 0)
	331	{
	332	*strp += 2;
	333	*valuep = 1;
	334	}
	335	else if (strncmp (strp, "cb", 2) == 0 \|\| strncmp (strp, "CB", 2) == 0)
	336	{
	337	*strp += 2;
	338	*valuep = 0;
	339	}
	340	else
	341	errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
	342
	343	return errmsg;
	344	}
	345
	346	static const char *
	347	parse_rbbc (CGEN_CPU_DESC cd,
	348	const char **strp,
	349	int opindex,
3ec2b351	350	unsigned long *valuep)
b081650b DB	351	{
	352	const char *errmsg = NULL;
	353
	354	if (strncmp (strp, "rt", 2) == 0 \|\| strncmp (strp, "RT", 2) == 0)
	355	{
	356	*strp += 2;
	357	*valuep = 0;
	358	}
	359	else if (strncmp (strp, "br1", 3) == 0 \|\| strncmp (strp, "BR1", 3) == 0)
	360	{
	361	*strp += 3;
	362	*valuep = 1;
	363	}
	364	else if (strncmp (strp, "br2", 3) == 0 \|\| strncmp (strp, "BR2", 3) == 0)
	365	{
	366	*strp += 3;
	367	*valuep = 2;
	368	}
	369	else if (strncmp (strp, "cs", 2) == 0 \|\| strncmp (strp, "CS", 2) == 0)
	370	{
	371	*strp += 2;
	372	*valuep = 3;
	373	}
	374	else
	375	errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
	376
	377	return errmsg;
	378	}
	379
	380	static const char *
	381	parse_type (CGEN_CPU_DESC cd,
	382	const char **strp,
	383	int opindex,
3ec2b351	384	unsigned long *valuep)
b081650b DB	385	{
	386	const char *errmsg = NULL;
	387
	388	if (strncmp (strp, "odd", 3) == 0 \|\| strncmp (strp, "ODD", 3) == 0)
	389	{
	390	*strp += 3;
	391	*valuep = 0;
	392	}
	393	else if (strncmp (strp, "even", 4) == 0 \|\| strncmp (strp, "EVEN", 4) == 0)
	394	{
	395	*strp += 4;
	396	*valuep = 1;
	397	}
	398	else if (strncmp (strp, "oe", 2) == 0 \|\| strncmp (strp, "OE", 2) == 0)
	399	{
	400	*strp += 2;
	401	*valuep = 2;
	402	}
	403	else
	404	errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
	405
	406	if ((errmsg == NULL) && (*valuep == 3))
	407	errmsg = _("invalid operand. type may have values 0,1,2 only.");
	408
	409	return errmsg;
	410	}
	411
	412	/* -- dis.c */
	413	static void print_dollarhex (CGEN_CPU_DESC, PTR, long, unsigned, bfd_vma, int);
	414
	415	static void
	416	print_dollarhex (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
	417	void * dis_info,
	418	long value,
	419	unsigned int attrs ATTRIBUTE_UNUSED,
	420	bfd_vma pc ATTRIBUTE_UNUSED,
	421	int length ATTRIBUTE_UNUSED)
	422	{
	423	disassemble_info info = (disassemble_info ) dis_info;
	424
0e6b69be	425	info->fprintf_func (info->stream, "$%lx", value);
b081650b DB	426
	427	if (0)
	428	print_normal (cd, dis_info, value, attrs, pc, length);
	429	}
	430
	431
	432	/* -- */
	433
	434
	435
	436
	437