opcodes/m32c-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
   8    Free Software Foundation, Inc.
   9
  10    This file is part of the GNU Binutils and GDB, the GNU debugger.
  11
  12    This program 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 2, or (at your option)
  15    any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public 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 /* ??? Eventually more and more of this stuff can go to cpu-independent files.
  27    Keep that in mind.  */
  28
  29 #include "sysdep.h"
  30 #include <stdio.h>
  31 #include "ansidecl.h"
  32 #include "bfd.h"
  33 #include "symcat.h"
  34 #include "m32c-desc.h"
  35 #include "m32c-opc.h"
  36 #include "opintl.h"
  37 #include "xregex.h"
  38 #include "libiberty.h"
  39 #include "safe-ctype.h"
  40
  41 #undef  min
  42 #define min(a,b) ((a) < (b) ? (a) : (b))
  43 #undef  max
  44 #define max(a,b) ((a) > (b) ? (a) : (b))
  45
  46 static const char * parse_insn_normal
  47   (CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *);
  48 \f
  49 /* -- assembler routines inserted here.  */
  50
  51 /* -- asm.c */
  52 #include "safe-ctype.h"
  53
  54 #define MACH_M32C 5             /* Must match md_begin.  */
  55
  56 static int
  57 m32c_cgen_isa_register (const char **strp)
  58  {
  59    int u;
  60    const char *s = *strp;
  61    static char * m32c_register_names [] =
  62      {
  63        "r0", "r1", "r2", "r3", "r0l", "r0h", "r1l", "r1h",
  64        "a0", "a1", "r2r0", "r3r1", "sp", "fb", "dct0", "dct1", "flg", "svf",
  65        "drc0", "drc1", "dmd0", "dmd1", "intb", "svp", "vct", "isp", "dma0",
  66        "dma1", "dra0", "dra1", "dsa0", "dsa1", 0
  67      };
  68
  69    for (u = 0; m32c_register_names[u]; u++)
  70      {
  71        int len = strlen (m32c_register_names[u]);
  72
  73        if (memcmp (m32c_register_names[u], s, len) == 0
  74            && (s[len] == 0 || ! ISALNUM (s[len])))
  75         return 1;
  76      }
  77    return 0;
  78 }
  79
  80 #define PARSE_UNSIGNED                                                  \
  81   do                                                                    \
  82     {                                                                   \
  83       /* Don't successfully parse literals beginning with '['.  */      \
  84       if (**strp == '[')                                                \
  85         return "Invalid literal"; /* Anything -- will not be seen.  */  \
  86                                                                         \
  87       errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);\
  88       if (errmsg)                                                       \
  89         return errmsg;                                                  \
  90     }                                                                   \
  91   while (0)
  92
  93 #define PARSE_SIGNED                                                    \
  94   do                                                                    \
  95     {                                                                   \
  96       /* Don't successfully parse literals beginning with '['.  */      \
  97       if (**strp == '[')                                                \
  98         return "Invalid literal"; /* Anything -- will not be seen.  */  \
  99                                                                         \
 100       errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);  \
 101       if (errmsg)                                                       \
 102         return errmsg;                                                  \
 103     }                                                                   \
 104   while (0)
 105
 106 static const char *
 107 parse_unsigned6 (CGEN_CPU_DESC cd, const char **strp,
 108                  int opindex, unsigned long *valuep)
 109 {
 110   const char *errmsg = 0;
 111   unsigned long value;
 112
 113   PARSE_UNSIGNED;
 114
 115   if (value > 0x3f)
 116     return _("imm:6 immediate is out of range");
 117
 118   *valuep = value;
 119   return 0;
 120 }
 121
 122 static const char *
 123 parse_unsigned8 (CGEN_CPU_DESC cd, const char **strp,
 124                  int opindex, unsigned long *valuep)
 125 {
 126   const char *errmsg = 0;
 127   unsigned long value;
 128   long have_zero = 0;
 129
 130   if (strncasecmp (*strp, "%dsp8(", 6) == 0)
 131     {
 132       enum cgen_parse_operand_result result_type;
 133       bfd_vma value;
 134       const char *errmsg;
 135
 136       *strp += 6;
 137       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_8,
 138                                    & result_type, & value);
 139       if (**strp != ')')
 140         return _("missing `)'");
 141       (*strp) ++;
 142
 143       if (errmsg == NULL
 144           && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
 145         {
 146           return _("%dsp8() takes a symbolic address, not a number");
 147         }
 148       *valuep = value;
 149       return errmsg;
 150     }
 151
 152   if (strncmp (*strp, "0x0", 3) == 0
 153       || (**strp == '0' && *(*strp + 1) != 'x'))
 154     have_zero = 1;
 155
 156   PARSE_UNSIGNED;
 157
 158   if (value > 0xff)
 159     return _("dsp:8 immediate is out of range");
 160
 161   /* If this field may require a relocation then use larger dsp16.  */
 162   if (! have_zero && value == 0)
 163     return _("dsp:8 immediate is out of range");
 164
 165   *valuep = value;
 166   return 0;
 167 }
 168
 169 static const char *
 170 parse_signed4 (CGEN_CPU_DESC cd, const char **strp,
 171                int opindex, signed long *valuep)
 172 {
 173   const char *errmsg = 0;
 174   signed long value;
 175   long have_zero = 0;
 176
 177   if (strncmp (*strp, "0x0", 3) == 0
 178       || (**strp == '0' && *(*strp + 1) != 'x'))
 179     have_zero = 1;
 180
 181   PARSE_SIGNED;
 182
 183   if (value < -8 || value > 7)
 184     return _("Immediate is out of range -8 to 7");
 185
 186   /* If this field may require a relocation then use larger dsp16.  */
 187   if (! have_zero && value == 0)
 188     return _("Immediate is out of range -8 to 7");
 189
 190   *valuep = value;
 191   return 0;
 192 }
 193
 194 static const char *
 195 parse_signed4n (CGEN_CPU_DESC cd, const char **strp,
 196                 int opindex, signed long *valuep)
 197 {
 198   const char *errmsg = 0;
 199   signed long value;
 200   long have_zero = 0;
 201
 202   if (strncmp (*strp, "0x0", 3) == 0
 203       || (**strp == '0' && *(*strp + 1) != 'x'))
 204     have_zero = 1;
 205
 206   PARSE_SIGNED;
 207
 208   if (value < -7 || value > 8)
 209     return _("Immediate is out of range -7 to 8");
 210
 211   /* If this field may require a relocation then use larger dsp16.  */
 212   if (! have_zero && value == 0)
 213     return _("Immediate is out of range -7 to 8");
 214
 215   *valuep = -value;
 216   return 0;
 217 }
 218
 219 static const char *
 220 parse_signed8 (CGEN_CPU_DESC cd, const char **strp,
 221                int opindex, signed long *valuep)
 222 {
 223   const char *errmsg = 0;
 224   signed long value;
 225
 226   if (strncasecmp (*strp, "%hi8(", 5) == 0)
 227     {
 228       enum cgen_parse_operand_result result_type;
 229       bfd_vma value;
 230       const char *errmsg;
 231
 232       *strp += 5;
 233       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32C_HI8,
 234                                    & result_type, & value);
 235       if (**strp != ')')
 236         return _("missing `)'");
 237       (*strp) ++;
 238
 239       if (errmsg == NULL
 240           && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
 241         {
 242           value >>= 16;
 243         }
 244       *valuep = value;
 245       return errmsg;
 246     }
 247
 248   PARSE_SIGNED;
 249
 250   if (value <= 255 && value > 127)
 251     value -= 0x100;
 252
 253   if (value < -128 || value > 127)
 254     return _("dsp:8 immediate is out of range");
 255
 256   *valuep = value;
 257   return 0;
 258 }
 259
 260 static const char *
 261 parse_unsigned16 (CGEN_CPU_DESC cd, const char **strp,
 262                  int opindex, unsigned long *valuep)
 263 {
 264   const char *errmsg = 0;
 265   unsigned long value;
 266   long have_zero = 0;
 267
 268   if (strncasecmp (*strp, "%dsp16(", 7) == 0)
 269     {
 270       enum cgen_parse_operand_result result_type;
 271       bfd_vma value;
 272       const char *errmsg;
 273
 274       *strp += 7;
 275       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_16,
 276                                    & result_type, & value);
 277       if (**strp != ')')
 278         return _("missing `)'");
 279       (*strp) ++;
 280
 281       if (errmsg == NULL
 282           && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
 283         {
 284           return _("%dsp16() takes a symbolic address, not a number");
 285         }
 286       *valuep = value;
 287       return errmsg;
 288     }
 289
 290   /* Don't successfully parse literals beginning with '['.  */
 291   if (**strp == '[')
 292     return "Invalid literal"; /* Anything -- will not be seen.  */
 293
 294   /* Don't successfully parse register names.  */
 295   if (m32c_cgen_isa_register (strp))
 296     return "Invalid literal"; /* Anything -- will not be seen.  */
 297
 298   if (strncmp (*strp, "0x0", 3) == 0
 299       || (**strp == '0' && *(*strp + 1) != 'x'))
 300     have_zero = 1;
 301
 302   errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
 303   if (errmsg)
 304     return errmsg;
 305
 306   if (value > 0xffff)
 307     return _("dsp:16 immediate is out of range");
 308
 309   /* If this field may require a relocation then use larger dsp24.  */
 310   if (cd->machs == MACH_M32C && ! have_zero && value == 0
 311       && (strncmp (*strp, "[a", 2) == 0
 312           || **strp == ','
 313           || **strp == 0))
 314     return _("dsp:16 immediate is out of range");
 315
 316   *valuep = value;
 317   return 0;
 318 }
 319
 320 static const char *
 321 parse_signed16 (CGEN_CPU_DESC cd, const char **strp,
 322                int opindex, signed long *valuep)
 323 {
 324   const char *errmsg = 0;
 325   signed long value;
 326
 327   if (strncasecmp (*strp, "%lo16(", 6) == 0)
 328     {
 329       enum cgen_parse_operand_result result_type;
 330       bfd_vma value;
 331       const char *errmsg;
 332
 333       *strp += 6;
 334       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_LO16,
 335                                    & result_type, & value);
 336       if (**strp != ')')
 337         return _("missing `)'");
 338       (*strp) ++;
 339
 340       if (errmsg == NULL
 341           && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
 342         {
 343           value &= 0xffff;
 344         }
 345       *valuep = value;
 346       return errmsg;
 347     }
 348
 349   if (strncasecmp (*strp, "%hi16(", 6) == 0)
 350     {
 351       enum cgen_parse_operand_result result_type;
 352       bfd_vma value;
 353       const char *errmsg;
 354
 355       *strp += 6;
 356       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_HI16,
 357                                    & result_type, & value);
 358       if (**strp != ')')
 359         return _("missing `)'");
 360       (*strp) ++;
 361
 362       if (errmsg == NULL
 363           && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
 364         {
 365           value >>= 16;
 366         }
 367       *valuep = value;
 368       return errmsg;
 369     }
 370
 371   PARSE_SIGNED;
 372
 373   if (value <= 65535 && value > 32767)
 374     value -= 0x10000;
 375
 376   if (value < -32768 || value > 32767)
 377     return _("dsp:16 immediate is out of range");
 378
 379   *valuep = value;
 380   return 0;
 381 }
 382
 383 static const char *
 384 parse_unsigned20 (CGEN_CPU_DESC cd, const char **strp,
 385                  int opindex, unsigned long *valuep)
 386 {
 387   const char *errmsg = 0;
 388   unsigned long value;
 389
 390   /* Don't successfully parse literals beginning with '['.  */
 391   if (**strp == '[')
 392     return "Invalid literal"; /* Anything -- will not be seen.  */
 393
 394   /* Don't successfully parse register names.  */
 395   if (m32c_cgen_isa_register (strp))
 396     return "Invalid literal"; /* Anything -- will not be seen.  */
 397
 398   errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
 399   if (errmsg)
 400     return errmsg;
 401
 402   if (value > 0xfffff)
 403     return _("dsp:20 immediate is out of range");
 404
 405   *valuep = value;
 406   return 0;
 407 }
 408
 409 static const char *
 410 parse_unsigned24 (CGEN_CPU_DESC cd, const char **strp,
 411                  int opindex, unsigned long *valuep)
 412 {
 413   const char *errmsg = 0;
 414   unsigned long value;
 415
 416   /* Don't successfully parse literals beginning with '['.  */
 417   if (**strp == '[')
 418     return "Invalid literal"; /* Anything -- will not be seen.  */
 419
 420   /* Don't successfully parse register names.  */
 421   if (m32c_cgen_isa_register (strp))
 422     return "Invalid literal"; /* Anything -- will not be seen.  */
 423
 424   errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
 425   if (errmsg)
 426     return errmsg;
 427
 428   if (value > 0xffffff)
 429     return _("dsp:24 immediate is out of range");
 430
 431   *valuep = value;
 432   return 0;
 433 }
 434
 435 /* This should only be used for #imm->reg.  */
 436 static const char *
 437 parse_signed24 (CGEN_CPU_DESC cd, const char **strp,
 438                  int opindex, signed long *valuep)
 439 {
 440   const char *errmsg = 0;
 441   signed long value;
 442
 443   PARSE_SIGNED;
 444
 445   if (value <= 0xffffff && value > 0x7fffff)
 446     value -= 0x1000000;
 447
 448   if (value > 0xffffff)
 449     return _("dsp:24 immediate is out of range");
 450
 451   *valuep = value;
 452   return 0;
 453 }
 454
 455 static const char *
 456 parse_signed32 (CGEN_CPU_DESC cd, const char **strp,
 457                 int opindex, signed long *valuep)
 458 {
 459   const char *errmsg = 0;
 460   signed long value;
 461
 462   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
 463   if (errmsg)
 464     return errmsg;
 465
 466   *valuep = value;
 467   return 0;
 468 }
 469
 470 static const char *
 471 parse_imm1_S (CGEN_CPU_DESC cd, const char **strp,
 472              int opindex, signed long *valuep)
 473 {
 474   const char *errmsg = 0;
 475   signed long value;
 476
 477   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
 478   if (errmsg)
 479     return errmsg;
 480
 481   if (value < 1 || value > 2)
 482     return _("immediate is out of range 1-2");
 483
 484   *valuep = value;
 485   return 0;
 486 }
 487
 488 static const char *
 489 parse_imm3_S (CGEN_CPU_DESC cd, const char **strp,
 490              int opindex, signed long *valuep)
 491 {
 492   const char *errmsg = 0;
 493   signed long value;
 494
 495   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
 496   if (errmsg)
 497     return errmsg;
 498
 499   if (value < 1 || value > 8)
 500     return _("immediate is out of range 1-8");
 501
 502   *valuep = value;
 503   return 0;
 504 }
 505
 506 static const char *
 507 parse_bit3_S (CGEN_CPU_DESC cd, const char **strp,
 508              int opindex, signed long *valuep)
 509 {
 510   const char *errmsg = 0;
 511   signed long value;
 512
 513   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
 514   if (errmsg)
 515     return errmsg;
 516
 517   if (value < 0 || value > 7)
 518     return _("immediate is out of range 0-7");
 519
 520   *valuep = value;
 521   return 0;
 522 }
 523
 524 static const char *
 525 parse_lab_5_3 (CGEN_CPU_DESC cd,
 526                const char **strp,
 527                int opindex ATTRIBUTE_UNUSED,
 528                int opinfo,
 529                enum cgen_parse_operand_result *type_addr,
 530                bfd_vma *valuep)
 531 {
 532   const char *errmsg = 0;
 533   bfd_vma value;
 534   enum cgen_parse_operand_result op_res;
 535
 536   errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_5_3,
 537                                opinfo, & op_res, & value);
 538
 539   if (type_addr)
 540     *type_addr = op_res;
 541
 542   if (op_res == CGEN_PARSE_OPERAND_ADDRESS)
 543     {
 544       /* This is a hack; the field cannot handle near-zero signed
 545          offsets that CGEN wants to put in to indicate an "empty"
 546          operand at first.  */
 547       *valuep = 2;
 548       return 0;
 549     }
 550   if (errmsg)
 551     return errmsg;
 552
 553   if (value < 2 || value > 9)
 554     return _("immediate is out of range 2-9");
 555
 556   *valuep = value;
 557   return 0;
 558 }
 559
 560 static const char *
 561 parse_Bitno16R (CGEN_CPU_DESC cd, const char **strp,
 562                 int opindex, unsigned long *valuep)
 563 {
 564   const char *errmsg = 0;
 565   unsigned long value;
 566
 567   errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);
 568   if (errmsg)
 569     return errmsg;
 570
 571   if (value > 15)
 572     return _("Bit number for indexing general register is out of range 0-15");
 573
 574   *valuep = value;
 575   return 0;
 576 }
 577
 578 static const char *
 579 parse_unsigned_bitbase (CGEN_CPU_DESC cd, const char **strp,
 580                         int opindex, unsigned long *valuep,
 581                         unsigned bits, int allow_syms)
 582 {
 583   const char *errmsg = 0;
 584   unsigned long bit;
 585   unsigned long base;
 586   const char *newp = *strp;
 587   unsigned long long bitbase;
 588   long have_zero = 0;
 589
 590   errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & bit);
 591   if (errmsg)
 592     return errmsg;
 593
 594   if (*newp != ',')
 595     return "Missing base for bit,base:8";
 596
 597   ++newp;
 598
 599   if (strncmp (newp, "0x0", 3) == 0
 600       || (newp[0] == '0' && newp[1] != 'x'))
 601     have_zero = 1;
 602
 603   errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & base);
 604   if (errmsg)
 605     return errmsg;
 606
 607   bitbase = (unsigned long long) bit + ((unsigned long long) base * 8);
 608
 609   if (bitbase >= (1ull << bits))
 610     return _("bit,base is out of range");
 611
 612   /* If this field may require a relocation then use larger displacement.  */
 613   if (! have_zero && base == 0)
 614     {
 615       switch (allow_syms) {
 616       case 0:
 617         return _("bit,base out of range for symbol");
 618       case 1:
 619         break;
 620       case 2:
 621         if (strncmp (newp, "[sb]", 4) != 0)
 622           return _("bit,base out of range for symbol");
 623         break;
 624       }
 625     }
 626
 627   *valuep = bitbase;
 628   *strp = newp;
 629   return 0;
 630 }
 631
 632 static const char *
 633 parse_signed_bitbase (CGEN_CPU_DESC cd, const char **strp,
 634                       int opindex, signed long *valuep,
 635                       unsigned bits, int allow_syms)
 636 {
 637   const char *errmsg = 0;
 638   unsigned long bit;
 639   signed long base;
 640   const char *newp = *strp;
 641   long long bitbase;
 642   long long limit;
 643   long have_zero = 0;
 644
 645   errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & bit);
 646   if (errmsg)
 647     return errmsg;
 648
 649   if (*newp != ',')
 650     return "Missing base for bit,base:8";
 651
 652   ++newp;
 653
 654   if (strncmp (newp, "0x0", 3) == 0
 655       || (newp[0] == '0' && newp[1] != 'x'))
 656     have_zero = 1;
 657
 658   errmsg = cgen_parse_signed_integer (cd, & newp, opindex, & base);
 659   if (errmsg)
 660     return errmsg;
 661
 662   bitbase = (long long)bit + ((long long)base * 8);
 663
 664   limit = 1ll << (bits - 1);
 665   if (bitbase < -limit || bitbase >= limit)
 666     return _("bit,base is out of range");
 667
 668   /* If this field may require a relocation then use larger displacement.  */
 669   if (! have_zero && base == 0 && ! allow_syms)
 670     return _("bit,base out of range for symbol");
 671
 672   *valuep = bitbase;
 673   *strp = newp;
 674   return 0;
 675 }
 676
 677 static const char *
 678 parse_unsigned_bitbase8 (CGEN_CPU_DESC cd, const char **strp,
 679                          int opindex, unsigned long *valuep)
 680 {
 681   return parse_unsigned_bitbase (cd, strp, opindex, valuep, 8, 0);
 682 }
 683
 684 static const char *
 685 parse_unsigned_bitbase11 (CGEN_CPU_DESC cd, const char **strp,
 686                          int opindex, unsigned long *valuep)
 687 {
 688   return parse_unsigned_bitbase (cd, strp, opindex, valuep, 11, 0);
 689 }
 690
 691 static const char *
 692 parse_unsigned_bitbase16 (CGEN_CPU_DESC cd, const char **strp,
 693                           int opindex, unsigned long *valuep)
 694 {
 695   return parse_unsigned_bitbase (cd, strp, opindex, valuep, 16, 1);
 696 }
 697
 698 static const char *
 699 parse_unsigned_bitbase19 (CGEN_CPU_DESC cd, const char **strp,
 700                          int opindex, unsigned long *valuep)
 701 {
 702   return parse_unsigned_bitbase (cd, strp, opindex, valuep, 19, 2);
 703 }
 704
 705 static const char *
 706 parse_unsigned_bitbase27 (CGEN_CPU_DESC cd, const char **strp,
 707                          int opindex, unsigned long *valuep)
 708 {
 709   return parse_unsigned_bitbase (cd, strp, opindex, valuep, 27, 1);
 710 }
 711
 712 static const char *
 713 parse_signed_bitbase8 (CGEN_CPU_DESC cd, const char **strp,
 714                        int opindex, signed long *valuep)
 715 {
 716   return parse_signed_bitbase (cd, strp, opindex, valuep, 8, 1);
 717 }
 718
 719 static const char *
 720 parse_signed_bitbase11 (CGEN_CPU_DESC cd, const char **strp,
 721                        int opindex, signed long *valuep)
 722 {
 723   return parse_signed_bitbase (cd, strp, opindex, valuep, 11, 0);
 724 }
 725
 726 static const char *
 727 parse_signed_bitbase19 (CGEN_CPU_DESC cd, const char **strp,
 728                        int opindex, signed long *valuep)
 729 {
 730   return parse_signed_bitbase (cd, strp, opindex, valuep, 19, 1);
 731 }
 732
 733 /* Parse the suffix as :<char> or as nothing followed by a whitespace.  */
 734
 735 static const char *
 736 parse_suffix (const char **strp, char suffix)
 737 {
 738   const char *newp = *strp;
 739
 740   if (**strp == ':' && TOLOWER (*(*strp + 1)) == suffix)
 741     newp = *strp + 2;
 742
 743   if (ISSPACE (*newp))
 744     {
 745       *strp = newp;
 746       return 0;
 747     }
 748
 749   return "Invalid suffix"; /* Anything -- will not be seen.  */
 750 }
 751
 752 static const char *
 753 parse_S (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
 754          int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
 755 {
 756   return parse_suffix (strp, 's');
 757 }
 758
 759 static const char *
 760 parse_G (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
 761          int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
 762 {
 763   return parse_suffix (strp, 'g');
 764 }
 765
 766 static const char *
 767 parse_Q (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
 768          int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
 769 {
 770   return parse_suffix (strp, 'q');
 771 }
 772
 773 static const char *
 774 parse_Z (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
 775          int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
 776 {
 777   return parse_suffix (strp, 'z');
 778 }
 779
 780 /* Parse an empty suffix. Fail if the next char is ':'.  */
 781
 782 static const char *
 783 parse_X (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
 784          int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
 785 {
 786   if (**strp == ':')
 787     return "Unexpected suffix";
 788   return 0;
 789 }
 790
 791 static const char *
 792 parse_r0l_r0h (CGEN_CPU_DESC cd, const char **strp,
 793                int opindex ATTRIBUTE_UNUSED, signed long *valuep)
 794 {
 795   const char *errmsg;
 796   signed long value;
 797   signed long junk;
 798   const char *newp = *strp;
 799
 800   /* Parse r0[hl].  */
 801   errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0l_r0h, & value);
 802   if (errmsg)
 803     return errmsg;
 804
 805   if (*newp != ',')
 806     return _("not a valid r0l/r0h pair");
 807   ++newp;
 808
 809   /* Parse the second register in the pair.  */
 810   if (value == 0) /* r0l */
 811     errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0h, & junk);
 812   else
 813     errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0l, & junk);
 814   if (errmsg)
 815     return errmsg;
 816
 817   *strp = newp;
 818   *valuep = ! value;
 819   return 0;
 820 }
 821
 822 /* Accept .b or .w in any case.  */
 823
 824 static const char *
 825 parse_size (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,
 826             int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)
 827 {
 828   if (**strp == '.'
 829       && (*(*strp + 1) == 'b' || *(*strp + 1) == 'B'
 830           || *(*strp + 1) == 'w' || *(*strp + 1) == 'W'))
 831     {
 832       *strp += 2;
 833       return NULL;
 834     }
 835
 836   return _("Invalid size specifier");
 837 }
 838
 839 /* Special check to ensure that instruction exists for given machine.  */
 840
 841 int
 842 m32c_cgen_insn_supported (CGEN_CPU_DESC cd,
 843                           const CGEN_INSN *insn)
 844 {
 845   int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH);
 846   CGEN_BITSET isas = CGEN_INSN_BITSET_ATTR_VALUE (insn, CGEN_INSN_ISA);
 847
 848   /* If attributes are absent, assume no restriction.  */
 849   if (machs == 0)
 850     machs = ~0;
 851
 852   return ((machs & cd->machs)
 853           && cgen_bitset_intersect_p (& isas, cd->isas));
 854 }
 855
 856 /* Parse a set of registers, R0,R1,A0,A1,SB,FB.  */
 857
 858 static const char *
 859 parse_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 860               const char **strp,
 861               int opindex ATTRIBUTE_UNUSED,
 862               unsigned long *valuep,
 863               int push)
 864 {
 865   const char *errmsg = 0;
 866   int regno = 0;
 867
 868   *valuep = 0;
 869   while (**strp && **strp != ')')
 870     {
 871       if (**strp == 'r' || **strp == 'R')
 872         {
 873           ++*strp;
 874           regno = **strp - '0';
 875           if (regno > 4)
 876             errmsg = _("Register number is not valid");
 877         }
 878       else if (**strp == 'a' || **strp == 'A')
 879         {
 880           ++*strp;
 881           regno = **strp - '0';
 882           if (regno > 2)
 883             errmsg = _("Register number is not valid");
 884           regno = **strp - '0' + 4;
 885         }
 886
 887       else if (strncasecmp (*strp, "sb", 2) == 0 || strncasecmp (*strp, "SB", 2) == 0)
 888         {
 889           regno = 6;
 890           ++*strp;
 891         }
 892
 893       else if (strncasecmp (*strp, "fb", 2) == 0 || strncasecmp (*strp, "FB", 2) == 0)
 894         {
 895           regno = 7;
 896           ++*strp;
 897         }
 898
 899       if (push) /* Mask is reversed for push.  */
 900         *valuep |= 0x80 >> regno;
 901       else
 902         *valuep |= 1 << regno;
 903
 904       ++*strp;
 905       if (**strp == ',')
 906         {
 907           if (*(*strp + 1) == ')')
 908             break;
 909           ++*strp;
 910         }
 911     }
 912
 913   if (!*strp)
 914     errmsg = _("Register list is not valid");
 915
 916   return errmsg;
 917 }
 918
 919 #define POP  0
 920 #define PUSH 1
 921
 922 static const char *
 923 parse_pop_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 924                   const char **strp,
 925                   int opindex ATTRIBUTE_UNUSED,
 926                   unsigned long *valuep)
 927 {
 928   return parse_regset (cd, strp, opindex, valuep, POP);
 929 }
 930
 931 static const char *
 932 parse_push_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 933                    const char **strp,
 934                    int opindex ATTRIBUTE_UNUSED,
 935                    unsigned long *valuep)
 936 {
 937   return parse_regset (cd, strp, opindex, valuep, PUSH);
 938 }
 939
 940 /* -- dis.c */
 941
 942 const char * m32c_cgen_parse_operand
 943   (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
 944
 945 /* Main entry point for operand parsing.
 946
 947    This function is basically just a big switch statement.  Earlier versions
 948    used tables to look up the function to use, but
 949    - if the table contains both assembler and disassembler functions then
 950      the disassembler contains much of the assembler and vice-versa,
 951    - there's a lot of inlining possibilities as things grow,
 952    - using a switch statement avoids the function call overhead.
 953
 954    This function could be moved into `parse_insn_normal', but keeping it
 955    separate makes clear the interface between `parse_insn_normal' and each of
 956    the handlers.  */
 957
 958 const char *
 959 m32c_cgen_parse_operand (CGEN_CPU_DESC cd,
 960                            int opindex,
 961                            const char ** strp,
 962                            CGEN_FIELDS * fields)
 963 {
 964   const char * errmsg = NULL;
 965   /* Used by scalar operands that still need to be parsed.  */
 966   long junk ATTRIBUTE_UNUSED;
 967
 968   switch (opindex)
 969     {
 970     case M32C_OPERAND_A0 :
 971       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_a0, & junk);
 972       break;
 973     case M32C_OPERAND_A1 :
 974       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_a1, & junk);
 975       break;
 976     case M32C_OPERAND_AN16_PUSH_S :
 977       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_4_1);
 978       break;
 979     case M32C_OPERAND_BIT16AN :
 980       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst16_an);
 981       break;
 982     case M32C_OPERAND_BIT16RN :
 983       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_dst16_rn);
 984       break;
 985     case M32C_OPERAND_BIT3_S :
 986       errmsg = parse_bit3_S (cd, strp, M32C_OPERAND_BIT3_S, (long *) (& fields->f_imm3_S));
 987       break;
 988     case M32C_OPERAND_BIT32ANPREFIXED :
 989       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_prefixed);
 990       break;
 991     case M32C_OPERAND_BIT32ANUNPREFIXED :
 992       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_unprefixed);
 993       break;
 994     case M32C_OPERAND_BIT32RNPREFIXED :
 995       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_dst32_rn_prefixed_QI);
 996       break;
 997     case M32C_OPERAND_BIT32RNUNPREFIXED :
 998       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_dst32_rn_unprefixed_QI);
 999       break;
1000     case M32C_OPERAND_BITBASE16_16_S8 :
1001       errmsg = parse_signed_bitbase8 (cd, strp, M32C_OPERAND_BITBASE16_16_S8, (long *) (& fields->f_dsp_16_s8));
1002       break;
1003     case M32C_OPERAND_BITBASE16_16_U16 :
1004       errmsg = parse_unsigned_bitbase16 (cd, strp, M32C_OPERAND_BITBASE16_16_U16, (unsigned long *) (& fields->f_dsp_16_u16));
1005       break;
1006     case M32C_OPERAND_BITBASE16_16_U8 :
1007       errmsg = parse_unsigned_bitbase8 (cd, strp, M32C_OPERAND_BITBASE16_16_U8, (unsigned long *) (& fields->f_dsp_16_u8));
1008       break;
1009     case M32C_OPERAND_BITBASE16_8_U11_S :
1010       errmsg = parse_unsigned_bitbase11 (cd, strp, M32C_OPERAND_BITBASE16_8_U11_S, (unsigned long *) (& fields->f_bitbase16_u11_S));
1011       break;
1012     case M32C_OPERAND_BITBASE32_16_S11_UNPREFIXED :
1013       errmsg = parse_signed_bitbase11 (cd, strp, M32C_OPERAND_BITBASE32_16_S11_UNPREFIXED, (long *) (& fields->f_bitbase32_16_s11_unprefixed));
1014       break;
1015     case M32C_OPERAND_BITBASE32_16_S19_UNPREFIXED :
1016       errmsg = parse_signed_bitbase19 (cd, strp, M32C_OPERAND_BITBASE32_16_S19_UNPREFIXED, (long *) (& fields->f_bitbase32_16_s19_unprefixed));
1017       break;
1018     case M32C_OPERAND_BITBASE32_16_U11_UNPREFIXED :
1019       errmsg = parse_unsigned_bitbase11 (cd, strp, M32C_OPERAND_BITBASE32_16_U11_UNPREFIXED, (unsigned long *) (& fields->f_bitbase32_16_u11_unprefixed));
1020       break;
1021     case M32C_OPERAND_BITBASE32_16_U19_UNPREFIXED :
1022       errmsg = parse_unsigned_bitbase19 (cd, strp, M32C_OPERAND_BITBASE32_16_U19_UNPREFIXED, (unsigned long *) (& fields->f_bitbase32_16_u19_unprefixed));
1023       break;
1024     case M32C_OPERAND_BITBASE32_16_U27_UNPREFIXED :
1025       errmsg = parse_unsigned_bitbase27 (cd, strp, M32C_OPERAND_BITBASE32_16_U27_UNPREFIXED, (unsigned long *) (& fields->f_bitbase32_16_u27_unprefixed));
1026       break;
1027     case M32C_OPERAND_BITBASE32_24_S11_PREFIXED :
1028       errmsg = parse_signed_bitbase11 (cd, strp, M32C_OPERAND_BITBASE32_24_S11_PREFIXED, (long *) (& fields->f_bitbase32_24_s11_prefixed));
1029       break;
1030     case M32C_OPERAND_BITBASE32_24_S19_PREFIXED :
1031       errmsg = parse_signed_bitbase19 (cd, strp, M32C_OPERAND_BITBASE32_24_S19_PREFIXED, (long *) (& fields->f_bitbase32_24_s19_prefixed));
1032       break;
1033     case M32C_OPERAND_BITBASE32_24_U11_PREFIXED :
1034       errmsg = parse_unsigned_bitbase11 (cd, strp, M32C_OPERAND_BITBASE32_24_U11_PREFIXED, (unsigned long *) (& fields->f_bitbase32_24_u11_prefixed));
1035       break;
1036     case M32C_OPERAND_BITBASE32_24_U19_PREFIXED :
1037       errmsg = parse_unsigned_bitbase19 (cd, strp, M32C_OPERAND_BITBASE32_24_U19_PREFIXED, (unsigned long *) (& fields->f_bitbase32_24_u19_prefixed));
1038       break;
1039     case M32C_OPERAND_BITBASE32_24_U27_PREFIXED :
1040       errmsg = parse_unsigned_bitbase27 (cd, strp, M32C_OPERAND_BITBASE32_24_U27_PREFIXED, (unsigned long *) (& fields->f_bitbase32_24_u27_prefixed));
1041       break;
1042     case M32C_OPERAND_BITNO16R :
1043       errmsg = parse_Bitno16R (cd, strp, M32C_OPERAND_BITNO16R, (unsigned long *) (& fields->f_dsp_16_u8));
1044       break;
1045     case M32C_OPERAND_BITNO32PREFIXED :
1046       errmsg = cgen_parse_unsigned_integer (cd, strp, M32C_OPERAND_BITNO32PREFIXED, (unsigned long *) (& fields->f_bitno32_prefixed));
1047       break;
1048     case M32C_OPERAND_BITNO32UNPREFIXED :
1049       errmsg = cgen_parse_unsigned_integer (cd, strp, M32C_OPERAND_BITNO32UNPREFIXED, (unsigned long *) (& fields->f_bitno32_unprefixed));
1050       break;
1051     case M32C_OPERAND_DSP_10_U6 :
1052       errmsg = parse_unsigned6 (cd, strp, M32C_OPERAND_DSP_10_U6, (unsigned long *) (& fields->f_dsp_10_u6));
1053       break;
1054     case M32C_OPERAND_DSP_16_S16 :
1055       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_DSP_16_S16, (long *) (& fields->f_dsp_16_s16));
1056       break;
1057     case M32C_OPERAND_DSP_16_S8 :
1058       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_DSP_16_S8, (long *) (& fields->f_dsp_16_s8));
1059       break;
1060     case M32C_OPERAND_DSP_16_U16 :
1061       errmsg = parse_unsigned16 (cd, strp, M32C_OPERAND_DSP_16_U16, (unsigned long *) (& fields->f_dsp_16_u16));
1062       break;
1063     case M32C_OPERAND_DSP_16_U20 :
1064       errmsg = parse_unsigned20 (cd, strp, M32C_OPERAND_DSP_16_U20, (unsigned long *) (& fields->f_dsp_16_u24));
1065       break;
1066     case M32C_OPERAND_DSP_16_U24 :
1067       errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_16_U24, (unsigned long *) (& fields->f_dsp_16_u24));
1068       break;
1069     case M32C_OPERAND_DSP_16_U8 :
1070       errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_16_U8, (unsigned long *) (& fields->f_dsp_16_u8));
1071       break;
1072     case M32C_OPERAND_DSP_24_S16 :
1073       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_DSP_24_S16, (long *) (& fields->f_dsp_24_s16));
1074       break;
1075     case M32C_OPERAND_DSP_24_S8 :
1076       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_DSP_24_S8, (long *) (& fields->f_dsp_24_s8));
1077       break;
1078     case M32C_OPERAND_DSP_24_U16 :
1079       errmsg = parse_unsigned16 (cd, strp, M32C_OPERAND_DSP_24_U16, (unsigned long *) (& fields->f_dsp_24_u16));
1080       break;
1081     case M32C_OPERAND_DSP_24_U20 :
1082       errmsg = parse_unsigned20 (cd, strp, M32C_OPERAND_DSP_24_U20, (unsigned long *) (& fields->f_dsp_24_u24));
1083       break;
1084     case M32C_OPERAND_DSP_24_U24 :
1085       errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_24_U24, (unsigned long *) (& fields->f_dsp_24_u24));
1086       break;
1087     case M32C_OPERAND_DSP_24_U8 :
1088       errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_24_U8, (unsigned long *) (& fields->f_dsp_24_u8));
1089       break;
1090     case M32C_OPERAND_DSP_32_S16 :
1091       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_DSP_32_S16, (long *) (& fields->f_dsp_32_s16));
1092       break;
1093     case M32C_OPERAND_DSP_32_S8 :
1094       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_DSP_32_S8, (long *) (& fields->f_dsp_32_s8));
1095       break;
1096     case M32C_OPERAND_DSP_32_U16 :
1097       errmsg = parse_unsigned16 (cd, strp, M32C_OPERAND_DSP_32_U16, (unsigned long *) (& fields->f_dsp_32_u16));
1098       break;
1099     case M32C_OPERAND_DSP_32_U20 :
1100       errmsg = parse_unsigned20 (cd, strp, M32C_OPERAND_DSP_32_U20, (unsigned long *) (& fields->f_dsp_32_u24));
1101       break;
1102     case M32C_OPERAND_DSP_32_U24 :
1103       errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_32_U24, (unsigned long *) (& fields->f_dsp_32_u24));
1104       break;
1105     case M32C_OPERAND_DSP_32_U8 :
1106       errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_32_U8, (unsigned long *) (& fields->f_dsp_32_u8));
1107       break;
1108     case M32C_OPERAND_DSP_40_S16 :
1109       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_DSP_40_S16, (long *) (& fields->f_dsp_40_s16));
1110       break;
1111     case M32C_OPERAND_DSP_40_S8 :
1112       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_DSP_40_S8, (long *) (& fields->f_dsp_40_s8));
1113       break;
1114     case M32C_OPERAND_DSP_40_U16 :
1115       errmsg = parse_unsigned16 (cd, strp, M32C_OPERAND_DSP_40_U16, (unsigned long *) (& fields->f_dsp_40_u16));
1116       break;
1117     case M32C_OPERAND_DSP_40_U20 :
1118       errmsg = parse_unsigned20 (cd, strp, M32C_OPERAND_DSP_40_U20, (unsigned long *) (& fields->f_dsp_40_u20));
1119       break;
1120     case M32C_OPERAND_DSP_40_U24 :
1121       errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_40_U24, (unsigned long *) (& fields->f_dsp_40_u24));
1122       break;
1123     case M32C_OPERAND_DSP_40_U8 :
1124       errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_40_U8, (unsigned long *) (& fields->f_dsp_40_u8));
1125       break;
1126     case M32C_OPERAND_DSP_48_S16 :
1127       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_DSP_48_S16, (long *) (& fields->f_dsp_48_s16));
1128       break;
1129     case M32C_OPERAND_DSP_48_S8 :
1130       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_DSP_48_S8, (long *) (& fields->f_dsp_48_s8));
1131       break;
1132     case M32C_OPERAND_DSP_48_U16 :
1133       errmsg = parse_unsigned16 (cd, strp, M32C_OPERAND_DSP_48_U16, (unsigned long *) (& fields->f_dsp_48_u16));
1134       break;
1135     case M32C_OPERAND_DSP_48_U20 :
1136       errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_48_U20, (unsigned long *) (& fields->f_dsp_48_u20));
1137       break;
1138     case M32C_OPERAND_DSP_48_U24 :
1139       errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_48_U24, (unsigned long *) (& fields->f_dsp_48_u24));
1140       break;
1141     case M32C_OPERAND_DSP_48_U8 :
1142       errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_48_U8, (unsigned long *) (& fields->f_dsp_48_u8));
1143       break;
1144     case M32C_OPERAND_DSP_8_S24 :
1145       errmsg = parse_signed24 (cd, strp, M32C_OPERAND_DSP_8_S24, (long *) (& fields->f_dsp_8_s24));
1146       break;
1147     case M32C_OPERAND_DSP_8_S8 :
1148       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_DSP_8_S8, (long *) (& fields->f_dsp_8_s8));
1149       break;
1150     case M32C_OPERAND_DSP_8_U16 :
1151       errmsg = parse_unsigned16 (cd, strp, M32C_OPERAND_DSP_8_U16, (unsigned long *) (& fields->f_dsp_8_u16));
1152       break;
1153     case M32C_OPERAND_DSP_8_U24 :
1154       errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_8_U24, (unsigned long *) (& fields->f_dsp_8_u24));
1155       break;
1156     case M32C_OPERAND_DSP_8_U6 :
1157       errmsg = parse_unsigned6 (cd, strp, M32C_OPERAND_DSP_8_U6, (unsigned long *) (& fields->f_dsp_8_u6));
1158       break;
1159     case M32C_OPERAND_DSP_8_U8 :
1160       errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_8_U8, (unsigned long *) (& fields->f_dsp_8_u8));
1161       break;
1162     case M32C_OPERAND_DST16AN :
1163       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst16_an);
1164       break;
1165     case M32C_OPERAND_DST16AN_S :
1166       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_dst16_an_s);
1167       break;
1168     case M32C_OPERAND_DST16ANHI :
1169       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_dst16_an);
1170       break;
1171     case M32C_OPERAND_DST16ANQI :
1172       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_dst16_an);
1173       break;
1174     case M32C_OPERAND_DST16ANQI_S :
1175       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_dst16_rn_QI_s);
1176       break;
1177     case M32C_OPERAND_DST16ANSI :
1178       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_SI, & fields->f_dst16_an);
1179       break;
1180     case M32C_OPERAND_DST16RNEXTQI :
1181       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_ext_QI, & fields->f_dst16_rn_ext);
1182       break;
1183     case M32C_OPERAND_DST16RNHI :
1184       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_dst16_rn);
1185       break;
1186     case M32C_OPERAND_DST16RNQI :
1187       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_dst16_rn);
1188       break;
1189     case M32C_OPERAND_DST16RNQI_S :
1190       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0l_r0h, & fields->f_dst16_rn_QI_s);
1191       break;
1192     case M32C_OPERAND_DST16RNSI :
1193       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_dst16_rn);
1194       break;
1195     case M32C_OPERAND_DST32ANEXTUNPREFIXED :
1196       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_unprefixed);
1197       break;
1198     case M32C_OPERAND_DST32ANPREFIXED :
1199       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_prefixed);
1200       break;
1201     case M32C_OPERAND_DST32ANPREFIXEDHI :
1202       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_dst32_an_prefixed);
1203       break;
1204     case M32C_OPERAND_DST32ANPREFIXEDQI :
1205       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_dst32_an_prefixed);
1206       break;
1207     case M32C_OPERAND_DST32ANPREFIXEDSI :
1208       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_prefixed);
1209       break;
1210     case M32C_OPERAND_DST32ANUNPREFIXED :
1211       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_unprefixed);
1212       break;
1213     case M32C_OPERAND_DST32ANUNPREFIXEDHI :
1214       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_dst32_an_unprefixed);
1215       break;
1216     case M32C_OPERAND_DST32ANUNPREFIXEDQI :
1217       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_dst32_an_unprefixed);
1218       break;
1219     case M32C_OPERAND_DST32ANUNPREFIXEDSI :
1220       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_unprefixed);
1221       break;
1222     case M32C_OPERAND_DST32R0HI_S :
1223       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0, & junk);
1224       break;
1225     case M32C_OPERAND_DST32R0QI_S :
1226       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0l, & junk);
1227       break;
1228     case M32C_OPERAND_DST32RNEXTUNPREFIXEDHI :
1229       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_ext_HI, & fields->f_dst32_rn_ext_unprefixed);
1230       break;
1231     case M32C_OPERAND_DST32RNEXTUNPREFIXEDQI :
1232       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_ext_QI, & fields->f_dst32_rn_ext_unprefixed);
1233       break;
1234     case M32C_OPERAND_DST32RNPREFIXEDHI :
1235       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_dst32_rn_prefixed_HI);
1236       break;
1237     case M32C_OPERAND_DST32RNPREFIXEDQI :
1238       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_dst32_rn_prefixed_QI);
1239       break;
1240     case M32C_OPERAND_DST32RNPREFIXEDSI :
1241       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_dst32_rn_prefixed_SI);
1242       break;
1243     case M32C_OPERAND_DST32RNUNPREFIXEDHI :
1244       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_dst32_rn_unprefixed_HI);
1245       break;
1246     case M32C_OPERAND_DST32RNUNPREFIXEDQI :
1247       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_dst32_rn_unprefixed_QI);
1248       break;
1249     case M32C_OPERAND_DST32RNUNPREFIXEDSI :
1250       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_dst32_rn_unprefixed_SI);
1251       break;
1252     case M32C_OPERAND_G :
1253       errmsg = parse_G (cd, strp, M32C_OPERAND_G, (long *) (& junk));
1254       break;
1255     case M32C_OPERAND_IMM_12_S4 :
1256       errmsg = parse_signed4 (cd, strp, M32C_OPERAND_IMM_12_S4, (long *) (& fields->f_imm_12_s4));
1257       break;
1258     case M32C_OPERAND_IMM_12_S4N :
1259       errmsg = parse_signed4n (cd, strp, M32C_OPERAND_IMM_12_S4N, (long *) (& fields->f_imm_12_s4));
1260       break;
1261     case M32C_OPERAND_IMM_13_U3 :
1262       errmsg = parse_signed4 (cd, strp, M32C_OPERAND_IMM_13_U3, (long *) (& fields->f_imm_13_u3));
1263       break;
1264     case M32C_OPERAND_IMM_16_HI :
1265       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_16_HI, (long *) (& fields->f_dsp_16_s16));
1266       break;
1267     case M32C_OPERAND_IMM_16_QI :
1268       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_16_QI, (long *) (& fields->f_dsp_16_s8));
1269       break;
1270     case M32C_OPERAND_IMM_16_SI :
1271       errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_16_SI, (long *) (& fields->f_dsp_16_s32));
1272       break;
1273     case M32C_OPERAND_IMM_20_S4 :
1274       errmsg = parse_signed4 (cd, strp, M32C_OPERAND_IMM_20_S4, (long *) (& fields->f_imm_20_s4));
1275       break;
1276     case M32C_OPERAND_IMM_24_HI :
1277       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_24_HI, (long *) (& fields->f_dsp_24_s16));
1278       break;
1279     case M32C_OPERAND_IMM_24_QI :
1280       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_24_QI, (long *) (& fields->f_dsp_24_s8));
1281       break;
1282     case M32C_OPERAND_IMM_24_SI :
1283       errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_24_SI, (long *) (& fields->f_dsp_24_s32));
1284       break;
1285     case M32C_OPERAND_IMM_32_HI :
1286       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_32_HI, (long *) (& fields->f_dsp_32_s16));
1287       break;
1288     case M32C_OPERAND_IMM_32_QI :
1289       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_32_QI, (long *) (& fields->f_dsp_32_s8));
1290       break;
1291     case M32C_OPERAND_IMM_32_SI :
1292       errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_32_SI, (long *) (& fields->f_dsp_32_s32));
1293       break;
1294     case M32C_OPERAND_IMM_40_HI :
1295       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_40_HI, (long *) (& fields->f_dsp_40_s16));
1296       break;
1297     case M32C_OPERAND_IMM_40_QI :
1298       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_40_QI, (long *) (& fields->f_dsp_40_s8));
1299       break;
1300     case M32C_OPERAND_IMM_40_SI :
1301       errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_40_SI, (long *) (& fields->f_dsp_40_s32));
1302       break;
1303     case M32C_OPERAND_IMM_48_HI :
1304       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_48_HI, (long *) (& fields->f_dsp_48_s16));
1305       break;
1306     case M32C_OPERAND_IMM_48_QI :
1307       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_48_QI, (long *) (& fields->f_dsp_48_s8));
1308       break;
1309     case M32C_OPERAND_IMM_48_SI :
1310       errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_48_SI, (long *) (& fields->f_dsp_48_s32));
1311       break;
1312     case M32C_OPERAND_IMM_56_HI :
1313       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_56_HI, (long *) (& fields->f_dsp_56_s16));
1314       break;
1315     case M32C_OPERAND_IMM_56_QI :
1316       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_56_QI, (long *) (& fields->f_dsp_56_s8));
1317       break;
1318     case M32C_OPERAND_IMM_64_HI :
1319       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_64_HI, (long *) (& fields->f_dsp_64_s16));
1320       break;
1321     case M32C_OPERAND_IMM_8_HI :
1322       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_8_HI, (long *) (& fields->f_dsp_8_s16));
1323       break;
1324     case M32C_OPERAND_IMM_8_QI :
1325       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_8_QI, (long *) (& fields->f_dsp_8_s8));
1326       break;
1327     case M32C_OPERAND_IMM_8_S4 :
1328       errmsg = parse_signed4 (cd, strp, M32C_OPERAND_IMM_8_S4, (long *) (& fields->f_imm_8_s4));
1329       break;
1330     case M32C_OPERAND_IMM_8_S4N :
1331       errmsg = parse_signed4n (cd, strp, M32C_OPERAND_IMM_8_S4N, (long *) (& fields->f_imm_8_s4));
1332       break;
1333     case M32C_OPERAND_IMM_SH_12_S4 :
1334       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_shimm, & fields->f_imm_12_s4);
1335       break;
1336     case M32C_OPERAND_IMM_SH_20_S4 :
1337       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_shimm, & fields->f_imm_20_s4);
1338       break;
1339     case M32C_OPERAND_IMM_SH_8_S4 :
1340       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_shimm, & fields->f_imm_8_s4);
1341       break;
1342     case M32C_OPERAND_IMM1_S :
1343       errmsg = parse_imm1_S (cd, strp, M32C_OPERAND_IMM1_S, (long *) (& fields->f_imm1_S));
1344       break;
1345     case M32C_OPERAND_IMM3_S :
1346       errmsg = parse_imm3_S (cd, strp, M32C_OPERAND_IMM3_S, (long *) (& fields->f_imm3_S));
1347       break;
1348     case M32C_OPERAND_LAB_16_8 :
1349       {
1350         bfd_vma value = 0;
1351         errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_16_8, 0, NULL,  & value);
1352         fields->f_lab_16_8 = value;
1353       }
1354       break;
1355     case M32C_OPERAND_LAB_24_8 :
1356       {
1357         bfd_vma value = 0;
1358         errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_24_8, 0, NULL,  & value);
1359         fields->f_lab_24_8 = value;
1360       }
1361       break;
1362     case M32C_OPERAND_LAB_32_8 :
1363       {
1364         bfd_vma value = 0;
1365         errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_32_8, 0, NULL,  & value);
1366         fields->f_lab_32_8 = value;
1367       }
1368       break;
1369     case M32C_OPERAND_LAB_40_8 :
1370       {
1371         bfd_vma value = 0;
1372         errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_40_8, 0, NULL,  & value);
1373         fields->f_lab_40_8 = value;
1374       }
1375       break;
1376     case M32C_OPERAND_LAB_5_3 :
1377       {
1378         bfd_vma value = 0;
1379         errmsg = parse_lab_5_3 (cd, strp, M32C_OPERAND_LAB_5_3, 0, NULL,  & value);
1380         fields->f_lab_5_3 = value;
1381       }
1382       break;
1383     case M32C_OPERAND_LAB_8_16 :
1384       {
1385         bfd_vma value = 0;
1386         errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_8_16, 0, NULL,  & value);
1387         fields->f_lab_8_16 = value;
1388       }
1389       break;
1390     case M32C_OPERAND_LAB_8_24 :
1391       {
1392         bfd_vma value = 0;
1393         errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_8_24, 0, NULL,  & value);
1394         fields->f_lab_8_24 = value;
1395       }
1396       break;
1397     case M32C_OPERAND_LAB_8_8 :
1398       {
1399         bfd_vma value = 0;
1400         errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_8_8, 0, NULL,  & value);
1401         fields->f_lab_8_8 = value;
1402       }
1403       break;
1404     case M32C_OPERAND_LAB32_JMP_S :
1405       {
1406         bfd_vma value = 0;
1407         errmsg = parse_lab_5_3 (cd, strp, M32C_OPERAND_LAB32_JMP_S, 0, NULL,  & value);
1408         fields->f_lab32_jmp_s = value;
1409       }
1410       break;
1411     case M32C_OPERAND_Q :
1412       errmsg = parse_Q (cd, strp, M32C_OPERAND_Q, (long *) (& junk));
1413       break;
1414     case M32C_OPERAND_R0 :
1415       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0, & junk);
1416       break;
1417     case M32C_OPERAND_R0H :
1418       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0h, & junk);
1419       break;
1420     case M32C_OPERAND_R0L :
1421       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0l, & junk);
1422       break;
1423     case M32C_OPERAND_R1 :
1424       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r1, & junk);
1425       break;
1426     case M32C_OPERAND_R1R2R0 :
1427       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r1r2r0, & junk);
1428       break;
1429     case M32C_OPERAND_R2 :
1430       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r2, & junk);
1431       break;
1432     case M32C_OPERAND_R2R0 :
1433       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r2r0, & junk);
1434       break;
1435     case M32C_OPERAND_R3 :
1436       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r3, & junk);
1437       break;
1438     case M32C_OPERAND_R3R1 :
1439       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r3r1, & junk);
1440       break;
1441     case M32C_OPERAND_REGSETPOP :
1442       errmsg = parse_pop_regset (cd, strp, M32C_OPERAND_REGSETPOP, (unsigned long *) (& fields->f_8_8));
1443       break;
1444     case M32C_OPERAND_REGSETPUSH :
1445       errmsg = parse_push_regset (cd, strp, M32C_OPERAND_REGSETPUSH, (unsigned long *) (& fields->f_8_8));
1446       break;
1447     case M32C_OPERAND_RN16_PUSH_S :
1448       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_4_1);
1449       break;
1450     case M32C_OPERAND_S :
1451       errmsg = parse_S (cd, strp, M32C_OPERAND_S, (long *) (& junk));
1452       break;
1453     case M32C_OPERAND_SRC16AN :
1454       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src16_an);
1455       break;
1456     case M32C_OPERAND_SRC16ANHI :
1457       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_src16_an);
1458       break;
1459     case M32C_OPERAND_SRC16ANQI :
1460       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_src16_an);
1461       break;
1462     case M32C_OPERAND_SRC16RNHI :
1463       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_src16_rn);
1464       break;
1465     case M32C_OPERAND_SRC16RNQI :
1466       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_src16_rn);
1467       break;
1468     case M32C_OPERAND_SRC32ANPREFIXED :
1469       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src32_an_prefixed);
1470       break;
1471     case M32C_OPERAND_SRC32ANPREFIXEDHI :
1472       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_src32_an_prefixed);
1473       break;
1474     case M32C_OPERAND_SRC32ANPREFIXEDQI :
1475       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_src32_an_prefixed);
1476       break;
1477     case M32C_OPERAND_SRC32ANPREFIXEDSI :
1478       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src32_an_prefixed);
1479       break;
1480     case M32C_OPERAND_SRC32ANUNPREFIXED :
1481       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src32_an_unprefixed);
1482       break;
1483     case M32C_OPERAND_SRC32ANUNPREFIXEDHI :
1484       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_src32_an_unprefixed);
1485       break;
1486     case M32C_OPERAND_SRC32ANUNPREFIXEDQI :
1487       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_src32_an_unprefixed);
1488       break;
1489     case M32C_OPERAND_SRC32ANUNPREFIXEDSI :
1490       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src32_an_unprefixed);
1491       break;
1492     case M32C_OPERAND_SRC32RNPREFIXEDHI :
1493       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_src32_rn_prefixed_HI);
1494       break;
1495     case M32C_OPERAND_SRC32RNPREFIXEDQI :
1496       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_src32_rn_prefixed_QI);
1497       break;
1498     case M32C_OPERAND_SRC32RNPREFIXEDSI :
1499       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_src32_rn_prefixed_SI);
1500       break;
1501     case M32C_OPERAND_SRC32RNUNPREFIXEDHI :
1502       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_src32_rn_unprefixed_HI);
1503       break;
1504     case M32C_OPERAND_SRC32RNUNPREFIXEDQI :
1505       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_src32_rn_unprefixed_QI);
1506       break;
1507     case M32C_OPERAND_SRC32RNUNPREFIXEDSI :
1508       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_src32_rn_unprefixed_SI);
1509       break;
1510     case M32C_OPERAND_SRCDST16_R0L_R0H_S_NORMAL :
1511       errmsg = parse_r0l_r0h (cd, strp, M32C_OPERAND_SRCDST16_R0L_R0H_S_NORMAL, (long *) (& fields->f_5_1));
1512       break;
1513     case M32C_OPERAND_X :
1514       errmsg = parse_X (cd, strp, M32C_OPERAND_X, (long *) (& junk));
1515       break;
1516     case M32C_OPERAND_Z :
1517       errmsg = parse_Z (cd, strp, M32C_OPERAND_Z, (long *) (& junk));
1518       break;
1519     case M32C_OPERAND_COND16_16 :
1520       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16, & fields->f_dsp_16_u8);
1521       break;
1522     case M32C_OPERAND_COND16_24 :
1523       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16, & fields->f_dsp_24_u8);
1524       break;
1525     case M32C_OPERAND_COND16_32 :
1526       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16, & fields->f_dsp_32_u8);
1527       break;
1528     case M32C_OPERAND_COND16C :
1529       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16c, & fields->f_cond16);
1530       break;
1531     case M32C_OPERAND_COND16J :
1532       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16j, & fields->f_cond16);
1533       break;
1534     case M32C_OPERAND_COND16J5 :
1535       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16j_5, & fields->f_cond16j_5);
1536       break;
1537     case M32C_OPERAND_COND32 :
1538       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_cond32);
1539       break;
1540     case M32C_OPERAND_COND32_16 :
1541       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_dsp_16_u8);
1542       break;
1543     case M32C_OPERAND_COND32_24 :
1544       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_dsp_24_u8);
1545       break;
1546     case M32C_OPERAND_COND32_32 :
1547       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_dsp_32_u8);
1548       break;
1549     case M32C_OPERAND_COND32_40 :
1550       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_dsp_40_u8);
1551       break;
1552     case M32C_OPERAND_COND32J :
1553       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_cond32j);
1554       break;
1555     case M32C_OPERAND_CR1_PREFIXED_32 :
1556       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr1_32, & fields->f_21_3);
1557       break;
1558     case M32C_OPERAND_CR1_UNPREFIXED_32 :
1559       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr1_32, & fields->f_13_3);
1560       break;
1561     case M32C_OPERAND_CR16 :
1562       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr_16, & fields->f_9_3);
1563       break;
1564     case M32C_OPERAND_CR2_32 :
1565       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr2_32, & fields->f_13_3);
1566       break;
1567     case M32C_OPERAND_CR3_PREFIXED_32 :
1568       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr3_32, & fields->f_21_3);
1569       break;
1570     case M32C_OPERAND_CR3_UNPREFIXED_32 :
1571       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr3_32, & fields->f_13_3);
1572       break;
1573     case M32C_OPERAND_FLAGS16 :
1574       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_flags, & fields->f_9_3);
1575       break;
1576     case M32C_OPERAND_FLAGS32 :
1577       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_flags, & fields->f_13_3);
1578       break;
1579     case M32C_OPERAND_SCCOND32 :
1580       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_cond16);
1581       break;
1582     case M32C_OPERAND_SIZE :
1583       errmsg = parse_size (cd, strp, M32C_OPERAND_SIZE, (long *) (& junk));
1584       break;
1585
1586     default :
1587       /* xgettext:c-format */
1588       fprintf (stderr, _("Unrecognized field %d while parsing.\n"), opindex);
1589       abort ();
1590   }
1591
1592   return errmsg;
1593 }
1594
1595 cgen_parse_fn * const m32c_cgen_parse_handlers[] =
1596 {
1597   parse_insn_normal,
1598 };
1599
1600 void
1601 m32c_cgen_init_asm (CGEN_CPU_DESC cd)
1602 {
1603   m32c_cgen_init_opcode_table (cd);
1604   m32c_cgen_init_ibld_table (cd);
1605   cd->parse_handlers = & m32c_cgen_parse_handlers[0];
1606   cd->parse_operand = m32c_cgen_parse_operand;
1607 #ifdef CGEN_ASM_INIT_HOOK
1608 CGEN_ASM_INIT_HOOK
1609 #endif
1610 }
1611
1612 \f
1613
1614 /* Regex construction routine.
1615
1616    This translates an opcode syntax string into a regex string,
1617    by replacing any non-character syntax element (such as an
1618    opcode) with the pattern '.*'
1619
1620    It then compiles the regex and stores it in the opcode, for
1621    later use by m32c_cgen_assemble_insn
1622
1623    Returns NULL for success, an error message for failure.  */
1624
1625 char *
1626 m32c_cgen_build_insn_regex (CGEN_INSN *insn)
1627 {
1628   CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
1629   const char *mnem = CGEN_INSN_MNEMONIC (insn);
1630   char rxbuf[CGEN_MAX_RX_ELEMENTS];
1631   char *rx = rxbuf;
1632   const CGEN_SYNTAX_CHAR_TYPE *syn;
1633   int reg_err;
1634
1635   syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
1636
1637   /* Mnemonics come first in the syntax string.  */
1638   if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
1639     return _("missing mnemonic in syntax string");
1640   ++syn;
1641
1642   /* Generate a case sensitive regular expression that emulates case
1643      insensitive matching in the "C" locale.  We cannot generate a case
1644      insensitive regular expression because in Turkish locales, 'i' and 'I'
1645      are not equal modulo case conversion.  */
1646
1647   /* Copy the literal mnemonic out of the insn.  */
1648   for (; *mnem; mnem++)
1649     {
1650       char c = *mnem;
1651
1652       if (ISALPHA (c))
1653         {
1654           *rx++ = '[';
1655           *rx++ = TOLOWER (c);
1656           *rx++ = TOUPPER (c);
1657           *rx++ = ']';
1658         }
1659       else
1660         *rx++ = c;
1661     }
1662
1663   /* Copy any remaining literals from the syntax string into the rx.  */
1664   for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
1665     {
1666       if (CGEN_SYNTAX_CHAR_P (* syn))
1667         {
1668           char c = CGEN_SYNTAX_CHAR (* syn);
1669
1670           switch (c)
1671             {
1672               /* Escape any regex metacharacters in the syntax.  */
1673             case '.': case '[': case '\\':
1674             case '*': case '^': case '$':
1675
1676 #ifdef CGEN_ESCAPE_EXTENDED_REGEX
1677             case '?': case '{': case '}':
1678             case '(': case ')': case '*':
1679             case '|': case '+': case ']':
1680 #endif
1681               *rx++ = '\\';
1682               *rx++ = c;
1683               break;
1684
1685             default:
1686               if (ISALPHA (c))
1687                 {
1688                   *rx++ = '[';
1689                   *rx++ = TOLOWER (c);
1690                   *rx++ = TOUPPER (c);
1691                   *rx++ = ']';
1692                 }
1693               else
1694                 *rx++ = c;
1695               break;
1696             }
1697         }
1698       else
1699         {
1700           /* Replace non-syntax fields with globs.  */
1701           *rx++ = '.';
1702           *rx++ = '*';
1703         }
1704     }
1705
1706   /* Trailing whitespace ok.  */
1707   * rx++ = '[';
1708   * rx++ = ' ';
1709   * rx++ = '\t';
1710   * rx++ = ']';
1711   * rx++ = '*';
1712
1713   /* But anchor it after that.  */
1714   * rx++ = '$';
1715   * rx = '\0';
1716
1717   CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
1718   reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
1719
1720   if (reg_err == 0)
1721     return NULL;
1722   else
1723     {
1724       static char msg[80];
1725
1726       regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
1727       regfree ((regex_t *) CGEN_INSN_RX (insn));
1728       free (CGEN_INSN_RX (insn));
1729       (CGEN_INSN_RX (insn)) = NULL;
1730       return msg;
1731     }
1732 }
1733
1734 \f
1735 /* Default insn parser.
1736
1737    The syntax string is scanned and operands are parsed and stored in FIELDS.
1738    Relocs are queued as we go via other callbacks.
1739
1740    ??? Note that this is currently an all-or-nothing parser.  If we fail to
1741    parse the instruction, we return 0 and the caller will start over from
1742    the beginning.  Backtracking will be necessary in parsing subexpressions,
1743    but that can be handled there.  Not handling backtracking here may get
1744    expensive in the case of the m68k.  Deal with later.
1745
1746    Returns NULL for success, an error message for failure.  */
1747
1748 static const char *
1749 parse_insn_normal (CGEN_CPU_DESC cd,
1750                    const CGEN_INSN *insn,
1751                    const char **strp,
1752                    CGEN_FIELDS *fields)
1753 {
1754   /* ??? Runtime added insns not handled yet.  */
1755   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
1756   const char *str = *strp;
1757   const char *errmsg;
1758   const char *p;
1759   const CGEN_SYNTAX_CHAR_TYPE * syn;
1760 #ifdef CGEN_MNEMONIC_OPERANDS
1761   /* FIXME: wip */
1762   int past_opcode_p;
1763 #endif
1764
1765   /* For now we assume the mnemonic is first (there are no leading operands).
1766      We can parse it without needing to set up operand parsing.
1767      GAS's input scrubber will ensure mnemonics are lowercase, but we may
1768      not be called from GAS.  */
1769   p = CGEN_INSN_MNEMONIC (insn);
1770   while (*p && TOLOWER (*p) == TOLOWER (*str))
1771     ++p, ++str;
1772
1773   if (* p)
1774     return _("unrecognized instruction");
1775
1776 #ifndef CGEN_MNEMONIC_OPERANDS
1777   if (* str && ! ISSPACE (* str))
1778     return _("unrecognized instruction");
1779 #endif
1780
1781   CGEN_INIT_PARSE (cd);
1782   cgen_init_parse_operand (cd);
1783 #ifdef CGEN_MNEMONIC_OPERANDS
1784   past_opcode_p = 0;
1785 #endif
1786
1787   /* We don't check for (*str != '\0') here because we want to parse
1788      any trailing fake arguments in the syntax string.  */
1789   syn = CGEN_SYNTAX_STRING (syntax);
1790
1791   /* Mnemonics come first for now, ensure valid string.  */
1792   if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
1793     abort ();
1794
1795   ++syn;
1796
1797   while (* syn != 0)
1798     {
1799       /* Non operand chars must match exactly.  */
1800       if (CGEN_SYNTAX_CHAR_P (* syn))
1801         {
1802           /* FIXME: While we allow for non-GAS callers above, we assume the
1803              first char after the mnemonic part is a space.  */
1804           /* FIXME: We also take inappropriate advantage of the fact that
1805              GAS's input scrubber will remove extraneous blanks.  */
1806           if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
1807             {
1808 #ifdef CGEN_MNEMONIC_OPERANDS
1809               if (CGEN_SYNTAX_CHAR(* syn) == ' ')
1810                 past_opcode_p = 1;
1811 #endif
1812               ++ syn;
1813               ++ str;
1814             }
1815           else if (*str)
1816             {
1817               /* Syntax char didn't match.  Can't be this insn.  */
1818               static char msg [80];
1819
1820               /* xgettext:c-format */
1821               sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
1822                        CGEN_SYNTAX_CHAR(*syn), *str);
1823               return msg;
1824             }
1825           else
1826             {
1827               /* Ran out of input.  */
1828               static char msg [80];
1829
1830               /* xgettext:c-format */
1831               sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
1832                        CGEN_SYNTAX_CHAR(*syn));
1833               return msg;
1834             }
1835           continue;
1836         }
1837
1838       /* We have an operand of some sort.  */
1839       errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn),
1840                                           &str, fields);
1841       if (errmsg)
1842         return errmsg;
1843
1844       /* Done with this operand, continue with next one.  */
1845       ++ syn;
1846     }
1847
1848   /* If we're at the end of the syntax string, we're done.  */
1849   if (* syn == 0)
1850     {
1851       /* FIXME: For the moment we assume a valid `str' can only contain
1852          blanks now.  IE: We needn't try again with a longer version of
1853          the insn and it is assumed that longer versions of insns appear
1854          before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3).  */
1855       while (ISSPACE (* str))
1856         ++ str;
1857
1858       if (* str != '\0')
1859         return _("junk at end of line"); /* FIXME: would like to include `str' */
1860
1861       return NULL;
1862     }
1863
1864   /* We couldn't parse it.  */
1865   return _("unrecognized instruction");
1866 }
1867 \f
1868 /* Main entry point.
1869    This routine is called for each instruction to be assembled.
1870    STR points to the insn to be assembled.
1871    We assume all necessary tables have been initialized.
1872    The assembled instruction, less any fixups, is stored in BUF.
1873    Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
1874    still needs to be converted to target byte order, otherwise BUF is an array
1875    of bytes in target byte order.
1876    The result is a pointer to the insn's entry in the opcode table,
1877    or NULL if an error occured (an error message will have already been
1878    printed).
1879
1880    Note that when processing (non-alias) macro-insns,
1881    this function recurses.
1882
1883    ??? It's possible to make this cpu-independent.
1884    One would have to deal with a few minor things.
1885    At this point in time doing so would be more of a curiosity than useful
1886    [for example this file isn't _that_ big], but keeping the possibility in
1887    mind helps keep the design clean.  */
1888
1889 const CGEN_INSN *
1890 m32c_cgen_assemble_insn (CGEN_CPU_DESC cd,
1891                            const char *str,
1892                            CGEN_FIELDS *fields,
1893                            CGEN_INSN_BYTES_PTR buf,
1894                            char **errmsg)
1895 {
1896   const char *start;
1897   CGEN_INSN_LIST *ilist;
1898   const char *parse_errmsg = NULL;
1899   const char *insert_errmsg = NULL;
1900   int recognized_mnemonic = 0;
1901
1902   /* Skip leading white space.  */
1903   while (ISSPACE (* str))
1904     ++ str;
1905
1906   /* The instructions are stored in hashed lists.
1907      Get the first in the list.  */
1908   ilist = CGEN_ASM_LOOKUP_INSN (cd, str);
1909
1910   /* Keep looking until we find a match.  */
1911   start = str;
1912   for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
1913     {
1914       const CGEN_INSN *insn = ilist->insn;
1915       recognized_mnemonic = 1;
1916
1917 #ifdef CGEN_VALIDATE_INSN_SUPPORTED
1918       /* Not usually needed as unsupported opcodes
1919          shouldn't be in the hash lists.  */
1920       /* Is this insn supported by the selected cpu?  */
1921       if (! m32c_cgen_insn_supported (cd, insn))
1922         continue;
1923 #endif
1924       /* If the RELAXED attribute is set, this is an insn that shouldn't be
1925          chosen immediately.  Instead, it is used during assembler/linker
1926          relaxation if possible.  */
1927       if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
1928         continue;
1929
1930       str = start;
1931
1932       /* Skip this insn if str doesn't look right lexically.  */
1933       if (CGEN_INSN_RX (insn) != NULL &&
1934           regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
1935         continue;
1936
1937       /* Allow parse/insert handlers to obtain length of insn.  */
1938       CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
1939
1940       parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
1941       if (parse_errmsg != NULL)
1942         continue;
1943
1944       /* ??? 0 is passed for `pc'.  */
1945       insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
1946                                                  (bfd_vma) 0);
1947       if (insert_errmsg != NULL)
1948         continue;
1949
1950       /* It is up to the caller to actually output the insn and any
1951          queued relocs.  */
1952       return insn;
1953     }
1954
1955   {
1956     static char errbuf[150];
1957 #ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
1958     const char *tmp_errmsg;
1959
1960     /* If requesting verbose error messages, use insert_errmsg.
1961        Failing that, use parse_errmsg.  */
1962     tmp_errmsg = (insert_errmsg ? insert_errmsg :
1963                   parse_errmsg ? parse_errmsg :
1964                   recognized_mnemonic ?
1965                   _("unrecognized form of instruction") :
1966                   _("unrecognized instruction"));
1967
1968     if (strlen (start) > 50)
1969       /* xgettext:c-format */
1970       sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
1971     else
1972       /* xgettext:c-format */
1973       sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
1974 #else
1975     if (strlen (start) > 50)
1976       /* xgettext:c-format */
1977       sprintf (errbuf, _("bad instruction `%.50s...'"), start);
1978     else
1979       /* xgettext:c-format */
1980       sprintf (errbuf, _("bad instruction `%.50s'"), start);
1981 #endif
1982
1983     *errmsg = errbuf;
1984     return NULL;
1985   }
1986 }