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 #ifdef CGEN_MNEMONIC_OPERANDS
 561       (void) past_opcode_p;
 562 #endif
 563       /* We have an operand of some sort.  */
 564       errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
 565       if (errmsg)
 566         return errmsg;
 567
 568       /* Done with this operand, continue with next one.  */
 569       ++ syn;
 570     }
 571
 572   /* If we're at the end of the syntax string, we're done.  */
 573   if (* syn == 0)
 574     {
 575       /* FIXME: For the moment we assume a valid `str' can only contain
 576          blanks now.  IE: We needn't try again with a longer version of
 577          the insn and it is assumed that longer versions of insns appear
 578          before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3).  */
 579       while (ISSPACE (* str))
 580         ++ str;
 581
 582       if (* str != '\0')
 583         return _("junk at end of line"); /* FIXME: would like to include `str' */
 584
 585       return NULL;
 586     }
 587
 588   /* We couldn't parse it.  */
 589   return _("unrecognized instruction");
 590 }
 591 \f
 592 /* Main entry point.
 593    This routine is called for each instruction to be assembled.
 594    STR points to the insn to be assembled.
 595    We assume all necessary tables have been initialized.
 596    The assembled instruction, less any fixups, is stored in BUF.
 597    Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
 598    still needs to be converted to target byte order, otherwise BUF is an array
 599    of bytes in target byte order.
 600    The result is a pointer to the insn's entry in the opcode table,
 601    or NULL if an error occured (an error message will have already been
 602    printed).
 603
 604    Note that when processing (non-alias) macro-insns,
 605    this function recurses.
 606
 607    ??? It's possible to make this cpu-independent.
 608    One would have to deal with a few minor things.
 609    At this point in time doing so would be more of a curiosity than useful
 610    [for example this file isn't _that_ big], but keeping the possibility in
 611    mind helps keep the design clean.  */
 612
 613 const CGEN_INSN *
 614 fr30_cgen_assemble_insn (CGEN_CPU_DESC cd,
 615                            const char *str,
 616                            CGEN_FIELDS *fields,
 617                            CGEN_INSN_BYTES_PTR buf,
 618                            char **errmsg)
 619 {
 620   const char *start;
 621   CGEN_INSN_LIST *ilist;
 622   const char *parse_errmsg = NULL;
 623   const char *insert_errmsg = NULL;
 624   int recognized_mnemonic = 0;
 625
 626   /* Skip leading white space.  */
 627   while (ISSPACE (* str))
 628     ++ str;
 629
 630   /* The instructions are stored in hashed lists.
 631      Get the first in the list.  */
 632   ilist = CGEN_ASM_LOOKUP_INSN (cd, str);
 633
 634   /* Keep looking until we find a match.  */
 635   start = str;
 636   for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
 637     {
 638       const CGEN_INSN *insn = ilist->insn;
 639       recognized_mnemonic = 1;
 640
 641 #ifdef CGEN_VALIDATE_INSN_SUPPORTED
 642       /* Not usually needed as unsupported opcodes
 643          shouldn't be in the hash lists.  */
 644       /* Is this insn supported by the selected cpu?  */
 645       if (! fr30_cgen_insn_supported (cd, insn))
 646         continue;
 647 #endif
 648       /* If the RELAXED attribute is set, this is an insn that shouldn't be
 649          chosen immediately.  Instead, it is used during assembler/linker
 650          relaxation if possible.  */
 651       if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
 652         continue;
 653
 654       str = start;
 655
 656       /* Skip this insn if str doesn't look right lexically.  */
 657       if (CGEN_INSN_RX (insn) != NULL &&
 658           regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
 659         continue;
 660
 661       /* Allow parse/insert handlers to obtain length of insn.  */
 662       CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
 663
 664       parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
 665       if (parse_errmsg != NULL)
 666         continue;
 667
 668       /* ??? 0 is passed for `pc'.  */
 669       insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
 670                                                  (bfd_vma) 0);
 671       if (insert_errmsg != NULL)
 672         continue;
 673
 674       /* It is up to the caller to actually output the insn and any
 675          queued relocs.  */
 676       return insn;
 677     }
 678
 679   {
 680     static char errbuf[150];
 681     const char *tmp_errmsg;
 682 #ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
 683 #define be_verbose 1
 684 #else
 685 #define be_verbose 0
 686 #endif
 687
 688     if (be_verbose)
 689       {
 690         /* If requesting verbose error messages, use insert_errmsg.
 691            Failing that, use parse_errmsg.  */
 692         tmp_errmsg = (insert_errmsg ? insert_errmsg :
 693                       parse_errmsg ? parse_errmsg :
 694                       recognized_mnemonic ?
 695                       _("unrecognized form of instruction") :
 696                       _("unrecognized instruction"));
 697
 698         if (strlen (start) > 50)
 699           /* xgettext:c-format */
 700           sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
 701         else
 702           /* xgettext:c-format */
 703           sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
 704       }
 705     else
 706       {
 707         if (strlen (start) > 50)
 708           /* xgettext:c-format */
 709           sprintf (errbuf, _("bad instruction `%.50s...'"), start);
 710         else
 711           /* xgettext:c-format */
 712           sprintf (errbuf, _("bad instruction `%.50s'"), start);
 713       }
 714
 715     *errmsg = errbuf;
 716     return NULL;
 717   }
 718 }