Home | History | Annotate | Download | only in opcodes
      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 (C) 1996-2014 Free Software Foundation, Inc.
      8 
      9    This file is part of libopcodes.
     10 
     11    This library 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 3, or (at your option)
     14    any later version.
     15 
     16    It is distributed in the hope that it will be useful, but WITHOUT
     17    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
     18    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
     19    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    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
     24 
     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"
     30 #include <stdio.h>
     31 #include "ansidecl.h"
     32 #include "bfd.h"
     33 #include "symcat.h"
     34 #include "iq2000-desc.h"
     35 #include "iq2000-opc.h"
     36 #include "opintl.h"
     37 #include "xregex.h"
     38 #include "libiberty.h"
     39 #include "safe-ctype.h"
     40 
     41 #undef  min
     42 #define min(a,b) ((a) < (b) ? (a) : (b))
     43 #undef  max
     44 #define max(a,b) ((a) > (b) ? (a) : (b))
     45 
     46 static const char * parse_insn_normal
     47   (CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *);
     48 
     49 /* -- assembler routines inserted here.  */
     51 
     52 /* -- asm.c */
     53 
     54 #include "safe-ctype.h"
     55 
     56 static const char * MISSING_CLOSING_PARENTHESIS = N_("missing `)'");
     57 
     58 /* Special check to ensure that instruction exists for given machine.  */
     59 
     60 int
     61 iq2000_cgen_insn_supported (CGEN_CPU_DESC cd, const CGEN_INSN *insn)
     62 {
     63   int machs = cd->machs;
     64 
     65   return (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH) & machs) != 0;
     66 }
     67 
     68 static int
     69 iq2000_cgen_isa_register (const char **strp)
     70 {
     71   int len;
     72   int ch1, ch2;
     73 
     74   if (**strp == 'r' || **strp == 'R')
     75     {
     76       len = strlen (*strp);
     77       if (len == 2)
     78         {
     79           ch1 = (*strp)[1];
     80           if ('0' <= ch1 && ch1 <= '9')
     81             return 1;
     82         }
     83       else if (len == 3)
     84         {
     85 	  ch1 = (*strp)[1];
     86           ch2 = (*strp)[2];
     87           if (('1' <= ch1 && ch1 <= '2') && ('0' <= ch2 && ch2 <= '9'))
     88             return 1;
     89           if ('3' == ch1 && (ch2 == '0' || ch2 == '1'))
     90             return 1;
     91         }
     92     }
     93   if (**strp == '%'
     94       && TOLOWER ((*strp)[1]) != 'l'
     95       && TOLOWER ((*strp)[1]) != 'h')
     96     return 1;
     97   return 0;
     98 }
     99 
    100 /* Handle negated literal.  */
    101 
    102 static const char *
    103 parse_mimm (CGEN_CPU_DESC cd,
    104 	    const char **strp,
    105 	    int opindex,
    106 	    unsigned long *valuep)
    107 {
    108   const char *errmsg;
    109 
    110   /* Verify this isn't a register.  */
    111   if (iq2000_cgen_isa_register (strp))
    112     errmsg = _("immediate value cannot be register");
    113   else
    114     {
    115       long value;
    116 
    117       errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
    118       if (errmsg == NULL)
    119 	{
    120 	  long x = (-value) & 0xFFFF0000;
    121 
    122 	  if (x != 0 && x != (long) 0xFFFF0000)
    123 	    errmsg = _("immediate value out of range");
    124 	  else
    125 	    *valuep = (-value & 0xFFFF);
    126 	}
    127     }
    128   return errmsg;
    129 }
    130 
    131 /* Handle signed/unsigned literal.  */
    132 
    133 static const char *
    134 parse_imm (CGEN_CPU_DESC cd,
    135 	   const char **strp,
    136 	   int opindex,
    137 	   unsigned long *valuep)
    138 {
    139   const char *errmsg;
    140 
    141   if (iq2000_cgen_isa_register (strp))
    142     errmsg = _("immediate value cannot be register");
    143   else
    144     {
    145       long value;
    146 
    147       errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
    148       if (errmsg == NULL)
    149 	{
    150 	  long x = value & 0xFFFF0000;
    151 
    152 	  if (x != 0 && x != (long) 0xFFFF0000)
    153 	    errmsg = _("immediate value out of range");
    154 	  else
    155 	    *valuep = (value & 0xFFFF);
    156 	}
    157     }
    158   return errmsg;
    159 }
    160 
    161 /* Handle iq10 21-bit jmp offset.  */
    162 
    163 static const char *
    164 parse_jtargq10 (CGEN_CPU_DESC cd,
    165 		const char **strp,
    166 		int opindex,
    167 		int reloc ATTRIBUTE_UNUSED,
    168 		enum cgen_parse_operand_result *type_addr ATTRIBUTE_UNUSED,
    169 		bfd_vma *valuep)
    170 {
    171   const char *errmsg;
    172   bfd_vma value;
    173   enum cgen_parse_operand_result result_type = CGEN_PARSE_OPERAND_RESULT_NUMBER;
    174 
    175   errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_IQ2000_OFFSET_21,
    176 			       & result_type, & value);
    177   if (errmsg == NULL && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
    178     {
    179       /* Check value is within 23-bits
    180 	 (remembering that 2-bit shift right will occur).  */
    181       if (value > 0x7fffff)
    182         return _("21-bit offset out of range");
    183     }
    184   *valuep = (value & 0x7FFFFF);
    185   return errmsg;
    186 }
    187 
    188 /* Handle high().  */
    189 
    190 static const char *
    191 parse_hi16 (CGEN_CPU_DESC cd,
    192 	    const char **strp,
    193 	    int opindex,
    194 	    unsigned long *valuep)
    195 {
    196   if (strncasecmp (*strp, "%hi(", 4) == 0)
    197     {
    198       enum cgen_parse_operand_result result_type;
    199       bfd_vma value;
    200       const char *errmsg;
    201 
    202       *strp += 4;
    203       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_HI16,
    204 				   & result_type, & value);
    205       if (**strp != ')')
    206 	return MISSING_CLOSING_PARENTHESIS;
    207 
    208       ++*strp;
    209       if (errmsg == NULL
    210   	  && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
    211 	{
    212 	  /* If value has top-bit of %lo on, then it will
    213 	     sign-propagate and so we compensate by adding
    214 	     1 to the resultant %hi value.  */
    215 	  if (value & 0x8000)
    216 	    value += 0x10000;
    217 	  value >>= 16;
    218 	  value &= 0xffff;
    219 	}
    220       *valuep = value;
    221 
    222       return errmsg;
    223     }
    224 
    225   /* We add %uhi in case a user just wants the high 16-bits or is using
    226      an insn like ori for %lo which does not sign-propagate.  */
    227   if (strncasecmp (*strp, "%uhi(", 5) == 0)
    228     {
    229       enum cgen_parse_operand_result result_type;
    230       bfd_vma value;
    231       const char *errmsg;
    232 
    233       *strp += 5;
    234       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_IQ2000_UHI16,
    235 				   & result_type, & value);
    236       if (**strp != ')')
    237 	return MISSING_CLOSING_PARENTHESIS;
    238 
    239       ++*strp;
    240       if (errmsg == NULL
    241   	  && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
    242 	value >>= 16;
    243 
    244       value &= 0xffff;
    245       *valuep = value;
    246 
    247       return errmsg;
    248     }
    249 
    250   return parse_imm (cd, strp, opindex, valuep);
    251 }
    252 
    253 /* Handle %lo in a signed context.
    254    The signedness of the value doesn't matter to %lo(), but this also
    255    handles the case where %lo() isn't present.  */
    256 
    257 static const char *
    258 parse_lo16 (CGEN_CPU_DESC cd,
    259 	    const char **strp,
    260 	    int opindex,
    261 	    unsigned long *valuep)
    262 {
    263   if (strncasecmp (*strp, "%lo(", 4) == 0)
    264     {
    265       const char *errmsg;
    266       enum cgen_parse_operand_result result_type;
    267       bfd_vma value;
    268 
    269       *strp += 4;
    270       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_LO16,
    271 				   & result_type, & value);
    272       if (**strp != ')')
    273 	return MISSING_CLOSING_PARENTHESIS;
    274       ++*strp;
    275       if (errmsg == NULL
    276 	  && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
    277 	value &= 0xffff;
    278       *valuep = value;
    279       return errmsg;
    280     }
    281 
    282   return parse_imm (cd, strp, opindex, valuep);
    283 }
    284 
    285 /* Handle %lo in a negated signed context.
    286    The signedness of the value doesn't matter to %lo(), but this also
    287    handles the case where %lo() isn't present.  */
    288 
    289 static const char *
    290 parse_mlo16 (CGEN_CPU_DESC cd,
    291 	     const char **strp,
    292 	     int opindex,
    293 	     unsigned long *valuep)
    294 {
    295   if (strncasecmp (*strp, "%lo(", 4) == 0)
    296     {
    297       const char *errmsg;
    298       enum cgen_parse_operand_result result_type;
    299       bfd_vma value;
    300 
    301       *strp += 4;
    302       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_LO16,
    303 				   & result_type, & value);
    304       if (**strp != ')')
    305 	return MISSING_CLOSING_PARENTHESIS;
    306       ++*strp;
    307       if (errmsg == NULL
    308 	  && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
    309 	value = (-value) & 0xffff;
    310       *valuep = value;
    311       return errmsg;
    312     }
    313 
    314   return parse_mimm (cd, strp, opindex, valuep);
    315 }
    316 
    317 /* -- */
    318 
    319 const char * iq2000_cgen_parse_operand
    320   (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
    321 
    322 /* Main entry point for operand parsing.
    323 
    324    This function is basically just a big switch statement.  Earlier versions
    325    used tables to look up the function to use, but
    326    - if the table contains both assembler and disassembler functions then
    327      the disassembler contains much of the assembler and vice-versa,
    328    - there's a lot of inlining possibilities as things grow,
    329    - using a switch statement avoids the function call overhead.
    330 
    331    This function could be moved into `parse_insn_normal', but keeping it
    332    separate makes clear the interface between `parse_insn_normal' and each of
    333    the handlers.  */
    334 
    335 const char *
    336 iq2000_cgen_parse_operand (CGEN_CPU_DESC cd,
    337 			   int opindex,
    338 			   const char ** strp,
    339 			   CGEN_FIELDS * fields)
    340 {
    341   const char * errmsg = NULL;
    342   /* Used by scalar operands that still need to be parsed.  */
    343   long junk ATTRIBUTE_UNUSED;
    344 
    345   switch (opindex)
    346     {
    347     case IQ2000_OPERAND__INDEX :
    348       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND__INDEX, (unsigned long *) (& fields->f_index));
    349       break;
    350     case IQ2000_OPERAND_BASE :
    351       errmsg = cgen_parse_keyword (cd, strp, & iq2000_cgen_opval_gr_names, & fields->f_rs);
    352       break;
    353     case IQ2000_OPERAND_BASEOFF :
    354       {
    355         bfd_vma value = 0;
    356         errmsg = cgen_parse_address (cd, strp, IQ2000_OPERAND_BASEOFF, 0, NULL,  & value);
    357         fields->f_imm = value;
    358       }
    359       break;
    360     case IQ2000_OPERAND_BITNUM :
    361       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_BITNUM, (unsigned long *) (& fields->f_rt));
    362       break;
    363     case IQ2000_OPERAND_BYTECOUNT :
    364       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_BYTECOUNT, (unsigned long *) (& fields->f_bytecount));
    365       break;
    366     case IQ2000_OPERAND_CAM_Y :
    367       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_CAM_Y, (unsigned long *) (& fields->f_cam_y));
    368       break;
    369     case IQ2000_OPERAND_CAM_Z :
    370       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_CAM_Z, (unsigned long *) (& fields->f_cam_z));
    371       break;
    372     case IQ2000_OPERAND_CM_3FUNC :
    373       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_CM_3FUNC, (unsigned long *) (& fields->f_cm_3func));
    374       break;
    375     case IQ2000_OPERAND_CM_3Z :
    376       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_CM_3Z, (unsigned long *) (& fields->f_cm_3z));
    377       break;
    378     case IQ2000_OPERAND_CM_4FUNC :
    379       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_CM_4FUNC, (unsigned long *) (& fields->f_cm_4func));
    380       break;
    381     case IQ2000_OPERAND_CM_4Z :
    382       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_CM_4Z, (unsigned long *) (& fields->f_cm_4z));
    383       break;
    384     case IQ2000_OPERAND_COUNT :
    385       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_COUNT, (unsigned long *) (& fields->f_count));
    386       break;
    387     case IQ2000_OPERAND_EXECODE :
    388       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_EXECODE, (unsigned long *) (& fields->f_excode));
    389       break;
    390     case IQ2000_OPERAND_HI16 :
    391       errmsg = parse_hi16 (cd, strp, IQ2000_OPERAND_HI16, (unsigned long *) (& fields->f_imm));
    392       break;
    393     case IQ2000_OPERAND_IMM :
    394       errmsg = parse_imm (cd, strp, IQ2000_OPERAND_IMM, (unsigned long *) (& fields->f_imm));
    395       break;
    396     case IQ2000_OPERAND_JMPTARG :
    397       {
    398         bfd_vma value = 0;
    399         errmsg = cgen_parse_address (cd, strp, IQ2000_OPERAND_JMPTARG, 0, NULL,  & value);
    400         fields->f_jtarg = value;
    401       }
    402       break;
    403     case IQ2000_OPERAND_JMPTARGQ10 :
    404       {
    405         bfd_vma value = 0;
    406         errmsg = parse_jtargq10 (cd, strp, IQ2000_OPERAND_JMPTARGQ10, 0, NULL,  & value);
    407         fields->f_jtargq10 = value;
    408       }
    409       break;
    410     case IQ2000_OPERAND_LO16 :
    411       errmsg = parse_lo16 (cd, strp, IQ2000_OPERAND_LO16, (unsigned long *) (& fields->f_imm));
    412       break;
    413     case IQ2000_OPERAND_MASK :
    414       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_MASK, (unsigned long *) (& fields->f_mask));
    415       break;
    416     case IQ2000_OPERAND_MASKL :
    417       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_MASKL, (unsigned long *) (& fields->f_maskl));
    418       break;
    419     case IQ2000_OPERAND_MASKQ10 :
    420       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_MASKQ10, (unsigned long *) (& fields->f_maskq10));
    421       break;
    422     case IQ2000_OPERAND_MASKR :
    423       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_MASKR, (unsigned long *) (& fields->f_rs));
    424       break;
    425     case IQ2000_OPERAND_MLO16 :
    426       errmsg = parse_mlo16 (cd, strp, IQ2000_OPERAND_MLO16, (unsigned long *) (& fields->f_imm));
    427       break;
    428     case IQ2000_OPERAND_OFFSET :
    429       {
    430         bfd_vma value = 0;
    431         errmsg = cgen_parse_address (cd, strp, IQ2000_OPERAND_OFFSET, 0, NULL,  & value);
    432         fields->f_offset = value;
    433       }
    434       break;
    435     case IQ2000_OPERAND_RD :
    436       errmsg = cgen_parse_keyword (cd, strp, & iq2000_cgen_opval_gr_names, & fields->f_rd);
    437       break;
    438     case IQ2000_OPERAND_RD_RS :
    439       errmsg = cgen_parse_keyword (cd, strp, & iq2000_cgen_opval_gr_names, & fields->f_rd_rs);
    440       break;
    441     case IQ2000_OPERAND_RD_RT :
    442       errmsg = cgen_parse_keyword (cd, strp, & iq2000_cgen_opval_gr_names, & fields->f_rd_rt);
    443       break;
    444     case IQ2000_OPERAND_RS :
    445       errmsg = cgen_parse_keyword (cd, strp, & iq2000_cgen_opval_gr_names, & fields->f_rs);
    446       break;
    447     case IQ2000_OPERAND_RT :
    448       errmsg = cgen_parse_keyword (cd, strp, & iq2000_cgen_opval_gr_names, & fields->f_rt);
    449       break;
    450     case IQ2000_OPERAND_RT_RS :
    451       errmsg = cgen_parse_keyword (cd, strp, & iq2000_cgen_opval_gr_names, & fields->f_rt_rs);
    452       break;
    453     case IQ2000_OPERAND_SHAMT :
    454       errmsg = cgen_parse_unsigned_integer (cd, strp, IQ2000_OPERAND_SHAMT, (unsigned long *) (& fields->f_shamt));
    455       break;
    456 
    457     default :
    458       /* xgettext:c-format */
    459       fprintf (stderr, _("Unrecognized field %d while parsing.\n"), opindex);
    460       abort ();
    461   }
    462 
    463   return errmsg;
    464 }
    465 
    466 cgen_parse_fn * const iq2000_cgen_parse_handlers[] =
    467 {
    468   parse_insn_normal,
    469 };
    470 
    471 void
    472 iq2000_cgen_init_asm (CGEN_CPU_DESC cd)
    473 {
    474   iq2000_cgen_init_opcode_table (cd);
    475   iq2000_cgen_init_ibld_table (cd);
    476   cd->parse_handlers = & iq2000_cgen_parse_handlers[0];
    477   cd->parse_operand = iq2000_cgen_parse_operand;
    478 #ifdef CGEN_ASM_INIT_HOOK
    479 CGEN_ASM_INIT_HOOK
    480 #endif
    481 }
    482 
    483 
    484 
    486 /* Regex construction routine.
    487 
    488    This translates an opcode syntax string into a regex string,
    489    by replacing any non-character syntax element (such as an
    490    opcode) with the pattern '.*'
    491 
    492    It then compiles the regex and stores it in the opcode, for
    493    later use by iq2000_cgen_assemble_insn
    494 
    495    Returns NULL for success, an error message for failure.  */
    496 
    497 char *
    498 iq2000_cgen_build_insn_regex (CGEN_INSN *insn)
    499 {
    500   CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
    501   const char *mnem = CGEN_INSN_MNEMONIC (insn);
    502   char rxbuf[CGEN_MAX_RX_ELEMENTS];
    503   char *rx = rxbuf;
    504   const CGEN_SYNTAX_CHAR_TYPE *syn;
    505   int reg_err;
    506 
    507   syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
    508 
    509   /* Mnemonics come first in the syntax string.  */
    510   if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
    511     return _("missing mnemonic in syntax string");
    512   ++syn;
    513 
    514   /* Generate a case sensitive regular expression that emulates case
    515      insensitive matching in the "C" locale.  We cannot generate a case
    516      insensitive regular expression because in Turkish locales, 'i' and 'I'
    517      are not equal modulo case conversion.  */
    518 
    519   /* Copy the literal mnemonic out of the insn.  */
    520   for (; *mnem; mnem++)
    521     {
    522       char c = *mnem;
    523 
    524       if (ISALPHA (c))
    525 	{
    526 	  *rx++ = '[';
    527 	  *rx++ = TOLOWER (c);
    528 	  *rx++ = TOUPPER (c);
    529 	  *rx++ = ']';
    530 	}
    531       else
    532 	*rx++ = c;
    533     }
    534 
    535   /* Copy any remaining literals from the syntax string into the rx.  */
    536   for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
    537     {
    538       if (CGEN_SYNTAX_CHAR_P (* syn))
    539 	{
    540 	  char c = CGEN_SYNTAX_CHAR (* syn);
    541 
    542 	  switch (c)
    543 	    {
    544 	      /* Escape any regex metacharacters in the syntax.  */
    545 	    case '.': case '[': case '\\':
    546 	    case '*': case '^': case '$':
    547 
    548 #ifdef CGEN_ESCAPE_EXTENDED_REGEX
    549 	    case '?': case '{': case '}':
    550 	    case '(': case ')': case '*':
    551 	    case '|': case '+': case ']':
    552 #endif
    553 	      *rx++ = '\\';
    554 	      *rx++ = c;
    555 	      break;
    556 
    557 	    default:
    558 	      if (ISALPHA (c))
    559 		{
    560 		  *rx++ = '[';
    561 		  *rx++ = TOLOWER (c);
    562 		  *rx++ = TOUPPER (c);
    563 		  *rx++ = ']';
    564 		}
    565 	      else
    566 		*rx++ = c;
    567 	      break;
    568 	    }
    569 	}
    570       else
    571 	{
    572 	  /* Replace non-syntax fields with globs.  */
    573 	  *rx++ = '.';
    574 	  *rx++ = '*';
    575 	}
    576     }
    577 
    578   /* Trailing whitespace ok.  */
    579   * rx++ = '[';
    580   * rx++ = ' ';
    581   * rx++ = '\t';
    582   * rx++ = ']';
    583   * rx++ = '*';
    584 
    585   /* But anchor it after that.  */
    586   * rx++ = '$';
    587   * rx = '\0';
    588 
    589   CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
    590   reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
    591 
    592   if (reg_err == 0)
    593     return NULL;
    594   else
    595     {
    596       static char msg[80];
    597 
    598       regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
    599       regfree ((regex_t *) CGEN_INSN_RX (insn));
    600       free (CGEN_INSN_RX (insn));
    601       (CGEN_INSN_RX (insn)) = NULL;
    602       return msg;
    603     }
    604 }
    605 
    606 
    607 /* Default insn parser.
    609 
    610    The syntax string is scanned and operands are parsed and stored in FIELDS.
    611    Relocs are queued as we go via other callbacks.
    612 
    613    ??? Note that this is currently an all-or-nothing parser.  If we fail to
    614    parse the instruction, we return 0 and the caller will start over from
    615    the beginning.  Backtracking will be necessary in parsing subexpressions,
    616    but that can be handled there.  Not handling backtracking here may get
    617    expensive in the case of the m68k.  Deal with later.
    618 
    619    Returns NULL for success, an error message for failure.  */
    620 
    621 static const char *
    622 parse_insn_normal (CGEN_CPU_DESC cd,
    623 		   const CGEN_INSN *insn,
    624 		   const char **strp,
    625 		   CGEN_FIELDS *fields)
    626 {
    627   /* ??? Runtime added insns not handled yet.  */
    628   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
    629   const char *str = *strp;
    630   const char *errmsg;
    631   const char *p;
    632   const CGEN_SYNTAX_CHAR_TYPE * syn;
    633 #ifdef CGEN_MNEMONIC_OPERANDS
    634   /* FIXME: wip */
    635   int past_opcode_p;
    636 #endif
    637 
    638   /* For now we assume the mnemonic is first (there are no leading operands).
    639      We can parse it without needing to set up operand parsing.
    640      GAS's input scrubber will ensure mnemonics are lowercase, but we may
    641      not be called from GAS.  */
    642   p = CGEN_INSN_MNEMONIC (insn);
    643   while (*p && TOLOWER (*p) == TOLOWER (*str))
    644     ++p, ++str;
    645 
    646   if (* p)
    647     return _("unrecognized instruction");
    648 
    649 #ifndef CGEN_MNEMONIC_OPERANDS
    650   if (* str && ! ISSPACE (* str))
    651     return _("unrecognized instruction");
    652 #endif
    653 
    654   CGEN_INIT_PARSE (cd);
    655   cgen_init_parse_operand (cd);
    656 #ifdef CGEN_MNEMONIC_OPERANDS
    657   past_opcode_p = 0;
    658 #endif
    659 
    660   /* We don't check for (*str != '\0') here because we want to parse
    661      any trailing fake arguments in the syntax string.  */
    662   syn = CGEN_SYNTAX_STRING (syntax);
    663 
    664   /* Mnemonics come first for now, ensure valid string.  */
    665   if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
    666     abort ();
    667 
    668   ++syn;
    669 
    670   while (* syn != 0)
    671     {
    672       /* Non operand chars must match exactly.  */
    673       if (CGEN_SYNTAX_CHAR_P (* syn))
    674 	{
    675 	  /* FIXME: While we allow for non-GAS callers above, we assume the
    676 	     first char after the mnemonic part is a space.  */
    677 	  /* FIXME: We also take inappropriate advantage of the fact that
    678 	     GAS's input scrubber will remove extraneous blanks.  */
    679 	  if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
    680 	    {
    681 #ifdef CGEN_MNEMONIC_OPERANDS
    682 	      if (CGEN_SYNTAX_CHAR(* syn) == ' ')
    683 		past_opcode_p = 1;
    684 #endif
    685 	      ++ syn;
    686 	      ++ str;
    687 	    }
    688 	  else if (*str)
    689 	    {
    690 	      /* Syntax char didn't match.  Can't be this insn.  */
    691 	      static char msg [80];
    692 
    693 	      /* xgettext:c-format */
    694 	      sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
    695 		       CGEN_SYNTAX_CHAR(*syn), *str);
    696 	      return msg;
    697 	    }
    698 	  else
    699 	    {
    700 	      /* Ran out of input.  */
    701 	      static char msg [80];
    702 
    703 	      /* xgettext:c-format */
    704 	      sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
    705 		       CGEN_SYNTAX_CHAR(*syn));
    706 	      return msg;
    707 	    }
    708 	  continue;
    709 	}
    710 
    711 #ifdef CGEN_MNEMONIC_OPERANDS
    712       (void) past_opcode_p;
    713 #endif
    714       /* We have an operand of some sort.  */
    715       errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
    716       if (errmsg)
    717 	return errmsg;
    718 
    719       /* Done with this operand, continue with next one.  */
    720       ++ syn;
    721     }
    722 
    723   /* If we're at the end of the syntax string, we're done.  */
    724   if (* syn == 0)
    725     {
    726       /* FIXME: For the moment we assume a valid `str' can only contain
    727 	 blanks now.  IE: We needn't try again with a longer version of
    728 	 the insn and it is assumed that longer versions of insns appear
    729 	 before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3).  */
    730       while (ISSPACE (* str))
    731 	++ str;
    732 
    733       if (* str != '\0')
    734 	return _("junk at end of line"); /* FIXME: would like to include `str' */
    735 
    736       return NULL;
    737     }
    738 
    739   /* We couldn't parse it.  */
    740   return _("unrecognized instruction");
    741 }
    742 
    743 /* Main entry point.
    745    This routine is called for each instruction to be assembled.
    746    STR points to the insn to be assembled.
    747    We assume all necessary tables have been initialized.
    748    The assembled instruction, less any fixups, is stored in BUF.
    749    Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
    750    still needs to be converted to target byte order, otherwise BUF is an array
    751    of bytes in target byte order.
    752    The result is a pointer to the insn's entry in the opcode table,
    753    or NULL if an error occured (an error message will have already been
    754    printed).
    755 
    756    Note that when processing (non-alias) macro-insns,
    757    this function recurses.
    758 
    759    ??? It's possible to make this cpu-independent.
    760    One would have to deal with a few minor things.
    761    At this point in time doing so would be more of a curiosity than useful
    762    [for example this file isn't _that_ big], but keeping the possibility in
    763    mind helps keep the design clean.  */
    764 
    765 const CGEN_INSN *
    766 iq2000_cgen_assemble_insn (CGEN_CPU_DESC cd,
    767 			   const char *str,
    768 			   CGEN_FIELDS *fields,
    769 			   CGEN_INSN_BYTES_PTR buf,
    770 			   char **errmsg)
    771 {
    772   const char *start;
    773   CGEN_INSN_LIST *ilist;
    774   const char *parse_errmsg = NULL;
    775   const char *insert_errmsg = NULL;
    776   int recognized_mnemonic = 0;
    777 
    778   /* Skip leading white space.  */
    779   while (ISSPACE (* str))
    780     ++ str;
    781 
    782   /* The instructions are stored in hashed lists.
    783      Get the first in the list.  */
    784   ilist = CGEN_ASM_LOOKUP_INSN (cd, str);
    785 
    786   /* Keep looking until we find a match.  */
    787   start = str;
    788   for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
    789     {
    790       const CGEN_INSN *insn = ilist->insn;
    791       recognized_mnemonic = 1;
    792 
    793 #ifdef CGEN_VALIDATE_INSN_SUPPORTED
    794       /* Not usually needed as unsupported opcodes
    795 	 shouldn't be in the hash lists.  */
    796       /* Is this insn supported by the selected cpu?  */
    797       if (! iq2000_cgen_insn_supported (cd, insn))
    798 	continue;
    799 #endif
    800       /* If the RELAXED attribute is set, this is an insn that shouldn't be
    801 	 chosen immediately.  Instead, it is used during assembler/linker
    802 	 relaxation if possible.  */
    803       if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
    804 	continue;
    805 
    806       str = start;
    807 
    808       /* Skip this insn if str doesn't look right lexically.  */
    809       if (CGEN_INSN_RX (insn) != NULL &&
    810 	  regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
    811 	continue;
    812 
    813       /* Allow parse/insert handlers to obtain length of insn.  */
    814       CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
    815 
    816       parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
    817       if (parse_errmsg != NULL)
    818 	continue;
    819 
    820       /* ??? 0 is passed for `pc'.  */
    821       insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
    822 						 (bfd_vma) 0);
    823       if (insert_errmsg != NULL)
    824         continue;
    825 
    826       /* It is up to the caller to actually output the insn and any
    827          queued relocs.  */
    828       return insn;
    829     }
    830 
    831   {
    832     static char errbuf[150];
    833     const char *tmp_errmsg;
    834 #ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
    835 #define be_verbose 1
    836 #else
    837 #define be_verbose 0
    838 #endif
    839 
    840     if (be_verbose)
    841       {
    842 	/* If requesting verbose error messages, use insert_errmsg.
    843 	   Failing that, use parse_errmsg.  */
    844 	tmp_errmsg = (insert_errmsg ? insert_errmsg :
    845 		      parse_errmsg ? parse_errmsg :
    846 		      recognized_mnemonic ?
    847 		      _("unrecognized form of instruction") :
    848 		      _("unrecognized instruction"));
    849 
    850 	if (strlen (start) > 50)
    851 	  /* xgettext:c-format */
    852 	  sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
    853 	else
    854 	  /* xgettext:c-format */
    855 	  sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
    856       }
    857     else
    858       {
    859 	if (strlen (start) > 50)
    860 	  /* xgettext:c-format */
    861 	  sprintf (errbuf, _("bad instruction `%.50s...'"), start);
    862 	else
    863 	  /* xgettext:c-format */
    864 	  sprintf (errbuf, _("bad instruction `%.50s'"), start);
    865       }
    866 
    867     *errmsg = errbuf;
    868     return NULL;
    869   }
    870 }
    871