[deliverable/binutils-gdb.git] / opcodes / openrisc-asm.c

/* Assembler interface for targets using CGEN. -*- C -*-
   CGEN: Cpu tools GENerator

   THIS FILE IS MACHINE GENERATED WITH CGEN.
   - the resultant file is machine generated, cgen-asm.in isn't

   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2005
   Free Software Foundation, Inc.

   This file is part of the GNU Binutils and GDB, the GNU debugger.

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

/* ??? Eventually more and more of this stuff can go to cpu-independent files.
   Keep that in mind.  */

#include "sysdep.h"
#include <stdio.h>
#include "ansidecl.h"
#include "bfd.h"
#include "symcat.h"
#include "openrisc-desc.h"
#include "openrisc-opc.h"
#include "opintl.h"
#include "xregex.h"
#include "libiberty.h"
#include "safe-ctype.h"

#undef  min
#define min(a,b) ((a) < (b) ? (a) : (b))
#undef  max
#define max(a,b) ((a) > (b) ? (a) : (b))

static const char * parse_insn_normal
  (CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *);
\f
/* -- assembler routines inserted here.  */

/* -- asm.c */

static const char * MISSING_CLOSING_PARENTHESIS = N_("missing `)'");

#define CGEN_VERBOSE_ASSEMBLER_ERRORS

long
openrisc_sign_extend_16bit (long value)
{
  return ((value & 0xffff) ^ 0x8000) - 0x8000;
}

/* Handle hi().  */

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

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

  if (strncasecmp (*strp, "hi(", 3) == 0)
    {
      bfd_vma value;

      *strp += 3;
      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_HI16,
				   & result_type, & value);
      if (**strp != ')')
        return MISSING_CLOSING_PARENTHESIS;

      ++*strp;
      if (errmsg == NULL
          && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
        value >>= 16;
      ret = value;
    }
  else
    {
      if (**strp == '-')
	{
	  long value;

	  errmsg = cgen_parse_signed_integer (cd, strp, opindex, &value);
	  ret = value;
	}
      else
	{
	  unsigned long value;

	  errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, &value);
	  ret = value;
	}
    }

  *valuep = ((ret & 0xffff) ^ 0x8000) - 0x8000;
  return errmsg;
}

/* Handle lo().  */

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

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

  if (strncasecmp (*strp, "lo(", 3) == 0)
    {
      bfd_vma value;

      *strp += 3;
      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_LO16,
				   & result_type, & value);
      if (**strp != ')')
        return MISSING_CLOSING_PARENTHESIS;

      ++*strp;
      ret = value;
    }
  else
    {
      if (**strp == '-')
	{
	  long value;

	  errmsg = cgen_parse_signed_integer (cd, strp, opindex, &value);
	  ret = value;
	}
      else
	{
	  unsigned long value;

	  errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, &value);
	  ret = value;
	}
    }

  *valuep = ((ret & 0xffff) ^ 0x8000) - 0x8000;
  return errmsg;
}

/* -- */

const char * openrisc_cgen_parse_operand
  (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);

/* Main entry point for operand parsing.

   This function is basically just a big switch statement.  Earlier versions
   used tables to look up the function to use, but
   - if the table contains both assembler and disassembler functions then
     the disassembler contains much of the assembler and vice-versa,
   - there's a lot of inlining possibilities as things grow,
   - using a switch statement avoids the function call overhead.

   This function could be moved into `parse_insn_normal', but keeping it
   separate makes clear the interface between `parse_insn_normal' and each of
   the handlers.  */

const char *
openrisc_cgen_parse_operand (CGEN_CPU_DESC cd,
			   int opindex,
			   const char ** strp,
			   CGEN_FIELDS * fields)
{
  const char * errmsg = NULL;
  /* Used by scalar operands that still need to be parsed.  */
  long junk ATTRIBUTE_UNUSED;

  switch (opindex)
    {
    case OPENRISC_OPERAND_ABS_26 :
      {
        bfd_vma value = 0;
        errmsg = cgen_parse_address (cd, strp, OPENRISC_OPERAND_ABS_26, 0, NULL,  & value);
        fields->f_abs26 = value;
      }
      break;
    case OPENRISC_OPERAND_DISP_26 :
      {
        bfd_vma value = 0;
        errmsg = cgen_parse_address (cd, strp, OPENRISC_OPERAND_DISP_26, 0, NULL,  & value);
        fields->f_disp26 = value;
      }
      break;
    case OPENRISC_OPERAND_HI16 :
      errmsg = parse_hi16 (cd, strp, OPENRISC_OPERAND_HI16, (long *) (& fields->f_simm16));
      break;
    case OPENRISC_OPERAND_LO16 :
      errmsg = parse_lo16 (cd, strp, OPENRISC_OPERAND_LO16, (long *) (& fields->f_lo16));
      break;
    case OPENRISC_OPERAND_OP_F_23 :
      errmsg = cgen_parse_unsigned_integer (cd, strp, OPENRISC_OPERAND_OP_F_23, (unsigned long *) (& fields->f_op4));
      break;
    case OPENRISC_OPERAND_OP_F_3 :
      errmsg = cgen_parse_unsigned_integer (cd, strp, OPENRISC_OPERAND_OP_F_3, (unsigned long *) (& fields->f_op5));
      break;
    case OPENRISC_OPERAND_RA :
      errmsg = cgen_parse_keyword (cd, strp, & openrisc_cgen_opval_h_gr, & fields->f_r2);
      break;
    case OPENRISC_OPERAND_RB :
      errmsg = cgen_parse_keyword (cd, strp, & openrisc_cgen_opval_h_gr, & fields->f_r3);
      break;
    case OPENRISC_OPERAND_RD :
      errmsg = cgen_parse_keyword (cd, strp, & openrisc_cgen_opval_h_gr, & fields->f_r1);
      break;
    case OPENRISC_OPERAND_SIMM_16 :
      errmsg = cgen_parse_signed_integer (cd, strp, OPENRISC_OPERAND_SIMM_16, (long *) (& fields->f_simm16));
      break;
    case OPENRISC_OPERAND_UI16NC :
      errmsg = parse_lo16 (cd, strp, OPENRISC_OPERAND_UI16NC, (long *) (& fields->f_i16nc));
      break;
    case OPENRISC_OPERAND_UIMM_16 :
      errmsg = cgen_parse_unsigned_integer (cd, strp, OPENRISC_OPERAND_UIMM_16, (unsigned long *) (& fields->f_uimm16));
      break;
    case OPENRISC_OPERAND_UIMM_5 :
      errmsg = cgen_parse_unsigned_integer (cd, strp, OPENRISC_OPERAND_UIMM_5, (unsigned long *) (& fields->f_uimm5));
      break;

    default :
      /* xgettext:c-format */
      fprintf (stderr, _("Unrecognized field %d while parsing.\n"), opindex);
      abort ();
  }

  return errmsg;
}

cgen_parse_fn * const openrisc_cgen_parse_handlers[] = 
{
  parse_insn_normal,
};

void
openrisc_cgen_init_asm (CGEN_CPU_DESC cd)
{
  openrisc_cgen_init_opcode_table (cd);
  openrisc_cgen_init_ibld_table (cd);
  cd->parse_handlers = & openrisc_cgen_parse_handlers[0];
  cd->parse_operand = openrisc_cgen_parse_operand;
#ifdef CGEN_ASM_INIT_HOOK
CGEN_ASM_INIT_HOOK
#endif
}

\f

/* Regex construction routine.

   This translates an opcode syntax string into a regex string,
   by replacing any non-character syntax element (such as an
   opcode) with the pattern '.*'

   It then compiles the regex and stores it in the opcode, for
   later use by openrisc_cgen_assemble_insn

   Returns NULL for success, an error message for failure.  */

char * 
openrisc_cgen_build_insn_regex (CGEN_INSN *insn)
{  
  CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
  const char *mnem = CGEN_INSN_MNEMONIC (insn);
  char rxbuf[CGEN_MAX_RX_ELEMENTS];
  char *rx = rxbuf;
  const CGEN_SYNTAX_CHAR_TYPE *syn;
  int reg_err;

  syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));

  /* Mnemonics come first in the syntax string.  */
  if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
    return _("missing mnemonic in syntax string");
  ++syn;

  /* Generate a case sensitive regular expression that emulates case
     insensitive matching in the "C" locale.  We cannot generate a case
     insensitive regular expression because in Turkish locales, 'i' and 'I'
     are not equal modulo case conversion.  */

  /* Copy the literal mnemonic out of the insn.  */
  for (; *mnem; mnem++)
    {
      char c = *mnem;

      if (ISALPHA (c))
	{
	  *rx++ = '[';
	  *rx++ = TOLOWER (c);
	  *rx++ = TOUPPER (c);
	  *rx++ = ']';
	}
      else
	*rx++ = c;
    }

  /* Copy any remaining literals from the syntax string into the rx.  */
  for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
    {
      if (CGEN_SYNTAX_CHAR_P (* syn)) 
	{
	  char c = CGEN_SYNTAX_CHAR (* syn);

	  switch (c) 
	    {
	      /* Escape any regex metacharacters in the syntax.  */
	    case '.': case '[': case '\\': 
	    case '*': case '^': case '$': 

#ifdef CGEN_ESCAPE_EXTENDED_REGEX
	    case '?': case '{': case '}': 
	    case '(': case ')': case '*':
	    case '|': case '+': case ']':
#endif
	      *rx++ = '\\';
	      *rx++ = c;
	      break;

	    default:
	      if (ISALPHA (c))
		{
		  *rx++ = '[';
		  *rx++ = TOLOWER (c);
		  *rx++ = TOUPPER (c);
		  *rx++ = ']';
		}
	      else
		*rx++ = c;
	      break;
	    }
	}
      else
	{
	  /* Replace non-syntax fields with globs.  */
	  *rx++ = '.';
	  *rx++ = '*';
	}
    }

  /* Trailing whitespace ok.  */
  * rx++ = '['; 
  * rx++ = ' '; 
  * rx++ = '\t'; 
  * rx++ = ']'; 
  * rx++ = '*'; 

  /* But anchor it after that.  */
  * rx++ = '$'; 
  * rx = '\0';

  CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
  reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);

  if (reg_err == 0) 
    return NULL;
  else
    {
      static char msg[80];

      regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
      regfree ((regex_t *) CGEN_INSN_RX (insn));
      free (CGEN_INSN_RX (insn));
      (CGEN_INSN_RX (insn)) = NULL;
      return msg;
    }
}

\f
/* Default insn parser.

   The syntax string is scanned and operands are parsed and stored in FIELDS.
   Relocs are queued as we go via other callbacks.

   ??? Note that this is currently an all-or-nothing parser.  If we fail to
   parse the instruction, we return 0 and the caller will start over from
   the beginning.  Backtracking will be necessary in parsing subexpressions,
   but that can be handled there.  Not handling backtracking here may get
   expensive in the case of the m68k.  Deal with later.

   Returns NULL for success, an error message for failure.  */

static const char *
parse_insn_normal (CGEN_CPU_DESC cd,
		   const CGEN_INSN *insn,
		   const char **strp,
		   CGEN_FIELDS *fields)
{
  /* ??? Runtime added insns not handled yet.  */
  const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
  const char *str = *strp;
  const char *errmsg;
  const char *p;
  const CGEN_SYNTAX_CHAR_TYPE * syn;
#ifdef CGEN_MNEMONIC_OPERANDS
  /* FIXME: wip */
  int past_opcode_p;
#endif

  /* For now we assume the mnemonic is first (there are no leading operands).
     We can parse it without needing to set up operand parsing.
     GAS's input scrubber will ensure mnemonics are lowercase, but we may
     not be called from GAS.  */
  p = CGEN_INSN_MNEMONIC (insn);
  while (*p && TOLOWER (*p) == TOLOWER (*str))
    ++p, ++str;

  if (* p)
    return _("unrecognized instruction");

#ifndef CGEN_MNEMONIC_OPERANDS
  if (* str && ! ISSPACE (* str))
    return _("unrecognized instruction");
#endif

  CGEN_INIT_PARSE (cd);
  cgen_init_parse_operand (cd);
#ifdef CGEN_MNEMONIC_OPERANDS
  past_opcode_p = 0;
#endif

  /* We don't check for (*str != '\0') here because we want to parse
     any trailing fake arguments in the syntax string.  */
  syn = CGEN_SYNTAX_STRING (syntax);

  /* Mnemonics come first for now, ensure valid string.  */
  if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
    abort ();

  ++syn;

  while (* syn != 0)
    {
      /* Non operand chars must match exactly.  */
      if (CGEN_SYNTAX_CHAR_P (* syn))
	{
	  /* FIXME: While we allow for non-GAS callers above, we assume the
	     first char after the mnemonic part is a space.  */
	  /* FIXME: We also take inappropriate advantage of the fact that
	     GAS's input scrubber will remove extraneous blanks.  */
	  if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
	    {
#ifdef CGEN_MNEMONIC_OPERANDS
	      if (CGEN_SYNTAX_CHAR(* syn) == ' ')
		past_opcode_p = 1;
#endif
	      ++ syn;
	      ++ str;
	    }
	  else if (*str)
	    {
	      /* Syntax char didn't match.  Can't be this insn.  */
	      static char msg [80];

	      /* xgettext:c-format */
	      sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
		       CGEN_SYNTAX_CHAR(*syn), *str);
	      return msg;
	    }
	  else
	    {
	      /* Ran out of input.  */
	      static char msg [80];

	      /* xgettext:c-format */
	      sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
		       CGEN_SYNTAX_CHAR(*syn));
	      return msg;
	    }
	  continue;
	}

      /* We have an operand of some sort.  */
      errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn),
					  &str, fields);
      if (errmsg)
	return errmsg;

      /* Done with this operand, continue with next one.  */
      ++ syn;
    }

  /* If we're at the end of the syntax string, we're done.  */
  if (* syn == 0)
    {
      /* FIXME: For the moment we assume a valid `str' can only contain
	 blanks now.  IE: We needn't try again with a longer version of
	 the insn and it is assumed that longer versions of insns appear
	 before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3).  */
      while (ISSPACE (* str))
	++ str;

      if (* str != '\0')
	return _("junk at end of line"); /* FIXME: would like to include `str' */

      return NULL;
    }

  /* We couldn't parse it.  */
  return _("unrecognized instruction");
}
\f
/* Main entry point.
   This routine is called for each instruction to be assembled.
   STR points to the insn to be assembled.
   We assume all necessary tables have been initialized.
   The assembled instruction, less any fixups, is stored in BUF.
   Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
   still needs to be converted to target byte order, otherwise BUF is an array
   of bytes in target byte order.
   The result is a pointer to the insn's entry in the opcode table,
   or NULL if an error occured (an error message will have already been
   printed).

   Note that when processing (non-alias) macro-insns,
   this function recurses.

   ??? It's possible to make this cpu-independent.
   One would have to deal with a few minor things.
   At this point in time doing so would be more of a curiosity than useful
   [for example this file isn't _that_ big], but keeping the possibility in
   mind helps keep the design clean.  */

const CGEN_INSN *
openrisc_cgen_assemble_insn (CGEN_CPU_DESC cd,
			   const char *str,
			   CGEN_FIELDS *fields,
			   CGEN_INSN_BYTES_PTR buf,
			   char **errmsg)
{
  const char *start;
  CGEN_INSN_LIST *ilist;
  const char *parse_errmsg = NULL;
  const char *insert_errmsg = NULL;
  int recognized_mnemonic = 0;

  /* Skip leading white space.  */
  while (ISSPACE (* str))
    ++ str;

  /* The instructions are stored in hashed lists.
     Get the first in the list.  */
  ilist = CGEN_ASM_LOOKUP_INSN (cd, str);

  /* Keep looking until we find a match.  */
  start = str;
  for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
    {
      const CGEN_INSN *insn = ilist->insn;
      recognized_mnemonic = 1;

#ifdef CGEN_VALIDATE_INSN_SUPPORTED 
      /* Not usually needed as unsupported opcodes
	 shouldn't be in the hash lists.  */
      /* Is this insn supported by the selected cpu?  */
      if (! openrisc_cgen_insn_supported (cd, insn))
	continue;
#endif
      /* If the RELAXED attribute is set, this is an insn that shouldn't be
	 chosen immediately.  Instead, it is used during assembler/linker
	 relaxation if possible.  */
      if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
	continue;

      str = start;

      /* Skip this insn if str doesn't look right lexically.  */
      if (CGEN_INSN_RX (insn) != NULL &&
	  regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
	continue;

      /* Allow parse/insert handlers to obtain length of insn.  */
      CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);

      parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
      if (parse_errmsg != NULL)
	continue;

      /* ??? 0 is passed for `pc'.  */
      insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
						 (bfd_vma) 0);
      if (insert_errmsg != NULL)
        continue;

      /* It is up to the caller to actually output the insn and any
         queued relocs.  */
      return insn;
    }

  {
    static char errbuf[150];
#ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
    const char *tmp_errmsg;

    /* If requesting verbose error messages, use insert_errmsg.
       Failing that, use parse_errmsg.  */
    tmp_errmsg = (insert_errmsg ? insert_errmsg :
		  parse_errmsg ? parse_errmsg :
		  recognized_mnemonic ?
		  _("unrecognized form of instruction") :
		  _("unrecognized instruction"));

    if (strlen (start) > 50)
      /* xgettext:c-format */
      sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
    else 
      /* xgettext:c-format */
      sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
#else
    if (strlen (start) > 50)
      /* xgettext:c-format */
      sprintf (errbuf, _("bad instruction `%.50s...'"), start);
    else 
      /* xgettext:c-format */
      sprintf (errbuf, _("bad instruction `%.50s'"), start);
#endif
      
    *errmsg = errbuf;
    return NULL;
  }
}
Commit	Line	Data
87e6d782 NC	1	/* Assembler interface for targets using CGEN. -- C --
	2	CGEN: Cpu tools GENerator
	3
47b0e7ad NC	4	THIS FILE IS MACHINE GENERATED WITH CGEN.
47b0e7ad NC	5	- the resultant file is machine generated, cgen-asm.in isn't
87e6d782	6
47b0e7ad NC	7	Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2005
47b0e7ad NC	8	Free Software Foundation, Inc.
87e6d782	9
47b0e7ad	10	This file is part of the GNU Binutils and GDB, the GNU debugger.
87e6d782	11
47b0e7ad NC	12	This program is free software; you can redistribute it and/or modify
	13	it under the terms of the GNU General Public License as published by
	14	the Free Software Foundation; either version 2, or (at your option)
	15	any later version.
87e6d782	16
47b0e7ad NC	17	This program is distributed in the hope that it will be useful,
	18	but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	20	GNU General Public License for more details.
87e6d782	21
47b0e7ad NC	22	You should have received a copy of the GNU General Public License
	23	along with this program; if not, write to the Free Software Foundation, Inc.,
	24	51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
87e6d782 NC	25
	26	/* ??? Eventually more and more of this stuff can go to cpu-independent files.
	27	Keep that in mind. */
	28
	29	#include "sysdep.h"
87e6d782 NC	30	#include <stdio.h>
	31	#include "ansidecl.h"
	32	#include "bfd.h"
	33	#include "symcat.h"
	34	#include "openrisc-desc.h"
	35	#include "openrisc-opc.h"
	36	#include "opintl.h"
fc7bc883	37	#include "xregex.h"
fc05c67f	38	#include "libiberty.h"
37111cc7	39	#include "safe-ctype.h"
87e6d782	40
37111cc7	41	#undef min
87e6d782	42	#define min(a,b) ((a) < (b) ? (a) : (b))
37111cc7	43	#undef max
87e6d782 NC	44	#define max(a,b) ((a) > (b) ? (a) : (b))
	45
	46	static const char * parse_insn_normal
ffead7ae	47	(CGEN_CPU_DESC, const CGEN_INSN , const char , CGEN_FIELDS );
87e6d782	48	\f
37111cc7	49	/* -- assembler routines inserted here. */
87e6d782 NC	50
	51	/* -- asm.c */
	52
47b0e7ad	53	static const char * MISSING_CLOSING_PARENTHESIS = N_("missing `)'");
87e6d782	54
47b0e7ad	55	#define CGEN_VERBOSE_ASSEMBLER_ERRORS
0e2ee3ca	56
87e6d782	57	long
47b0e7ad	58	openrisc_sign_extend_16bit (long value)
87e6d782	59	{
8f807746	60	return ((value & 0xffff) ^ 0x8000) - 0x8000;
87e6d782 NC	61	}
87e6d782 NC	62
87e6d782 NC	63	/* Handle hi(). */
	64
	65	static const char *
47b0e7ad	66	parse_hi16 (CGEN_CPU_DESC cd, const char ** strp, int opindex, long * valuep)
87e6d782 NC	67	{
	68	const char *errmsg;
	69	enum cgen_parse_operand_result result_type;
8f807746	70	unsigned long ret;
87e6d782 NC	71
	72	if (**strp == '#')
	73	++*strp;
	74
	75	if (strncasecmp (*strp, "hi(", 3) == 0)
	76	{
8f807746	77	bfd_vma value;
87e6d782	78
8f807746	79	*strp += 3;
33b71eeb	80	errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_HI16,
47b0e7ad	81	& result_type, & value);
87e6d782	82	if (**strp != ')')
47b0e7ad	83	return MISSING_CLOSING_PARENTHESIS;
8f807746	84
87e6d782 NC	85	++*strp;
	86	if (errmsg == NULL
	87	&& result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
	88	value >>= 16;
8f807746	89	ret = value;
87e6d782 NC	90	}
	91	else
	92	{
	93	if (**strp == '-')
8f807746 AM	94	{
8f807746 AM	95	long value;
33b71eeb	96
8f807746 AM	97	errmsg = cgen_parse_signed_integer (cd, strp, opindex, &value);
	98	ret = value;
	99	}
87e6d782	100	else
8f807746 AM	101	{
8f807746 AM	102	unsigned long value;
33b71eeb	103
8f807746 AM	104	errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, &value);
	105	ret = value;
	106	}
87e6d782	107	}
8f807746 AM	108
8f807746 AM	109	*valuep = ((ret & 0xffff) ^ 0x8000) - 0x8000;
87e6d782 NC	110	return errmsg;
	111	}
	112
0e2ee3ca	113	/* Handle lo(). */
87e6d782 NC	114
87e6d782 NC	115	static const char *
47b0e7ad	116	parse_lo16 (CGEN_CPU_DESC cd, const char ** strp, int opindex, long * valuep)
87e6d782 NC	117	{
	118	const char *errmsg;
	119	enum cgen_parse_operand_result result_type;
8f807746	120	unsigned long ret;
87e6d782 NC	121
	122	if (**strp == '#')
	123	++*strp;
	124
	125	if (strncasecmp (*strp, "lo(", 3) == 0)
	126	{
8f807746	127	bfd_vma value;
87e6d782	128
8f807746	129	*strp += 3;
33b71eeb	130	errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_LO16,
47b0e7ad	131	& result_type, & value);
87e6d782	132	if (**strp != ')')
47b0e7ad	133	return MISSING_CLOSING_PARENTHESIS;
87e6d782	134
8f807746 AM	135	++*strp;
8f807746 AM	136	ret = value;
87e6d782	137	}
87e6d782	138	else
8f807746 AM	139	{
	140	if (**strp == '-')
	141	{
	142	long value;
33b71eeb	143
8f807746 AM	144	errmsg = cgen_parse_signed_integer (cd, strp, opindex, &value);
	145	ret = value;
	146	}
	147	else
	148	{
	149	unsigned long value;
33b71eeb	150
8f807746 AM	151	errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, &value);
	152	ret = value;
	153	}
	154	}
	155
	156	*valuep = ((ret & 0xffff) ^ 0x8000) - 0x8000;
87e6d782 NC	157	return errmsg;
	158	}
	159
	160	/* -- */
	161
0e2ee3ca	162	const char * openrisc_cgen_parse_operand
47b0e7ad	163	(CGEN_CPU_DESC, int, const char *, CGEN_FIELDS );
0e2ee3ca	164
87e6d782 NC	165	/* Main entry point for operand parsing.
	166
	167	This function is basically just a big switch statement. Earlier versions
	168	used tables to look up the function to use, but
	169	- if the table contains both assembler and disassembler functions then
	170	the disassembler contains much of the assembler and vice-versa,
	171	- there's a lot of inlining possibilities as things grow,
	172	- using a switch statement avoids the function call overhead.
	173
	174	This function could be moved into `parse_insn_normal', but keeping it
	175	separate makes clear the interface between `parse_insn_normal' and each of
9a2e995d	176	the handlers. */
87e6d782 NC	177
87e6d782 NC	178	const char *
47b0e7ad NC	179	openrisc_cgen_parse_operand (CGEN_CPU_DESC cd,
	180	int opindex,
	181	const char ** strp,
	182	CGEN_FIELDS * fields)
87e6d782 NC	183	{
	184	const char * errmsg = NULL;
	185	/* Used by scalar operands that still need to be parsed. */
fc05c67f	186	long junk ATTRIBUTE_UNUSED;
87e6d782 NC	187
	188	switch (opindex)
	189	{
	190	case OPENRISC_OPERAND_ABS_26 :
	191	{
9494d739	192	bfd_vma value = 0;
87e6d782 NC	193	errmsg = cgen_parse_address (cd, strp, OPENRISC_OPERAND_ABS_26, 0, NULL, & value);
	194	fields->f_abs26 = value;
	195	}
	196	break;
	197	case OPENRISC_OPERAND_DISP_26 :
	198	{
9494d739	199	bfd_vma value = 0;
87e6d782 NC	200	errmsg = cgen_parse_address (cd, strp, OPENRISC_OPERAND_DISP_26, 0, NULL, & value);
	201	fields->f_disp26 = value;
	202	}
	203	break;
	204	case OPENRISC_OPERAND_HI16 :
33b71eeb	205	errmsg = parse_hi16 (cd, strp, OPENRISC_OPERAND_HI16, (long *) (& fields->f_simm16));
87e6d782 NC	206	break;
87e6d782 NC	207	case OPENRISC_OPERAND_LO16 :
33b71eeb	208	errmsg = parse_lo16 (cd, strp, OPENRISC_OPERAND_LO16, (long *) (& fields->f_lo16));
87e6d782 NC	209	break;
87e6d782 NC	210	case OPENRISC_OPERAND_OP_F_23 :
33b71eeb	211	errmsg = cgen_parse_unsigned_integer (cd, strp, OPENRISC_OPERAND_OP_F_23, (unsigned long *) (& fields->f_op4));
87e6d782 NC	212	break;
87e6d782 NC	213	case OPENRISC_OPERAND_OP_F_3 :
33b71eeb	214	errmsg = cgen_parse_unsigned_integer (cd, strp, OPENRISC_OPERAND_OP_F_3, (unsigned long *) (& fields->f_op5));
87e6d782 NC	215	break;
	216	case OPENRISC_OPERAND_RA :
	217	errmsg = cgen_parse_keyword (cd, strp, & openrisc_cgen_opval_h_gr, & fields->f_r2);
	218	break;
	219	case OPENRISC_OPERAND_RB :
	220	errmsg = cgen_parse_keyword (cd, strp, & openrisc_cgen_opval_h_gr, & fields->f_r3);
	221	break;
	222	case OPENRISC_OPERAND_RD :
	223	errmsg = cgen_parse_keyword (cd, strp, & openrisc_cgen_opval_h_gr, & fields->f_r1);
	224	break;
	225	case OPENRISC_OPERAND_SIMM_16 :
33b71eeb	226	errmsg = cgen_parse_signed_integer (cd, strp, OPENRISC_OPERAND_SIMM_16, (long *) (& fields->f_simm16));
87e6d782 NC	227	break;
87e6d782 NC	228	case OPENRISC_OPERAND_UI16NC :
33b71eeb	229	errmsg = parse_lo16 (cd, strp, OPENRISC_OPERAND_UI16NC, (long *) (& fields->f_i16nc));
87e6d782 NC	230	break;
87e6d782 NC	231	case OPENRISC_OPERAND_UIMM_16 :
33b71eeb	232	errmsg = cgen_parse_unsigned_integer (cd, strp, OPENRISC_OPERAND_UIMM_16, (unsigned long *) (& fields->f_uimm16));
87e6d782 NC	233	break;
87e6d782 NC	234	case OPENRISC_OPERAND_UIMM_5 :
33b71eeb	235	errmsg = cgen_parse_unsigned_integer (cd, strp, OPENRISC_OPERAND_UIMM_5, (unsigned long *) (& fields->f_uimm5));
87e6d782 NC	236	break;
	237
	238	default :
	239	/* xgettext:c-format */
	240	fprintf (stderr, _("Unrecognized field %d while parsing.\n"), opindex);
	241	abort ();
	242	}
	243
	244	return errmsg;
	245	}
	246
	247	cgen_parse_fn * const openrisc_cgen_parse_handlers[] =
	248	{
	249	parse_insn_normal,
	250	};
	251
	252	void
47b0e7ad	253	openrisc_cgen_init_asm (CGEN_CPU_DESC cd)
87e6d782 NC	254	{
	255	openrisc_cgen_init_opcode_table (cd);
	256	openrisc_cgen_init_ibld_table (cd);
	257	cd->parse_handlers = & openrisc_cgen_parse_handlers[0];
	258	cd->parse_operand = openrisc_cgen_parse_operand;
1620f33d AM	259	#ifdef CGEN_ASM_INIT_HOOK
	260	CGEN_ASM_INIT_HOOK
	261	#endif
87e6d782 NC	262	}
87e6d782 NC	263
fc7bc883 RH	264	\f
fc7bc883 RH	265
37111cc7	266	/* Regex construction routine.
fc7bc883	267
37111cc7 NC	268	This translates an opcode syntax string into a regex string,
	269	by replacing any non-character syntax element (such as an
	270	opcode) with the pattern '.*'
fc7bc883	271
37111cc7 NC	272	It then compiles the regex and stores it in the opcode, for
37111cc7 NC	273	later use by openrisc_cgen_assemble_insn
fc7bc883	274
37111cc7	275	Returns NULL for success, an error message for failure. */
fc7bc883 RH	276
fc7bc883 RH	277	char *
ffead7ae	278	openrisc_cgen_build_insn_regex (CGEN_INSN *insn)
fc7bc883	279	{
fc05c67f	280	CGEN_OPCODE opc = (CGEN_OPCODE ) CGEN_INSN_OPCODE (insn);
fc7bc883	281	const char *mnem = CGEN_INSN_MNEMONIC (insn);
fc7bc883 RH	282	char rxbuf[CGEN_MAX_RX_ELEMENTS];
	283	char *rx = rxbuf;
	284	const CGEN_SYNTAX_CHAR_TYPE *syn;
	285	int reg_err;
	286
	287	syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
	288
f3a55c17 NC	289	/* Mnemonics come first in the syntax string. */
	290	if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
	291	return _("missing mnemonic in syntax string");
fc7bc883 RH	292	++syn;
fc7bc883 RH	293
f3a55c17 NC	294	/* Generate a case sensitive regular expression that emulates case
	295	insensitive matching in the "C" locale. We cannot generate a case
	296	insensitive regular expression because in Turkish locales, 'i' and 'I'
	297	are not equal modulo case conversion. */
fc7bc883	298
f3a55c17 NC	299	/* Copy the literal mnemonic out of the insn. */
	300	for (; *mnem; mnem++)
	301	{
	302	char c = *mnem;
	303
	304	if (ISALPHA (c))
	305	{
	306	*rx++ = '[';
	307	*rx++ = TOLOWER (c);
	308	*rx++ = TOUPPER (c);
	309	*rx++ = ']';
	310	}
	311	else
	312	*rx++ = c;
	313	}
	314
	315	/* Copy any remaining literals from the syntax string into the rx. */
	316	for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
fc7bc883 RH	317	{
	318	if (CGEN_SYNTAX_CHAR_P (* syn))
	319	{
f3a55c17 NC	320	char c = CGEN_SYNTAX_CHAR (* syn);
	321
	322	switch (c)
	323	{
	324	/* Escape any regex metacharacters in the syntax. */
	325	case '.': case '[': case '\\':
	326	case '*': case '^': case '$':
fc7bc883 RH	327
fc7bc883 RH	328	#ifdef CGEN_ESCAPE_EXTENDED_REGEX
f3a55c17 NC	329	case '?': case '{': case '}':
	330	case '(': case ')': case '*':
	331	case '\|': case '+': case ']':
fc7bc883	332	#endif
f3a55c17 NC	333	*rx++ = '\\';
	334	*rx++ = c;
	335	break;
	336
	337	default:
	338	if (ISALPHA (c))
	339	{
	340	*rx++ = '[';
	341	*rx++ = TOLOWER (c);
	342	*rx++ = TOUPPER (c);
	343	*rx++ = ']';
	344	}
	345	else
	346	*rx++ = c;
	347	break;
	348	}
fc7bc883 RH	349	}
	350	else
	351	{
f3a55c17 NC	352	/* Replace non-syntax fields with globs. */
	353	*rx++ = '.';
	354	rx++ = '';
fc7bc883 RH	355	}
	356	}
	357
f3a55c17	358	/* Trailing whitespace ok. */
fc7bc883 RH	359	* rx++ = '[';
	360	* rx++ = ' ';
	361	* rx++ = '\t';
	362	* rx++ = ']';
	363	* rx++ = '*';
	364
f3a55c17	365	/* But anchor it after that. */
fc7bc883 RH	366	* rx++ = '$';
	367	* rx = '\0';
	368
	369	CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
f3a55c17	370	reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
fc7bc883 RH	371
	372	if (reg_err == 0)
	373	return NULL;
	374	else
	375	{
	376	static char msg[80];
f3a55c17	377
fc7bc883 RH	378	regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
	379	regfree ((regex_t *) CGEN_INSN_RX (insn));
	380	free (CGEN_INSN_RX (insn));
	381	(CGEN_INSN_RX (insn)) = NULL;
37111cc7	382	return msg;
fc7bc883 RH	383	}
	384	}
	385
87e6d782 NC	386	\f
	387	/* Default insn parser.
	388
	389	The syntax string is scanned and operands are parsed and stored in FIELDS.
	390	Relocs are queued as we go via other callbacks.
	391
	392	??? Note that this is currently an all-or-nothing parser. If we fail to
	393	parse the instruction, we return 0 and the caller will start over from
	394	the beginning. Backtracking will be necessary in parsing subexpressions,
	395	but that can be handled there. Not handling backtracking here may get
	396	expensive in the case of the m68k. Deal with later.
	397
f3a55c17	398	Returns NULL for success, an error message for failure. */
87e6d782 NC	399
87e6d782 NC	400	static const char *
ffead7ae MM	401	parse_insn_normal (CGEN_CPU_DESC cd,
	402	const CGEN_INSN *insn,
	403	const char **strp,
	404	CGEN_FIELDS *fields)
87e6d782 NC	405	{
	406	/* ??? Runtime added insns not handled yet. */
	407	const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
	408	const char str = strp;
	409	const char *errmsg;
	410	const char *p;
	411	const CGEN_SYNTAX_CHAR_TYPE * syn;
	412	#ifdef CGEN_MNEMONIC_OPERANDS
	413	/* FIXME: wip */
	414	int past_opcode_p;
	415	#endif
	416
	417	/* For now we assume the mnemonic is first (there are no leading operands).
	418	We can parse it without needing to set up operand parsing.
	419	GAS's input scrubber will ensure mnemonics are lowercase, but we may
	420	not be called from GAS. */
	421	p = CGEN_INSN_MNEMONIC (insn);
37111cc7	422	while (p && TOLOWER (p) == TOLOWER (*str))
87e6d782 NC	423	++p, ++str;
	424
	425	if (* p)
	426	return _("unrecognized instruction");
	427
	428	#ifndef CGEN_MNEMONIC_OPERANDS
37111cc7	429	if (* str && ! ISSPACE (* str))
87e6d782 NC	430	return _("unrecognized instruction");
	431	#endif
	432
	433	CGEN_INIT_PARSE (cd);
	434	cgen_init_parse_operand (cd);
	435	#ifdef CGEN_MNEMONIC_OPERANDS
	436	past_opcode_p = 0;
	437	#endif
	438
	439	/* We don't check for (*str != '\0') here because we want to parse
	440	any trailing fake arguments in the syntax string. */
	441	syn = CGEN_SYNTAX_STRING (syntax);
	442
	443	/* Mnemonics come first for now, ensure valid string. */
	444	if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
	445	abort ();
	446
	447	++syn;
	448
	449	while (* syn != 0)
	450	{
	451	/* Non operand chars must match exactly. */
	452	if (CGEN_SYNTAX_CHAR_P (* syn))
	453	{
	454	/* FIXME: While we allow for non-GAS callers above, we assume the
	455	first char after the mnemonic part is a space. */
	456	/* FIXME: We also take inappropriate advantage of the fact that
	457	GAS's input scrubber will remove extraneous blanks. */
37111cc7	458	if (TOLOWER (str) == TOLOWER (CGEN_SYNTAX_CHAR ( syn)))
87e6d782 NC	459	{
	460	#ifdef CGEN_MNEMONIC_OPERANDS
	461	if (CGEN_SYNTAX_CHAR(* syn) == ' ')
	462	past_opcode_p = 1;
	463	#endif
	464	++ syn;
	465	++ str;
	466	}
	467	else if (*str)
	468	{
	469	/* Syntax char didn't match. Can't be this insn. */
	470	static char msg [80];
f3a55c17	471
87e6d782 NC	472	/* xgettext:c-format */
	473	sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
	474	CGEN_SYNTAX_CHAR(syn), str);
	475	return msg;
	476	}
	477	else
	478	{
	479	/* Ran out of input. */
	480	static char msg [80];
f3a55c17	481
87e6d782 NC	482	/* xgettext:c-format */
	483	sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
	484	CGEN_SYNTAX_CHAR(*syn));
	485	return msg;
	486	}
	487	continue;
	488	}
	489
	490	/* We have an operand of some sort. */
a978a3e5	491	errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn),
87e6d782 NC	492	&str, fields);
	493	if (errmsg)
	494	return errmsg;
	495
	496	/* Done with this operand, continue with next one. */
	497	++ syn;
	498	}
	499
	500	/* If we're at the end of the syntax string, we're done. */
	501	if (* syn == 0)
	502	{
	503	/* FIXME: For the moment we assume a valid `str' can only contain
	504	blanks now. IE: We needn't try again with a longer version of
	505	the insn and it is assumed that longer versions of insns appear
	506	before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */
37111cc7	507	while (ISSPACE (* str))
87e6d782 NC	508	++ str;
	509
	510	if (* str != '\0')
	511	return _("junk at end of line"); /* FIXME: would like to include `str' */
	512
	513	return NULL;
	514	}
	515
	516	/* We couldn't parse it. */
	517	return _("unrecognized instruction");
	518	}
	519	\f
	520	/* Main entry point.
	521	This routine is called for each instruction to be assembled.
	522	STR points to the insn to be assembled.
	523	We assume all necessary tables have been initialized.
	524	The assembled instruction, less any fixups, is stored in BUF.
	525	Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
	526	still needs to be converted to target byte order, otherwise BUF is an array
	527	of bytes in target byte order.
	528	The result is a pointer to the insn's entry in the opcode table,
	529	or NULL if an error occured (an error message will have already been
	530	printed).
	531
	532	Note that when processing (non-alias) macro-insns,
	533	this function recurses.
	534
	535	??? It's possible to make this cpu-independent.
	536	One would have to deal with a few minor things.
	537	At this point in time doing so would be more of a curiosity than useful
	538	[for example this file isn't _that_ big], but keeping the possibility in
	539	mind helps keep the design clean. */
	540
	541	const CGEN_INSN *
ffead7ae MM	542	openrisc_cgen_assemble_insn (CGEN_CPU_DESC cd,
	543	const char *str,
	544	CGEN_FIELDS *fields,
	545	CGEN_INSN_BYTES_PTR buf,
	546	char **errmsg)
87e6d782 NC	547	{
	548	const char *start;
	549	CGEN_INSN_LIST *ilist;
	550	const char *parse_errmsg = NULL;
	551	const char *insert_errmsg = NULL;
fc7bc883	552	int recognized_mnemonic = 0;
87e6d782 NC	553
87e6d782 NC	554	/* Skip leading white space. */
37111cc7	555	while (ISSPACE (* str))
87e6d782 NC	556	++ str;
	557
	558	/* The instructions are stored in hashed lists.
	559	Get the first in the list. */
	560	ilist = CGEN_ASM_LOOKUP_INSN (cd, str);
	561
	562	/* Keep looking until we find a match. */
87e6d782 NC	563	start = str;
	564	for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
	565	{
	566	const CGEN_INSN *insn = ilist->insn;
fc7bc883	567	recognized_mnemonic = 1;
87e6d782 NC	568
87e6d782 NC	569	#ifdef CGEN_VALIDATE_INSN_SUPPORTED
f3a55c17 NC	570	/* Not usually needed as unsupported opcodes
f3a55c17 NC	571	shouldn't be in the hash lists. */
87e6d782 NC	572	/* Is this insn supported by the selected cpu? */
	573	if (! openrisc_cgen_insn_supported (cd, insn))
	574	continue;
	575	#endif
b11dcf4e	576	/* If the RELAXED attribute is set, this is an insn that shouldn't be
87e6d782 NC	577	chosen immediately. Instead, it is used during assembler/linker
87e6d782 NC	578	relaxation if possible. */
b11dcf4e	579	if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
87e6d782 NC	580	continue;
	581
	582	str = start;
	583
f3a55c17	584	/* Skip this insn if str doesn't look right lexically. */
fc7bc883 RH	585	if (CGEN_INSN_RX (insn) != NULL &&
	586	regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
	587	continue;
	588
87e6d782 NC	589	/* Allow parse/insert handlers to obtain length of insn. */
	590	CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
	591
	592	parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
	593	if (parse_errmsg != NULL)
	594	continue;
	595
f3a55c17	596	/* ??? 0 is passed for `pc'. */
87e6d782 NC	597	insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
	598	(bfd_vma) 0);
	599	if (insert_errmsg != NULL)
	600	continue;
	601
	602	/* It is up to the caller to actually output the insn and any
	603	queued relocs. */
	604	return insn;
	605	}
	606
	607	{
	608	static char errbuf[150];
	609	#ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
	610	const char *tmp_errmsg;
	611
	612	/* If requesting verbose error messages, use insert_errmsg.
f3a55c17	613	Failing that, use parse_errmsg. */
87e6d782 NC	614	tmp_errmsg = (insert_errmsg ? insert_errmsg :
87e6d782 NC	615	parse_errmsg ? parse_errmsg :
f3a55c17 NC	616	recognized_mnemonic ?
f3a55c17 NC	617	_("unrecognized form of instruction") :
87e6d782 NC	618	_("unrecognized instruction"));
	619
	620	if (strlen (start) > 50)
	621	/* xgettext:c-format */
	622	sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
	623	else
	624	/* xgettext:c-format */
	625	sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
	626	#else
	627	if (strlen (start) > 50)
	628	/* xgettext:c-format */
	629	sprintf (errbuf, _("bad instruction `%.50s...'"), start);
	630	else
	631	/* xgettext:c-format */
	632	sprintf (errbuf, _("bad instruction `%.50s'"), start);
	633	#endif
	634
	635	*errmsg = errbuf;
	636	return NULL;
	637	}
	638	}