[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 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.,
59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 */

#define CGEN_VERBOSE_ASSEMBLER_ERRORS

static const char * parse_hi16
  PARAMS ((CGEN_CPU_DESC, const char **, int, unsigned long *));
static const char * parse_lo16
  PARAMS ((CGEN_CPU_DESC, const char **, int, unsigned long *));

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

/* Handle hi().  */

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;
  unsigned long ret;

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

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

      *strp += 3;
#if 0
      errmsg = cgen_parse_signed_integer (cd, strp, opindex, valuep);
      if (errmsg != NULL)
        fprintf (stderr, "parse_hi: %s\n", errmsg);
      if (errmsg != NULL)
#endif
        errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_HI16,
                                     &result_type, &value);
      if (**strp != ')')
        return _("missing `)'");

      ++*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 (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;
  unsigned long ret;

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

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

      *strp += 3;
#if 0 
      errmsg = cgen_parse_signed_integer (cd, strp, opindex, valuep);
      if (errmsg != NULL)
        fprintf (stderr, "parse_lo: %s\n", errmsg);

      if (errmsg != NULL)
#endif
        errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_LO16,
                                     &result_type, &value);
      if (**strp != ')')
        return _("missing `)'");

      ++*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
  PARAMS ((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 (cd, opindex, strp, fields)
     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;
        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;
        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, &fields->f_simm16);
      break;
    case OPENRISC_OPERAND_LO16 :
      errmsg = parse_lo16 (cd, strp, OPENRISC_OPERAND_LO16, &fields->f_lo16);
      break;
    case OPENRISC_OPERAND_OP_F_23 :
      errmsg = cgen_parse_unsigned_integer (cd, strp, OPENRISC_OPERAND_OP_F_23, &fields->f_op4);
      break;
    case OPENRISC_OPERAND_OP_F_3 :
      errmsg = cgen_parse_unsigned_integer (cd, strp, OPENRISC_OPERAND_OP_F_3, &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, &fields->f_simm16);
      break;
    case OPENRISC_OPERAND_UI16NC :
      errmsg = parse_lo16 (cd, strp, OPENRISC_OPERAND_UI16NC, &fields->f_i16nc);
      break;
    case OPENRISC_OPERAND_UIMM_16 :
      errmsg = cgen_parse_unsigned_integer (cd, strp, OPENRISC_OPERAND_UIMM_16, &fields->f_uimm16);
      break;
    case OPENRISC_OPERAND_UIMM_5 :
      errmsg = cgen_parse_unsigned_integer (cd, strp, OPENRISC_OPERAND_UIMM_5, &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 (cd)
     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;
}

\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;
  }
}
\f
#if 0 /* This calls back to GAS which we can't do without care.  */

/* Record each member of OPVALS in the assembler's symbol table.
   This lets GAS parse registers for us.
   ??? Interesting idea but not currently used.  */

/* Record each member of OPVALS in the assembler's symbol table.
   FIXME: Not currently used.  */

void
openrisc_cgen_asm_hash_keywords (CGEN_CPU_DESC cd, CGEN_KEYWORD *opvals)
{
  CGEN_KEYWORD_SEARCH search = cgen_keyword_search_init (opvals, NULL);
  const CGEN_KEYWORD_ENTRY * ke;

  while ((ke = cgen_keyword_search_next (& search)) != NULL)
    {
#if 0 /* Unnecessary, should be done in the search routine.  */
      if (! openrisc_cgen_opval_supported (ke))
	continue;
#endif
      cgen_asm_record_register (cd, ke->name, ke->value);
    }
}

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