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

/* Morpho Technologies mRISC opcode support, for GNU Binutils.  -*- C -*-
   Copyright 2001, 2007, 2008, 2009 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 3 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) mt_asm_hash (insn)

extern unsigned int mt_asm_hash (const char *);

extern int mt_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
mt_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
mt_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_loopsize (CGEN_CPU_DESC cd,
		const char **strp,
		int opindex,
		void *arg)
{
  signed long * valuep = (signed long *) arg;
  const char *errmsg;
  bfd_reloc_code_real_type code = BFD_RELOC_NONE;
  enum cgen_parse_operand_result result_type;
  bfd_vma value;

  /* Is it a control transfer instructions?  */ 
  if (opindex == (CGEN_OPERAND_TYPE) MT_OPERAND_LOOPSIZE)
    {
      code = BFD_RELOC_MT_PCINSN8;
      errmsg = cgen_parse_address (cd, strp, opindex, code,
                                   & result_type, & value);
      *valuep = value;
      return errmsg;
    }

  abort ();
}

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) MT_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 (opindex == (CGEN_OPERAND_TYPE) MT_OPERAND_IMM16L)
    ;
  else 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 = _("The percent-operator's 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)MT_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  
	{
          /* MT_OPERAND_IMM16Z.  Parse as an unsigned integer.  */
          errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, (unsigned long *) valuep);

	  if (opindex == (CGEN_OPERAND_TYPE) MT_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_pcrel (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);
}

static void
print_pcrel (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)
{
  print_address (cd, dis_info, value + pc, attrs, pc, length);
}

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