opcodes/mep-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
   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 "mep-desc.h"
  36 #include "mep-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
  54 #include "elf/mep.h"
  55
  56 #define CGEN_VALIDATE_INSN_SUPPORTED
  57 #define mep_cgen_insn_supported mep_cgen_insn_supported_asm
  58
  59        const char * parse_csrn       (CGEN_CPU_DESC, const char **, CGEN_KEYWORD *, long *);
  60        const char * parse_tpreg      (CGEN_CPU_DESC, const char **, CGEN_KEYWORD *, long *);
  61        const char * parse_spreg      (CGEN_CPU_DESC, const char **, CGEN_KEYWORD *, long *);
  62        const char * parse_mep_align  (CGEN_CPU_DESC, const char **, enum cgen_operand_type, long *);
  63        const char * parse_mep_alignu (CGEN_CPU_DESC, const char **, enum cgen_operand_type, unsigned long *);
  64 static const char * parse_signed16   (CGEN_CPU_DESC, const char **, int, long *);
  65 static const char * parse_signed16_range   (CGEN_CPU_DESC, const char **, int, long *);
  66 static const char * parse_unsigned16 (CGEN_CPU_DESC, const char **, int, unsigned long *);
  67 static const char * parse_unsigned16_range (CGEN_CPU_DESC, const char **, int, unsigned long *);
  68 static const char * parse_lo16       (CGEN_CPU_DESC, const char **, int, long *, long);
  69 static const char * parse_unsigned7  (CGEN_CPU_DESC, const char **, enum cgen_operand_type, unsigned long *);
  70 static const char * parse_zero       (CGEN_CPU_DESC, const char **, int, long *);
  71
  72 const char *
  73 parse_csrn (CGEN_CPU_DESC cd, const char **strp,
  74             CGEN_KEYWORD *keyword_table, long *field)
  75 {
  76   const char *err;
  77   unsigned long value;
  78
  79   err = cgen_parse_keyword (cd, strp, keyword_table, field);
  80   if (!err)
  81     return NULL;
  82
  83   err = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CSRN_IDX, & value);
  84   if (err)
  85     return err;
  86   *field = value;
  87   return NULL;
  88 }
  89
  90 /* begin-cop-ip-parse-handlers */
  91 static const char *
  92 parse_ivc2_cr (CGEN_CPU_DESC,
  93         const char **,
  94         CGEN_KEYWORD *,
  95         long *) ATTRIBUTE_UNUSED;
  96 static const char *
  97 parse_ivc2_cr (CGEN_CPU_DESC cd,
  98         const char **strp,
  99         CGEN_KEYWORD *keyword_table  ATTRIBUTE_UNUSED,
 100         long *field)
 101 {
 102   return cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr_ivc2, field);
 103 }
 104 static const char *
 105 parse_ivc2_ccr (CGEN_CPU_DESC,
 106         const char **,
 107         CGEN_KEYWORD *,
 108         long *) ATTRIBUTE_UNUSED;
 109 static const char *
 110 parse_ivc2_ccr (CGEN_CPU_DESC cd,
 111         const char **strp,
 112         CGEN_KEYWORD *keyword_table  ATTRIBUTE_UNUSED,
 113         long *field)
 114 {
 115   return cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_ccr_ivc2, field);
 116 }
 117 /* end-cop-ip-parse-handlers */
 118
 119 const char *
 120 parse_tpreg (CGEN_CPU_DESC cd, const char ** strp,
 121              CGEN_KEYWORD *keyword_table, long *field)
 122 {
 123   const char *err;
 124
 125   err = cgen_parse_keyword (cd, strp, keyword_table, field);
 126   if (err)
 127     return err;
 128   if (*field != 13)
 129     return _("Only $tp or $13 allowed for this opcode");
 130   return NULL;
 131 }
 132
 133 const char *
 134 parse_spreg (CGEN_CPU_DESC cd, const char ** strp,
 135              CGEN_KEYWORD *keyword_table, long *field)
 136 {
 137   const char *err;
 138
 139   err = cgen_parse_keyword (cd, strp, keyword_table, field);
 140   if (err)
 141     return err;
 142   if (*field != 15)
 143     return _("Only $sp or $15 allowed for this opcode");
 144   return NULL;
 145 }
 146
 147 const char *
 148 parse_mep_align (CGEN_CPU_DESC cd, const char ** strp,
 149                  enum cgen_operand_type type, long *field)
 150 {
 151   long lsbs = 0;
 152   const char *err;
 153
 154   switch (type)
 155     {
 156     case MEP_OPERAND_PCREL8A2:
 157     case MEP_OPERAND_PCREL12A2:
 158     case MEP_OPERAND_PCREL17A2:
 159     case MEP_OPERAND_PCREL24A2:
 160       err = cgen_parse_signed_integer   (cd, strp, type, field);
 161       break;
 162     case MEP_OPERAND_PCABS24A2:
 163     case MEP_OPERAND_UDISP7:
 164     case MEP_OPERAND_UDISP7A2:
 165     case MEP_OPERAND_UDISP7A4:
 166     case MEP_OPERAND_UIMM7A4:
 167     case MEP_OPERAND_ADDR24A4:
 168       err = cgen_parse_unsigned_integer (cd, strp, type, (unsigned long *) field);
 169       break;
 170     default:
 171       abort();
 172     }
 173   if (err)
 174     return err;
 175   switch (type)
 176     {
 177     case MEP_OPERAND_UDISP7:
 178       lsbs = 0;
 179       break;
 180     case MEP_OPERAND_PCREL8A2:
 181     case MEP_OPERAND_PCREL12A2:
 182     case MEP_OPERAND_PCREL17A2:
 183     case MEP_OPERAND_PCREL24A2:
 184     case MEP_OPERAND_PCABS24A2:
 185     case MEP_OPERAND_UDISP7A2:
 186       lsbs = *field & 1;
 187       break;
 188     case MEP_OPERAND_UDISP7A4:
 189     case MEP_OPERAND_UIMM7A4:
 190     case MEP_OPERAND_ADDR24A4:
 191       lsbs = *field & 3;
 192       break;
 193       lsbs = *field & 7;
 194       break;
 195     default:
 196       /* Safe assumption?  */
 197       abort ();
 198     }
 199   if (lsbs)
 200     return "Value is not aligned enough";
 201   return NULL;
 202 }
 203
 204 const char *
 205 parse_mep_alignu (CGEN_CPU_DESC cd, const char ** strp,
 206                  enum cgen_operand_type type, unsigned long *field)
 207 {
 208   return parse_mep_align (cd, strp, type, (long *) field);
 209 }
 210
 211
 212 /* Handle %lo(), %tpoff(), %sdaoff(), %hi(), and other signed
 213    constants in a signed context.  */
 214
 215 static const char *
 216 parse_signed16 (CGEN_CPU_DESC cd,
 217                 const char **strp,
 218                 int opindex,
 219                 long *valuep)
 220 {
 221   return parse_lo16 (cd, strp, opindex, valuep, 1);
 222 }
 223
 224 static const char *
 225 parse_lo16 (CGEN_CPU_DESC cd,
 226             const char **strp,
 227             int opindex,
 228             long *valuep,
 229             long signedp)
 230 {
 231   const char *errmsg;
 232   enum cgen_parse_operand_result result_type;
 233   bfd_vma value;
 234
 235   if (strncasecmp (*strp, "%lo(", 4) == 0)
 236     {
 237       *strp += 4;
 238       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_LOW16,
 239                                    & result_type, & value);
 240       if (**strp != ')')
 241         return _("missing `)'");
 242       ++*strp;
 243       if (errmsg == NULL
 244           && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
 245         value &= 0xffff;
 246       if (signedp)
 247         *valuep = (long)(short) value;
 248       else
 249         *valuep = value;
 250       return errmsg;
 251     }
 252
 253   if (strncasecmp (*strp, "%hi(", 4) == 0)
 254     {
 255       *strp += 4;
 256       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_HI16S,
 257                                    & result_type, & value);
 258       if (**strp != ')')
 259         return _("missing `)'");
 260       ++*strp;
 261       if (errmsg == NULL
 262           && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
 263         value = (value + 0x8000) >> 16;
 264       *valuep = value;
 265       return errmsg;
 266     }
 267
 268   if (strncasecmp (*strp, "%uhi(", 5) == 0)
 269     {
 270       *strp += 5;
 271       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_HI16U,
 272                                    & result_type, & value);
 273       if (**strp != ')')
 274         return _("missing `)'");
 275       ++*strp;
 276       if (errmsg == NULL
 277           && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
 278         value = value >> 16;
 279       *valuep = value;
 280       return errmsg;
 281     }
 282
 283   if (strncasecmp (*strp, "%sdaoff(", 8) == 0)
 284     {
 285       *strp += 8;
 286       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_GPREL,
 287                                    NULL, & value);
 288       if (**strp != ')')
 289         return _("missing `)'");
 290       ++*strp;
 291       *valuep = value;
 292       return errmsg;
 293     }
 294
 295   if (strncasecmp (*strp, "%tpoff(", 7) == 0)
 296     {
 297       *strp += 7;
 298       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_TPREL,
 299                                    NULL, & value);
 300       if (**strp != ')')
 301         return _("missing `)'");
 302       ++*strp;
 303       *valuep = value;
 304       return errmsg;
 305     }
 306
 307   if (**strp == '%')
 308     return _("invalid %function() here");
 309
 310   return cgen_parse_signed_integer (cd, strp, opindex, valuep);
 311 }
 312
 313 static const char *
 314 parse_unsigned16 (CGEN_CPU_DESC cd,
 315                   const char **strp,
 316                   int opindex,
 317                   unsigned long *valuep)
 318 {
 319   return parse_lo16 (cd, strp, opindex, (long *) valuep, 0);
 320 }
 321
 322 static const char *
 323 parse_signed16_range (CGEN_CPU_DESC cd,
 324                       const char **strp,
 325                       int opindex,
 326                       signed long *valuep)
 327 {
 328   const char *errmsg = 0;
 329   signed long value;
 330
 331   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
 332   if (errmsg)
 333     return errmsg;
 334
 335   if (value < -32768 || value > 32767)
 336     return _("Immediate is out of range -32768 to 32767");
 337
 338   *valuep = value;
 339   return 0;
 340 }
 341
 342 static const char *
 343 parse_unsigned16_range (CGEN_CPU_DESC cd,
 344                         const char **strp,
 345                         int opindex,
 346                         unsigned long *valuep)
 347 {
 348   const char *errmsg = 0;
 349   unsigned long value;
 350
 351   errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
 352   if (errmsg)
 353     return errmsg;
 354
 355   if (value > 65535)
 356     return _("Immediate is out of range 0 to 65535");
 357
 358   *valuep = value;
 359   return 0;
 360 }
 361
 362 /* A special case of parse_signed16 which accepts only the value zero.  */
 363
 364 static const char *
 365 parse_zero (CGEN_CPU_DESC cd, const char **strp, int opindex, long *valuep)
 366 {
 367   const char *errmsg;
 368   enum cgen_parse_operand_result result_type;
 369   bfd_vma value;
 370
 371   /*fprintf(stderr, "dj: signed parse opindex `%s'\n", *strp);*/
 372
 373   /* Prevent ($ry) from being attempted as an expression on 'sw $rx,($ry)'.
 374      It will fail and cause ry to be listed as an undefined symbol in the
 375      listing.  */
 376   if (strncmp (*strp, "($", 2) == 0)
 377     return "not zero"; /* any string will do -- will never be seen.  */
 378
 379   if (strncasecmp (*strp, "%lo(", 4) == 0)
 380     {
 381       *strp += 4;
 382       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_LOW16,
 383                                    &result_type, &value);
 384       if (**strp != ')')
 385         return "missing `)'";
 386       ++*strp;
 387       if (errmsg == NULL
 388           && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0))
 389         return "not zero"; /* any string will do -- will never be seen.  */
 390       *valuep = value;
 391       return errmsg;
 392     }
 393
 394   if (strncasecmp (*strp, "%hi(", 4) == 0)
 395     {
 396       *strp += 4;
 397       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_HI16S,
 398                                    &result_type, &value);
 399       if (**strp != ')')
 400         return "missing `)'";
 401       ++*strp;
 402       if (errmsg == NULL
 403           && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0))
 404         return "not zero"; /* any string will do -- will never be seen.  */
 405       *valuep = value;
 406       return errmsg;
 407     }
 408
 409   if (strncasecmp (*strp, "%uhi(", 5) == 0)
 410     {
 411       *strp += 5;
 412       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_HI16U,
 413                                    &result_type, &value);
 414       if (**strp != ')')
 415         return "missing `)'";
 416       ++*strp;
 417       if (errmsg == NULL
 418           && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0))
 419         return "not zero"; /* any string will do -- will never be seen.  */
 420       *valuep = value;
 421       return errmsg;
 422     }
 423
 424   if (strncasecmp (*strp, "%sdaoff(", 8) == 0)
 425     {
 426       *strp += 8;
 427       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_GPREL,
 428                                    &result_type, &value);
 429       if (**strp != ')')
 430         return "missing `)'";
 431       ++*strp;
 432       if (errmsg == NULL
 433           && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0))
 434         return "not zero"; /* any string will do -- will never be seen.  */
 435       *valuep = value;
 436       return errmsg;
 437     }
 438
 439   if (strncasecmp (*strp, "%tpoff(", 7) == 0)
 440     {
 441       *strp += 7;
 442       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_MEP_TPREL,
 443                                    &result_type, &value);
 444       if (**strp != ')')
 445         return "missing `)'";
 446       ++*strp;
 447       if (errmsg == NULL
 448           && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0))
 449         return "not zero"; /* any string will do -- will never be seen.  */
 450       *valuep = value;
 451       return errmsg;
 452     }
 453
 454   if (**strp == '%')
 455     return "invalid %function() here";
 456
 457   errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_NONE,
 458                                &result_type, &value);
 459   if (errmsg == NULL
 460       && (result_type != CGEN_PARSE_OPERAND_RESULT_NUMBER || value != 0))
 461     return "not zero"; /* any string will do -- will never be seen.  */
 462
 463   return errmsg;
 464 }
 465
 466 static const char *
 467 parse_unsigned7 (CGEN_CPU_DESC cd, const char **strp,
 468                  enum cgen_operand_type opindex, unsigned long *valuep)
 469 {
 470   const char *errmsg;
 471   bfd_vma value;
 472
 473   /* fprintf(stderr, "dj: unsigned7 parse `%s'\n", *strp); */
 474
 475   if (strncasecmp (*strp, "%tpoff(", 7) == 0)
 476     {
 477       int reloc;
 478       *strp += 7;
 479       switch (opindex)
 480         {
 481         case MEP_OPERAND_UDISP7:
 482           reloc = BFD_RELOC_MEP_TPREL7;
 483           break;
 484         case MEP_OPERAND_UDISP7A2:
 485           reloc = BFD_RELOC_MEP_TPREL7A2;
 486           break;
 487         case MEP_OPERAND_UDISP7A4:
 488           reloc = BFD_RELOC_MEP_TPREL7A4;
 489           break;
 490         default:
 491           /* Safe assumption?  */
 492           abort ();
 493         }
 494       errmsg = cgen_parse_address (cd, strp, opindex, reloc,
 495                                    NULL, &value);
 496       if (**strp != ')')
 497         return "missing `)'";
 498       ++*strp;
 499       *valuep = value;
 500       return errmsg;
 501     }
 502
 503   if (**strp == '%')
 504     return _("invalid %function() here");
 505
 506   return parse_mep_alignu (cd, strp, opindex, valuep);
 507 }
 508
 509 static ATTRIBUTE_UNUSED const char *
 510 parse_cdisp10 (CGEN_CPU_DESC cd,
 511                const char **strp,
 512                int opindex,
 513                long *valuep)
 514 {
 515   const char *errmsg = 0;
 516   signed long value;
 517   long have_zero = 0;
 518   int wide = 0;
 519   int alignment;
 520
 521   switch (opindex)
 522     {
 523     case MEP_OPERAND_CDISP10A4:
 524       alignment = 2;
 525       break;
 526     case MEP_OPERAND_CDISP10A2:
 527       alignment = 1;
 528       break;
 529     case MEP_OPERAND_CDISP10:
 530     default:
 531       alignment = 0;
 532       break;
 533     }
 534
 535   if ((MEP_CPU & EF_MEP_CPU_MASK) == EF_MEP_CPU_C5)
 536     wide = 1;
 537
 538   if (strncmp (*strp, "0x0", 3) == 0
 539       || (**strp == '0' && *(*strp + 1) != 'x'))
 540     have_zero = 1;
 541
 542   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
 543   if (errmsg)
 544     return errmsg;
 545
 546   if (wide)
 547     {
 548       if (value < -512 || value > 511)
 549         return _("Immediate is out of range -512 to 511");
 550     }
 551   else
 552     {
 553       if (value < -128 || value > 127)
 554         return _("Immediate is out of range -128 to 127");
 555     }
 556
 557   if (value & ((1<<alignment)-1))
 558     return _("Value is not aligned enough");
 559
 560   /* If this field may require a relocation then use larger dsp16.  */
 561   if (! have_zero && value == 0)
 562     return (wide ? _("Immediate is out of range -512 to 511")
 563             : _("Immediate is out of range -128 to 127"));
 564
 565   *valuep = value;
 566   return 0;
 567 }
 568
 569 /* BEGIN LIGHTWEIGHT MACRO PROCESSOR.  */
 570
 571 #define MAXARGS 9
 572
 573 typedef struct
 574 {
 575   char *name;
 576   char *expansion;
 577 }  macro;
 578
 579 typedef struct
 580 {
 581   const char *start;
 582   int len;
 583 } arg;
 584
 585 macro macros[] =
 586 {
 587   { "sizeof", "(`1.end + (- `1))"},
 588   { "startof", "(`1 | 0)" },
 589   { "align4", "(`1&(~3))"},
 590 /*{ "hi", "(((`1+0x8000)>>16) & 0xffff)" },  */
 591 /*{ "lo", "(`1 & 0xffff)" },  */
 592 /*{ "sdaoff", "((`1-__sdabase) & 0x7f)"},  */
 593 /*{ "tpoff", "((`1-__tpbase) & 0x7f)"},  */
 594   { 0,0 }
 595 };
 596
 597 static char  * expand_string    (const char *, int);
 598
 599 static const char *
 600 mep_cgen_expand_macros_and_parse_operand
 601   (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
 602
 603 static char *
 604 str_append (char *dest, const char *input, int len)
 605 {
 606   char *new_dest;
 607   int oldlen;
 608
 609   if (len == 0)
 610     return dest;
 611   /* printf("str_append: <<%s>>, <<%s>>, %d\n", dest, input, len); */
 612   oldlen = (dest ? strlen(dest) : 0);
 613   new_dest = realloc (dest, oldlen + len + 1);
 614   memset (new_dest + oldlen, 0, len + 1);
 615   return strncat (new_dest, input, len);
 616 }
 617
 618 static macro *
 619 lookup_macro (const char *name)
 620 {
 621   macro *m;
 622
 623   for (m = macros; m->name; ++m)
 624     if (strncmp (m->name, name, strlen(m->name)) == 0)
 625       return m;
 626
 627   return 0;
 628 }
 629
 630 static char *
 631 expand_macro (arg *args, int narg, macro *mac)
 632 {
 633   char *result = 0, *rescanned_result = 0;
 634   char *e = mac->expansion;
 635   char *mark = e;
 636   int arg = 0;
 637
 638   /*  printf("expanding macro %s with %d args\n", mac->name, narg + 1); */
 639   while (*e)
 640     {
 641       if (*e == '`' &&
 642           (*e+1) &&
 643           ((*(e + 1) - '1') <= MAXARGS) &&
 644           ((*(e + 1) - '1') <= narg))
 645         {
 646           result = str_append (result, mark, e - mark);
 647           arg = (*(e + 1) - '1');
 648           /* printf("replacing `%d with %s\n", arg+1, args[arg].start); */
 649           result = str_append (result, args[arg].start, args[arg].len);
 650           ++e;
 651           mark = e+1;
 652         }
 653       ++e;
 654     }
 655
 656   if (mark != e)
 657     result = str_append (result, mark, e - mark);
 658
 659   if (result)
 660     {
 661       rescanned_result = expand_string (result, 0);
 662       free (result);
 663       return rescanned_result;
 664     }
 665   else
 666     return result;
 667 }
 668
 669 #define IN_TEXT 0
 670 #define IN_ARGS 1
 671
 672 static char *
 673 expand_string (const char *in, int first_only)
 674 {
 675   int num_expansions = 0;
 676   int depth = 0;
 677   int narg = -1;
 678   arg args[MAXARGS];
 679   int state = IN_TEXT;
 680   const char *mark = in;
 681   macro *macro = 0;
 682
 683   char *expansion = 0;
 684   char *result = 0;
 685
 686   while (*in)
 687     {
 688       switch (state)
 689         {
 690         case IN_TEXT:
 691           if (*in == '%' && *(in + 1) && (!first_only || num_expansions == 0))
 692             {
 693               macro = lookup_macro (in + 1);
 694               if (macro)
 695                 {
 696                   /* printf("entering state %d at '%s'...\n", state, in); */
 697                   result = str_append (result, mark, in - mark);
 698                   mark = in;
 699                   in += 1 + strlen (macro->name);
 700                   while (*in == ' ') ++in;
 701                   if (*in != '(')
 702                     {
 703                       state = IN_TEXT;
 704                       macro = 0;
 705                     }
 706                   else
 707                     {
 708                       state = IN_ARGS;
 709                       narg = 0;
 710                       args[narg].start = in + 1;
 711                       args[narg].len = 0;
 712                       mark = in + 1;
 713                     }
 714                 }
 715             }
 716           break;
 717         case IN_ARGS:
 718           if (depth == 0)
 719             {
 720               switch (*in)
 721                 {
 722                 case ',':
 723                   narg++;
 724                   args[narg].start = (in + 1);
 725                   args[narg].len = 0;
 726                   break;
 727                 case ')':
 728                   state = IN_TEXT;
 729                   /* printf("entering state %d at '%s'...\n", state, in); */
 730                   if (macro)
 731                     {
 732                       expansion = 0;
 733                       expansion = expand_macro (args, narg, macro);
 734                       num_expansions++;
 735                       if (expansion)
 736                         {
 737                           result = str_append (result, expansion, strlen (expansion));
 738                           free (expansion);
 739                         }
 740                     }
 741                   else
 742                     {
 743                       result = str_append (result, mark, in - mark);
 744                     }
 745                   macro = 0;
 746                   mark = in + 1;
 747                   break;
 748                 case '(':
 749                   depth++;
 750                 default:
 751                   args[narg].len++;
 752                   break;
 753                 }
 754             }
 755           else
 756             {
 757               if (*in == ')')
 758                 depth--;
 759               if (narg > -1)
 760                 args[narg].len++;
 761             }
 762
 763         }
 764       ++in;
 765     }
 766
 767   if (mark != in)
 768     result = str_append (result, mark, in - mark);
 769
 770   return result;
 771 }
 772
 773 #undef IN_ARGS
 774 #undef IN_TEXT
 775 #undef MAXARGS
 776
 777
 778 /* END LIGHTWEIGHT MACRO PROCESSOR.  */
 779
 780 const char * mep_cgen_parse_operand
 781   (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
 782
 783 const char *
 784 mep_cgen_expand_macros_and_parse_operand (CGEN_CPU_DESC cd, int opindex,
 785                                           const char ** strp_in, CGEN_FIELDS * fields)
 786 {
 787   const char * errmsg = NULL;
 788   char *str = 0, *hold = 0;
 789   const char **strp = 0;
 790
 791   /* Set up a new pointer to macro-expanded string.  */
 792   str = expand_string (*strp_in, 1);
 793   /* fprintf (stderr, " expanded <<%s>> to <<%s>>\n", *strp_in, str); */
 794
 795   hold = str;
 796   strp = (const char **)(&str);
 797
 798   errmsg = mep_cgen_parse_operand (cd, opindex, strp, fields);
 799
 800   /* Now work out the advance.  */
 801   if (strlen (str) == 0)
 802     *strp_in += strlen (*strp_in);
 803
 804   else
 805     {
 806       if (strstr (*strp_in, str))
 807         /* A macro-expansion was pulled off the front.  */
 808         *strp_in = strstr (*strp_in, str);
 809       else
 810         /* A non-macro-expansion was pulled off the front.  */
 811         *strp_in += (str - hold);
 812     }
 813
 814   if (hold)
 815     free (hold);
 816
 817   return errmsg;
 818 }
 819
 820 #define CGEN_ASM_INIT_HOOK (cd->parse_operand = mep_cgen_expand_macros_and_parse_operand);
 821
 822 /* -- dis.c */
 823
 824 const char * mep_cgen_parse_operand
 825   (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
 826
 827 /* Main entry point for operand parsing.
 828
 829    This function is basically just a big switch statement.  Earlier versions
 830    used tables to look up the function to use, but
 831    - if the table contains both assembler and disassembler functions then
 832      the disassembler contains much of the assembler and vice-versa,
 833    - there's a lot of inlining possibilities as things grow,
 834    - using a switch statement avoids the function call overhead.
 835
 836    This function could be moved into `parse_insn_normal', but keeping it
 837    separate makes clear the interface between `parse_insn_normal' and each of
 838    the handlers.  */
 839
 840 const char *
 841 mep_cgen_parse_operand (CGEN_CPU_DESC cd,
 842                            int opindex,
 843                            const char ** strp,
 844                            CGEN_FIELDS * fields)
 845 {
 846   const char * errmsg = NULL;
 847   /* Used by scalar operands that still need to be parsed.  */
 848   long junk ATTRIBUTE_UNUSED;
 849
 850   switch (opindex)
 851     {
 852     case MEP_OPERAND_ADDR24A4 :
 853       errmsg = parse_mep_alignu (cd, strp, MEP_OPERAND_ADDR24A4, (unsigned long *) (& fields->f_24u8a4n));
 854       break;
 855     case MEP_OPERAND_C5RMUIMM20 :
 856       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_C5RMUIMM20, (unsigned long *) (& fields->f_c5_rmuimm20));
 857       break;
 858     case MEP_OPERAND_C5RNMUIMM24 :
 859       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_C5RNMUIMM24, (unsigned long *) (& fields->f_c5_rnmuimm24));
 860       break;
 861     case MEP_OPERAND_CALLNUM :
 862       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CALLNUM, (unsigned long *) (& fields->f_callnum));
 863       break;
 864     case MEP_OPERAND_CCCC :
 865       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CCCC, (unsigned long *) (& fields->f_rm));
 866       break;
 867     case MEP_OPERAND_CCRN :
 868       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_ccr, & fields->f_ccrn);
 869       break;
 870     case MEP_OPERAND_CDISP10 :
 871       errmsg = parse_cdisp10 (cd, strp, MEP_OPERAND_CDISP10, (long *) (& fields->f_cdisp10));
 872       break;
 873     case MEP_OPERAND_CDISP10A2 :
 874       errmsg = parse_cdisp10 (cd, strp, MEP_OPERAND_CDISP10A2, (long *) (& fields->f_cdisp10));
 875       break;
 876     case MEP_OPERAND_CDISP10A4 :
 877       errmsg = parse_cdisp10 (cd, strp, MEP_OPERAND_CDISP10A4, (long *) (& fields->f_cdisp10));
 878       break;
 879     case MEP_OPERAND_CDISP10A8 :
 880       errmsg = parse_cdisp10 (cd, strp, MEP_OPERAND_CDISP10A8, (long *) (& fields->f_cdisp10));
 881       break;
 882     case MEP_OPERAND_CDISP12 :
 883       errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_CDISP12, (long *) (& fields->f_12s20));
 884       break;
 885     case MEP_OPERAND_CIMM4 :
 886       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CIMM4, (unsigned long *) (& fields->f_rn));
 887       break;
 888     case MEP_OPERAND_CIMM5 :
 889       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CIMM5, (unsigned long *) (& fields->f_5u24));
 890       break;
 891     case MEP_OPERAND_CODE16 :
 892       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CODE16, (unsigned long *) (& fields->f_16u16));
 893       break;
 894     case MEP_OPERAND_CODE24 :
 895       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CODE24, (unsigned long *) (& fields->f_24u4n));
 896       break;
 897     case MEP_OPERAND_CP_FLAG :
 898       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_ccr, & junk);
 899       break;
 900     case MEP_OPERAND_CRN :
 901       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr, & fields->f_crn);
 902       break;
 903     case MEP_OPERAND_CRN64 :
 904       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_crn);
 905       break;
 906     case MEP_OPERAND_CRNX :
 907       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr, & fields->f_crnx);
 908       break;
 909     case MEP_OPERAND_CRNX64 :
 910       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_crnx);
 911       break;
 912     case MEP_OPERAND_CROC :
 913       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_ivc2_5u7);
 914       break;
 915     case MEP_OPERAND_CROP :
 916       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_ivc2_5u23);
 917       break;
 918     case MEP_OPERAND_CRPC :
 919       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_ivc2_5u26);
 920       break;
 921     case MEP_OPERAND_CRPP :
 922       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_ivc2_5u18);
 923       break;
 924     case MEP_OPERAND_CRQC :
 925       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_ivc2_5u21);
 926       break;
 927     case MEP_OPERAND_CRQP :
 928       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_ivc2_5u13);
 929       break;
 930     case MEP_OPERAND_CSRN :
 931       errmsg = parse_csrn (cd, strp, & mep_cgen_opval_h_csr, & fields->f_csrn);
 932       break;
 933     case MEP_OPERAND_CSRN_IDX :
 934       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_CSRN_IDX, (unsigned long *) (& fields->f_csrn));
 935       break;
 936     case MEP_OPERAND_DBG :
 937       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
 938       break;
 939     case MEP_OPERAND_DEPC :
 940       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
 941       break;
 942     case MEP_OPERAND_EPC :
 943       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
 944       break;
 945     case MEP_OPERAND_EXC :
 946       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
 947       break;
 948     case MEP_OPERAND_HI :
 949       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
 950       break;
 951     case MEP_OPERAND_IMM16P0 :
 952       errmsg = parse_unsigned16_range (cd, strp, MEP_OPERAND_IMM16P0, (unsigned long *) (& fields->f_ivc2_imm16p0));
 953       break;
 954     case MEP_OPERAND_IMM3P12 :
 955       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM3P12, (unsigned long *) (& fields->f_ivc2_3u12));
 956       break;
 957     case MEP_OPERAND_IMM3P25 :
 958       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM3P25, (unsigned long *) (& fields->f_ivc2_3u25));
 959       break;
 960     case MEP_OPERAND_IMM3P4 :
 961       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM3P4, (unsigned long *) (& fields->f_ivc2_3u4));
 962       break;
 963     case MEP_OPERAND_IMM3P5 :
 964       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM3P5, (unsigned long *) (& fields->f_ivc2_3u5));
 965       break;
 966     case MEP_OPERAND_IMM3P9 :
 967       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM3P9, (unsigned long *) (& fields->f_ivc2_3u9));
 968       break;
 969     case MEP_OPERAND_IMM4P10 :
 970       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM4P10, (unsigned long *) (& fields->f_ivc2_4u10));
 971       break;
 972     case MEP_OPERAND_IMM4P4 :
 973       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM4P4, (unsigned long *) (& fields->f_ivc2_4u4));
 974       break;
 975     case MEP_OPERAND_IMM4P8 :
 976       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM4P8, (unsigned long *) (& fields->f_ivc2_4u8));
 977       break;
 978     case MEP_OPERAND_IMM5P23 :
 979       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM5P23, (unsigned long *) (& fields->f_ivc2_5u23));
 980       break;
 981     case MEP_OPERAND_IMM5P3 :
 982       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM5P3, (unsigned long *) (& fields->f_ivc2_5u3));
 983       break;
 984     case MEP_OPERAND_IMM5P7 :
 985       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM5P7, (unsigned long *) (& fields->f_ivc2_5u7));
 986       break;
 987     case MEP_OPERAND_IMM5P8 :
 988       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM5P8, (unsigned long *) (& fields->f_ivc2_5u8));
 989       break;
 990     case MEP_OPERAND_IMM6P2 :
 991       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM6P2, (unsigned long *) (& fields->f_ivc2_6u2));
 992       break;
 993     case MEP_OPERAND_IMM6P6 :
 994       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM6P6, (unsigned long *) (& fields->f_ivc2_6u6));
 995       break;
 996     case MEP_OPERAND_IMM8P0 :
 997       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM8P0, (unsigned long *) (& fields->f_ivc2_8u0));
 998       break;
 999     case MEP_OPERAND_IMM8P20 :
1000       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM8P20, (unsigned long *) (& fields->f_ivc2_8u20));
1001       break;
1002     case MEP_OPERAND_IMM8P4 :
1003       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IMM8P4, (unsigned long *) (& fields->f_ivc2_8u4));
1004       break;
1005     case MEP_OPERAND_IVC_X_0_2 :
1006       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IVC_X_0_2, (unsigned long *) (& fields->f_ivc2_2u0));
1007       break;
1008     case MEP_OPERAND_IVC_X_0_3 :
1009       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IVC_X_0_3, (unsigned long *) (& fields->f_ivc2_3u0));
1010       break;
1011     case MEP_OPERAND_IVC_X_0_4 :
1012       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IVC_X_0_4, (unsigned long *) (& fields->f_ivc2_4u0));
1013       break;
1014     case MEP_OPERAND_IVC_X_0_5 :
1015       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IVC_X_0_5, (unsigned long *) (& fields->f_ivc2_5u0));
1016       break;
1017     case MEP_OPERAND_IVC_X_6_1 :
1018       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IVC_X_6_1, (unsigned long *) (& fields->f_ivc2_1u6));
1019       break;
1020     case MEP_OPERAND_IVC_X_6_2 :
1021       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IVC_X_6_2, (unsigned long *) (& fields->f_ivc2_2u6));
1022       break;
1023     case MEP_OPERAND_IVC_X_6_3 :
1024       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_IVC_X_6_3, (unsigned long *) (& fields->f_ivc2_3u6));
1025       break;
1026     case MEP_OPERAND_IVC2C3CCRN :
1027       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_ccr_ivc2, & fields->f_ivc2_ccrn_c3);
1028       break;
1029     case MEP_OPERAND_IVC2CCRN :
1030       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_ccr_ivc2, & fields->f_ivc2_ccrn);
1031       break;
1032     case MEP_OPERAND_IVC2CRN :
1033       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_cr64, & fields->f_ivc2_crnx);
1034       break;
1035     case MEP_OPERAND_IVC2RM :
1036       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_ivc2_crm);
1037       break;
1038     case MEP_OPERAND_LO :
1039       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
1040       break;
1041     case MEP_OPERAND_LP :
1042       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
1043       break;
1044     case MEP_OPERAND_MB0 :
1045       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
1046       break;
1047     case MEP_OPERAND_MB1 :
1048       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
1049       break;
1050     case MEP_OPERAND_ME0 :
1051       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
1052       break;
1053     case MEP_OPERAND_ME1 :
1054       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
1055       break;
1056     case MEP_OPERAND_NPC :
1057       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
1058       break;
1059     case MEP_OPERAND_OPT :
1060       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
1061       break;
1062     case MEP_OPERAND_PCABS24A2 :
1063       errmsg = parse_mep_alignu (cd, strp, MEP_OPERAND_PCABS24A2, (unsigned long *) (& fields->f_24u5a2n));
1064       break;
1065     case MEP_OPERAND_PCREL12A2 :
1066       errmsg = parse_mep_align (cd, strp, MEP_OPERAND_PCREL12A2, (long *) (& fields->f_12s4a2));
1067       break;
1068     case MEP_OPERAND_PCREL17A2 :
1069       errmsg = parse_mep_align (cd, strp, MEP_OPERAND_PCREL17A2, (long *) (& fields->f_17s16a2));
1070       break;
1071     case MEP_OPERAND_PCREL24A2 :
1072       errmsg = parse_mep_align (cd, strp, MEP_OPERAND_PCREL24A2, (long *) (& fields->f_24s5a2n));
1073       break;
1074     case MEP_OPERAND_PCREL8A2 :
1075       errmsg = parse_mep_align (cd, strp, MEP_OPERAND_PCREL8A2, (long *) (& fields->f_8s8a2));
1076       break;
1077     case MEP_OPERAND_PSW :
1078       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
1079       break;
1080     case MEP_OPERAND_R0 :
1081       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & junk);
1082       break;
1083     case MEP_OPERAND_R1 :
1084       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & junk);
1085       break;
1086     case MEP_OPERAND_RL :
1087       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rl);
1088       break;
1089     case MEP_OPERAND_RL5 :
1090       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rl5);
1091       break;
1092     case MEP_OPERAND_RM :
1093       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rm);
1094       break;
1095     case MEP_OPERAND_RMA :
1096       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rm);
1097       break;
1098     case MEP_OPERAND_RN :
1099       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn);
1100       break;
1101     case MEP_OPERAND_RN3 :
1102       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3);
1103       break;
1104     case MEP_OPERAND_RN3C :
1105       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3);
1106       break;
1107     case MEP_OPERAND_RN3L :
1108       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3);
1109       break;
1110     case MEP_OPERAND_RN3S :
1111       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3);
1112       break;
1113     case MEP_OPERAND_RN3UC :
1114       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3);
1115       break;
1116     case MEP_OPERAND_RN3UL :
1117       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3);
1118       break;
1119     case MEP_OPERAND_RN3US :
1120       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn3);
1121       break;
1122     case MEP_OPERAND_RNC :
1123       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn);
1124       break;
1125     case MEP_OPERAND_RNL :
1126       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn);
1127       break;
1128     case MEP_OPERAND_RNS :
1129       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn);
1130       break;
1131     case MEP_OPERAND_RNUC :
1132       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn);
1133       break;
1134     case MEP_OPERAND_RNUL :
1135       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn);
1136       break;
1137     case MEP_OPERAND_RNUS :
1138       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & fields->f_rn);
1139       break;
1140     case MEP_OPERAND_SAR :
1141       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_csr, & junk);
1142       break;
1143     case MEP_OPERAND_SDISP16 :
1144       errmsg = parse_signed16 (cd, strp, MEP_OPERAND_SDISP16, (long *) (& fields->f_16s16));
1145       break;
1146     case MEP_OPERAND_SIMM16 :
1147       errmsg = parse_signed16 (cd, strp, MEP_OPERAND_SIMM16, (long *) (& fields->f_16s16));
1148       break;
1149     case MEP_OPERAND_SIMM16P0 :
1150       errmsg = parse_signed16_range (cd, strp, MEP_OPERAND_SIMM16P0, (long *) (& fields->f_ivc2_simm16p0));
1151       break;
1152     case MEP_OPERAND_SIMM6 :
1153       errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_SIMM6, (long *) (& fields->f_6s8));
1154       break;
1155     case MEP_OPERAND_SIMM8 :
1156       errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_SIMM8, (long *) (& fields->f_8s8));
1157       break;
1158     case MEP_OPERAND_SIMM8P0 :
1159       errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_SIMM8P0, (long *) (& fields->f_ivc2_8s0));
1160       break;
1161     case MEP_OPERAND_SIMM8P20 :
1162       errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_SIMM8P20, (long *) (& fields->f_ivc2_8s20));
1163       break;
1164     case MEP_OPERAND_SIMM8P4 :
1165       errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_SIMM8P4, (long *) (& fields->f_ivc2_8s4));
1166       break;
1167     case MEP_OPERAND_SP :
1168       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & junk);
1169       break;
1170     case MEP_OPERAND_SPR :
1171       errmsg = parse_spreg (cd, strp, & mep_cgen_opval_h_gpr, & junk);
1172       break;
1173     case MEP_OPERAND_TP :
1174       errmsg = cgen_parse_keyword (cd, strp, & mep_cgen_opval_h_gpr, & junk);
1175       break;
1176     case MEP_OPERAND_TPR :
1177       errmsg = parse_tpreg (cd, strp, & mep_cgen_opval_h_gpr, & junk);
1178       break;
1179     case MEP_OPERAND_UDISP2 :
1180       errmsg = cgen_parse_signed_integer (cd, strp, MEP_OPERAND_UDISP2, (long *) (& fields->f_2u6));
1181       break;
1182     case MEP_OPERAND_UDISP7 :
1183       errmsg = parse_unsigned7 (cd, strp, MEP_OPERAND_UDISP7, (unsigned long *) (& fields->f_7u9));
1184       break;
1185     case MEP_OPERAND_UDISP7A2 :
1186       errmsg = parse_unsigned7 (cd, strp, MEP_OPERAND_UDISP7A2, (unsigned long *) (& fields->f_7u9a2));
1187       break;
1188     case MEP_OPERAND_UDISP7A4 :
1189       errmsg = parse_unsigned7 (cd, strp, MEP_OPERAND_UDISP7A4, (unsigned long *) (& fields->f_7u9a4));
1190       break;
1191     case MEP_OPERAND_UIMM16 :
1192       errmsg = parse_unsigned16 (cd, strp, MEP_OPERAND_UIMM16, (unsigned long *) (& fields->f_16u16));
1193       break;
1194     case MEP_OPERAND_UIMM2 :
1195       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM2, (unsigned long *) (& fields->f_2u10));
1196       break;
1197     case MEP_OPERAND_UIMM24 :
1198       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM24, (unsigned long *) (& fields->f_24u8n));
1199       break;
1200     case MEP_OPERAND_UIMM3 :
1201       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM3, (unsigned long *) (& fields->f_3u5));
1202       break;
1203     case MEP_OPERAND_UIMM4 :
1204       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM4, (unsigned long *) (& fields->f_4u8));
1205       break;
1206     case MEP_OPERAND_UIMM5 :
1207       errmsg = cgen_parse_unsigned_integer (cd, strp, MEP_OPERAND_UIMM5, (unsigned long *) (& fields->f_5u8));
1208       break;
1209     case MEP_OPERAND_UIMM7A4 :
1210       errmsg = parse_mep_alignu (cd, strp, MEP_OPERAND_UIMM7A4, (unsigned long *) (& fields->f_7u9a4));
1211       break;
1212     case MEP_OPERAND_ZERO :
1213       errmsg = parse_zero (cd, strp, MEP_OPERAND_ZERO, (long *) (& junk));
1214       break;
1215
1216     default :
1217       /* xgettext:c-format */
1218       fprintf (stderr, _("Unrecognized field %d while parsing.\n"), opindex);
1219       abort ();
1220   }
1221
1222   return errmsg;
1223 }
1224
1225 cgen_parse_fn * const mep_cgen_parse_handlers[] =
1226 {
1227   parse_insn_normal,
1228 };
1229
1230 void
1231 mep_cgen_init_asm (CGEN_CPU_DESC cd)
1232 {
1233   mep_cgen_init_opcode_table (cd);
1234   mep_cgen_init_ibld_table (cd);
1235   cd->parse_handlers = & mep_cgen_parse_handlers[0];
1236   cd->parse_operand = mep_cgen_parse_operand;
1237 #ifdef CGEN_ASM_INIT_HOOK
1238 CGEN_ASM_INIT_HOOK
1239 #endif
1240 }
1241
1242 \f
1243
1244 /* Regex construction routine.
1245
1246    This translates an opcode syntax string into a regex string,
1247    by replacing any non-character syntax element (such as an
1248    opcode) with the pattern '.*'
1249
1250    It then compiles the regex and stores it in the opcode, for
1251    later use by mep_cgen_assemble_insn
1252
1253    Returns NULL for success, an error message for failure.  */
1254
1255 char *
1256 mep_cgen_build_insn_regex (CGEN_INSN *insn)
1257 {
1258   CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
1259   const char *mnem = CGEN_INSN_MNEMONIC (insn);
1260   char rxbuf[CGEN_MAX_RX_ELEMENTS];
1261   char *rx = rxbuf;
1262   const CGEN_SYNTAX_CHAR_TYPE *syn;
1263   int reg_err;
1264
1265   syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
1266
1267   /* Mnemonics come first in the syntax string.  */
1268   if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
1269     return _("missing mnemonic in syntax string");
1270   ++syn;
1271
1272   /* Generate a case sensitive regular expression that emulates case
1273      insensitive matching in the "C" locale.  We cannot generate a case
1274      insensitive regular expression because in Turkish locales, 'i' and 'I'
1275      are not equal modulo case conversion.  */
1276
1277   /* Copy the literal mnemonic out of the insn.  */
1278   for (; *mnem; mnem++)
1279     {
1280       char c = *mnem;
1281
1282       if (ISALPHA (c))
1283         {
1284           *rx++ = '[';
1285           *rx++ = TOLOWER (c);
1286           *rx++ = TOUPPER (c);
1287           *rx++ = ']';
1288         }
1289       else
1290         *rx++ = c;
1291     }
1292
1293   /* Copy any remaining literals from the syntax string into the rx.  */
1294   for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
1295     {
1296       if (CGEN_SYNTAX_CHAR_P (* syn))
1297         {
1298           char c = CGEN_SYNTAX_CHAR (* syn);
1299
1300           switch (c)
1301             {
1302               /* Escape any regex metacharacters in the syntax.  */
1303             case '.': case '[': case '\\':
1304             case '*': case '^': case '$':
1305
1306 #ifdef CGEN_ESCAPE_EXTENDED_REGEX
1307             case '?': case '{': case '}':
1308             case '(': case ')': case '*':
1309             case '|': case '+': case ']':
1310 #endif
1311               *rx++ = '\\';
1312               *rx++ = c;
1313               break;
1314
1315             default:
1316               if (ISALPHA (c))
1317                 {
1318                   *rx++ = '[';
1319                   *rx++ = TOLOWER (c);
1320                   *rx++ = TOUPPER (c);
1321                   *rx++ = ']';
1322                 }
1323               else
1324                 *rx++ = c;
1325               break;
1326             }
1327         }
1328       else
1329         {
1330           /* Replace non-syntax fields with globs.  */
1331           *rx++ = '.';
1332           *rx++ = '*';
1333         }
1334     }
1335
1336   /* Trailing whitespace ok.  */
1337   * rx++ = '[';
1338   * rx++ = ' ';
1339   * rx++ = '\t';
1340   * rx++ = ']';
1341   * rx++ = '*';
1342
1343   /* But anchor it after that.  */
1344   * rx++ = '$';
1345   * rx = '\0';
1346
1347   CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
1348   reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
1349
1350   if (reg_err == 0)
1351     return NULL;
1352   else
1353     {
1354       static char msg[80];
1355
1356       regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
1357       regfree ((regex_t *) CGEN_INSN_RX (insn));
1358       free (CGEN_INSN_RX (insn));
1359       (CGEN_INSN_RX (insn)) = NULL;
1360       return msg;
1361     }
1362 }
1363
1364 \f
1365 /* Default insn parser.
1366
1367    The syntax string is scanned and operands are parsed and stored in FIELDS.
1368    Relocs are queued as we go via other callbacks.
1369
1370    ??? Note that this is currently an all-or-nothing parser.  If we fail to
1371    parse the instruction, we return 0 and the caller will start over from
1372    the beginning.  Backtracking will be necessary in parsing subexpressions,
1373    but that can be handled there.  Not handling backtracking here may get
1374    expensive in the case of the m68k.  Deal with later.
1375
1376    Returns NULL for success, an error message for failure.  */
1377
1378 static const char *
1379 parse_insn_normal (CGEN_CPU_DESC cd,
1380                    const CGEN_INSN *insn,
1381                    const char **strp,
1382                    CGEN_FIELDS *fields)
1383 {
1384   /* ??? Runtime added insns not handled yet.  */
1385   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
1386   const char *str = *strp;
1387   const char *errmsg;
1388   const char *p;
1389   const CGEN_SYNTAX_CHAR_TYPE * syn;
1390 #ifdef CGEN_MNEMONIC_OPERANDS
1391   /* FIXME: wip */
1392   int past_opcode_p;
1393 #endif
1394
1395   /* For now we assume the mnemonic is first (there are no leading operands).
1396      We can parse it without needing to set up operand parsing.
1397      GAS's input scrubber will ensure mnemonics are lowercase, but we may
1398      not be called from GAS.  */
1399   p = CGEN_INSN_MNEMONIC (insn);
1400   while (*p && TOLOWER (*p) == TOLOWER (*str))
1401     ++p, ++str;
1402
1403   if (* p)
1404     return _("unrecognized instruction");
1405
1406 #ifndef CGEN_MNEMONIC_OPERANDS
1407   if (* str && ! ISSPACE (* str))
1408     return _("unrecognized instruction");
1409 #endif
1410
1411   CGEN_INIT_PARSE (cd);
1412   cgen_init_parse_operand (cd);
1413 #ifdef CGEN_MNEMONIC_OPERANDS
1414   past_opcode_p = 0;
1415 #endif
1416
1417   /* We don't check for (*str != '\0') here because we want to parse
1418      any trailing fake arguments in the syntax string.  */
1419   syn = CGEN_SYNTAX_STRING (syntax);
1420
1421   /* Mnemonics come first for now, ensure valid string.  */
1422   if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
1423     abort ();
1424
1425   ++syn;
1426
1427   while (* syn != 0)
1428     {
1429       /* Non operand chars must match exactly.  */
1430       if (CGEN_SYNTAX_CHAR_P (* syn))
1431         {
1432           /* FIXME: While we allow for non-GAS callers above, we assume the
1433              first char after the mnemonic part is a space.  */
1434           /* FIXME: We also take inappropriate advantage of the fact that
1435              GAS's input scrubber will remove extraneous blanks.  */
1436           if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
1437             {
1438 #ifdef CGEN_MNEMONIC_OPERANDS
1439               if (CGEN_SYNTAX_CHAR(* syn) == ' ')
1440                 past_opcode_p = 1;
1441 #endif
1442               ++ syn;
1443               ++ str;
1444             }
1445           else if (*str)
1446             {
1447               /* Syntax char didn't match.  Can't be this insn.  */
1448               static char msg [80];
1449
1450               /* xgettext:c-format */
1451               sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
1452                        CGEN_SYNTAX_CHAR(*syn), *str);
1453               return msg;
1454             }
1455           else
1456             {
1457               /* Ran out of input.  */
1458               static char msg [80];
1459
1460               /* xgettext:c-format */
1461               sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
1462                        CGEN_SYNTAX_CHAR(*syn));
1463               return msg;
1464             }
1465           continue;
1466         }
1467
1468       /* We have an operand of some sort.  */
1469       errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn),
1470                                           &str, fields);
1471       if (errmsg)
1472         return errmsg;
1473
1474       /* Done with this operand, continue with next one.  */
1475       ++ syn;
1476     }
1477
1478   /* If we're at the end of the syntax string, we're done.  */
1479   if (* syn == 0)
1480     {
1481       /* FIXME: For the moment we assume a valid `str' can only contain
1482          blanks now.  IE: We needn't try again with a longer version of
1483          the insn and it is assumed that longer versions of insns appear
1484          before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3).  */
1485       while (ISSPACE (* str))
1486         ++ str;
1487
1488       if (* str != '\0')
1489         return _("junk at end of line"); /* FIXME: would like to include `str' */
1490
1491       return NULL;
1492     }
1493
1494   /* We couldn't parse it.  */
1495   return _("unrecognized instruction");
1496 }
1497 \f
1498 /* Main entry point.
1499    This routine is called for each instruction to be assembled.
1500    STR points to the insn to be assembled.
1501    We assume all necessary tables have been initialized.
1502    The assembled instruction, less any fixups, is stored in BUF.
1503    Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
1504    still needs to be converted to target byte order, otherwise BUF is an array
1505    of bytes in target byte order.
1506    The result is a pointer to the insn's entry in the opcode table,
1507    or NULL if an error occured (an error message will have already been
1508    printed).
1509
1510    Note that when processing (non-alias) macro-insns,
1511    this function recurses.
1512
1513    ??? It's possible to make this cpu-independent.
1514    One would have to deal with a few minor things.
1515    At this point in time doing so would be more of a curiosity than useful
1516    [for example this file isn't _that_ big], but keeping the possibility in
1517    mind helps keep the design clean.  */
1518
1519 const CGEN_INSN *
1520 mep_cgen_assemble_insn (CGEN_CPU_DESC cd,
1521                            const char *str,
1522                            CGEN_FIELDS *fields,
1523                            CGEN_INSN_BYTES_PTR buf,
1524                            char **errmsg)
1525 {
1526   const char *start;
1527   CGEN_INSN_LIST *ilist;
1528   const char *parse_errmsg = NULL;
1529   const char *insert_errmsg = NULL;
1530   int recognized_mnemonic = 0;
1531
1532   /* Skip leading white space.  */
1533   while (ISSPACE (* str))
1534     ++ str;
1535
1536   /* The instructions are stored in hashed lists.
1537      Get the first in the list.  */
1538   ilist = CGEN_ASM_LOOKUP_INSN (cd, str);
1539
1540   /* Keep looking until we find a match.  */
1541   start = str;
1542   for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
1543     {
1544       const CGEN_INSN *insn = ilist->insn;
1545       recognized_mnemonic = 1;
1546
1547 #ifdef CGEN_VALIDATE_INSN_SUPPORTED
1548       /* Not usually needed as unsupported opcodes
1549          shouldn't be in the hash lists.  */
1550       /* Is this insn supported by the selected cpu?  */
1551       if (! mep_cgen_insn_supported (cd, insn))
1552         continue;
1553 #endif
1554       /* If the RELAXED attribute is set, this is an insn that shouldn't be
1555          chosen immediately.  Instead, it is used during assembler/linker
1556          relaxation if possible.  */
1557       if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
1558         continue;
1559
1560       str = start;
1561
1562       /* Skip this insn if str doesn't look right lexically.  */
1563       if (CGEN_INSN_RX (insn) != NULL &&
1564           regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
1565         continue;
1566
1567       /* Allow parse/insert handlers to obtain length of insn.  */
1568       CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
1569
1570       parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
1571       if (parse_errmsg != NULL)
1572         continue;
1573
1574       /* ??? 0 is passed for `pc'.  */
1575       insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
1576                                                  (bfd_vma) 0);
1577       if (insert_errmsg != NULL)
1578         continue;
1579
1580       /* It is up to the caller to actually output the insn and any
1581          queued relocs.  */
1582       return insn;
1583     }
1584
1585   {
1586     static char errbuf[150];
1587 #ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
1588     const char *tmp_errmsg;
1589
1590     /* If requesting verbose error messages, use insert_errmsg.
1591        Failing that, use parse_errmsg.  */
1592     tmp_errmsg = (insert_errmsg ? insert_errmsg :
1593                   parse_errmsg ? parse_errmsg :
1594                   recognized_mnemonic ?
1595                   _("unrecognized form of instruction") :
1596                   _("unrecognized instruction"));
1597
1598     if (strlen (start) > 50)
1599       /* xgettext:c-format */
1600       sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
1601     else
1602       /* xgettext:c-format */
1603       sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
1604 #else
1605     if (strlen (start) > 50)
1606       /* xgettext:c-format */
1607       sprintf (errbuf, _("bad instruction `%.50s...'"), start);
1608     else
1609       /* xgettext:c-format */
1610       sprintf (errbuf, _("bad instruction `%.50s'"), start);
1611 #endif
1612
1613     *errmsg = errbuf;
1614     return NULL;
1615   }
1616 }