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