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