opcodes/fr30-asm.c

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