source: branches/GNU/src/binutils/opcodes/openrisc-asm.c@ 608

/* 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
     PARAMS ((CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *));


/* -- 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 (long) (short) value;
}

/* 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;
  bfd_vma value;

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

  if (strncasecmp (*strp, "hi(", 3) == 0)
    {
      *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;
      *valuep = (long) (short) value;

      return errmsg;
    }
  else
    {
      if (**strp == '-')
        errmsg = cgen_parse_signed_integer (cd, strp, opindex, (long *) &value);
      else
        errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, (unsigned long *) &value);
    }
  *valuep = (long) (short) (value & 0xffff);
  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;
  bfd_vma value;

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

  if (strncasecmp (*strp, "lo(", 3) == 0)
    {
      *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;
      if (errmsg == NULL
          && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
        value &= 0xffff;
      *valuep = (long) (short) value;

      return errmsg;
    }

  if (**strp == '-')
    errmsg = cgen_parse_signed_integer (cd, strp, opindex, (long *) &value);
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, (unsigned long *) &value);
  *valuep = (long) (short) (value & 0xffff);
  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;
}




/* 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 (insn)
     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;
    }
}



/* Default insn parser.