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_U24 :
1118       errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_40_U24, (unsigned long *) (& fields->f_dsp_40_u24));
1119       break;
1120     case M32C_OPERAND_DSP_40_U8 :
1121       errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_40_U8, (unsigned long *) (& fields->f_dsp_40_u8));
1122       break;
1123     case M32C_OPERAND_DSP_48_S16 :
1124       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_DSP_48_S16, (long *) (& fields->f_dsp_48_s16));
1125       break;
1126     case M32C_OPERAND_DSP_48_S8 :
1127       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_DSP_48_S8, (long *) (& fields->f_dsp_48_s8));
1128       break;
1129     case M32C_OPERAND_DSP_48_U16 :
1130       errmsg = parse_unsigned16 (cd, strp, M32C_OPERAND_DSP_48_U16, (unsigned long *) (& fields->f_dsp_48_u16));
1131       break;
1132     case M32C_OPERAND_DSP_48_U24 :
1133       errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_48_U24, (unsigned long *) (& fields->f_dsp_48_u24));
1134       break;
1135     case M32C_OPERAND_DSP_48_U8 :
1136       errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_48_U8, (unsigned long *) (& fields->f_dsp_48_u8));
1137       break;
1138     case M32C_OPERAND_DSP_8_S24 :
1139       errmsg = parse_signed24 (cd, strp, M32C_OPERAND_DSP_8_S24, (long *) (& fields->f_dsp_8_s24));
1140       break;
1141     case M32C_OPERAND_DSP_8_S8 :
1142       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_DSP_8_S8, (long *) (& fields->f_dsp_8_s8));
1143       break;
1144     case M32C_OPERAND_DSP_8_U16 :
1145       errmsg = parse_unsigned16 (cd, strp, M32C_OPERAND_DSP_8_U16, (unsigned long *) (& fields->f_dsp_8_u16));
1146       break;
1147     case M32C_OPERAND_DSP_8_U24 :
1148       errmsg = parse_unsigned24 (cd, strp, M32C_OPERAND_DSP_8_U24, (unsigned long *) (& fields->f_dsp_8_u24));
1149       break;
1150     case M32C_OPERAND_DSP_8_U6 :
1151       errmsg = parse_unsigned6 (cd, strp, M32C_OPERAND_DSP_8_U6, (unsigned long *) (& fields->f_dsp_8_u6));
1152       break;
1153     case M32C_OPERAND_DSP_8_U8 :
1154       errmsg = parse_unsigned8 (cd, strp, M32C_OPERAND_DSP_8_U8, (unsigned long *) (& fields->f_dsp_8_u8));
1155       break;
1156     case M32C_OPERAND_DST16AN :
1157       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst16_an);
1158       break;
1159     case M32C_OPERAND_DST16AN_S :
1160       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_dst16_an_s);
1161       break;
1162     case M32C_OPERAND_DST16ANHI :
1163       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_dst16_an);
1164       break;
1165     case M32C_OPERAND_DST16ANQI :
1166       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_dst16_an);
1167       break;
1168     case M32C_OPERAND_DST16ANQI_S :
1169       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_dst16_rn_QI_s);
1170       break;
1171     case M32C_OPERAND_DST16ANSI :
1172       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_SI, & fields->f_dst16_an);
1173       break;
1174     case M32C_OPERAND_DST16RNEXTQI :
1175       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_ext_QI, & fields->f_dst16_rn_ext);
1176       break;
1177     case M32C_OPERAND_DST16RNHI :
1178       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_dst16_rn);
1179       break;
1180     case M32C_OPERAND_DST16RNQI :
1181       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_dst16_rn);
1182       break;
1183     case M32C_OPERAND_DST16RNQI_S :
1184       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0l_r0h, & fields->f_dst16_rn_QI_s);
1185       break;
1186     case M32C_OPERAND_DST16RNSI :
1187       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_dst16_rn);
1188       break;
1189     case M32C_OPERAND_DST32ANEXTUNPREFIXED :
1190       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_unprefixed);
1191       break;
1192     case M32C_OPERAND_DST32ANPREFIXED :
1193       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_prefixed);
1194       break;
1195     case M32C_OPERAND_DST32ANPREFIXEDHI :
1196       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_dst32_an_prefixed);
1197       break;
1198     case M32C_OPERAND_DST32ANPREFIXEDQI :
1199       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_dst32_an_prefixed);
1200       break;
1201     case M32C_OPERAND_DST32ANPREFIXEDSI :
1202       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_prefixed);
1203       break;
1204     case M32C_OPERAND_DST32ANUNPREFIXED :
1205       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_unprefixed);
1206       break;
1207     case M32C_OPERAND_DST32ANUNPREFIXEDHI :
1208       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_dst32_an_unprefixed);
1209       break;
1210     case M32C_OPERAND_DST32ANUNPREFIXEDQI :
1211       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_dst32_an_unprefixed);
1212       break;
1213     case M32C_OPERAND_DST32ANUNPREFIXEDSI :
1214       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_dst32_an_unprefixed);
1215       break;
1216     case M32C_OPERAND_DST32R0HI_S :
1217       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0, & junk);
1218       break;
1219     case M32C_OPERAND_DST32R0QI_S :
1220       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0l, & junk);
1221       break;
1222     case M32C_OPERAND_DST32RNEXTUNPREFIXEDHI :
1223       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_ext_HI, & fields->f_dst32_rn_ext_unprefixed);
1224       break;
1225     case M32C_OPERAND_DST32RNEXTUNPREFIXEDQI :
1226       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_ext_QI, & fields->f_dst32_rn_ext_unprefixed);
1227       break;
1228     case M32C_OPERAND_DST32RNPREFIXEDHI :
1229       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_dst32_rn_prefixed_HI);
1230       break;
1231     case M32C_OPERAND_DST32RNPREFIXEDQI :
1232       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_dst32_rn_prefixed_QI);
1233       break;
1234     case M32C_OPERAND_DST32RNPREFIXEDSI :
1235       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_dst32_rn_prefixed_SI);
1236       break;
1237     case M32C_OPERAND_DST32RNUNPREFIXEDHI :
1238       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_dst32_rn_unprefixed_HI);
1239       break;
1240     case M32C_OPERAND_DST32RNUNPREFIXEDQI :
1241       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_dst32_rn_unprefixed_QI);
1242       break;
1243     case M32C_OPERAND_DST32RNUNPREFIXEDSI :
1244       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_dst32_rn_unprefixed_SI);
1245       break;
1246     case M32C_OPERAND_G :
1247       errmsg = parse_G (cd, strp, M32C_OPERAND_G, (long *) (& junk));
1248       break;
1249     case M32C_OPERAND_IMM_12_S4 :
1250       errmsg = parse_signed4 (cd, strp, M32C_OPERAND_IMM_12_S4, (long *) (& fields->f_imm_12_s4));
1251       break;
1252     case M32C_OPERAND_IMM_12_S4N :
1253       errmsg = parse_signed4n (cd, strp, M32C_OPERAND_IMM_12_S4N, (long *) (& fields->f_imm_12_s4));
1254       break;
1255     case M32C_OPERAND_IMM_13_U3 :
1256       errmsg = parse_signed4 (cd, strp, M32C_OPERAND_IMM_13_U3, (long *) (& fields->f_imm_13_u3));
1257       break;
1258     case M32C_OPERAND_IMM_16_HI :
1259       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_16_HI, (long *) (& fields->f_dsp_16_s16));
1260       break;
1261     case M32C_OPERAND_IMM_16_QI :
1262       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_16_QI, (long *) (& fields->f_dsp_16_s8));
1263       break;
1264     case M32C_OPERAND_IMM_16_SI :
1265       errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_16_SI, (long *) (& fields->f_dsp_16_s32));
1266       break;
1267     case M32C_OPERAND_IMM_20_S4 :
1268       errmsg = parse_signed4 (cd, strp, M32C_OPERAND_IMM_20_S4, (long *) (& fields->f_imm_20_s4));
1269       break;
1270     case M32C_OPERAND_IMM_24_HI :
1271       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_24_HI, (long *) (& fields->f_dsp_24_s16));
1272       break;
1273     case M32C_OPERAND_IMM_24_QI :
1274       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_24_QI, (long *) (& fields->f_dsp_24_s8));
1275       break;
1276     case M32C_OPERAND_IMM_24_SI :
1277       errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_24_SI, (long *) (& fields->f_dsp_24_s32));
1278       break;
1279     case M32C_OPERAND_IMM_32_HI :
1280       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_32_HI, (long *) (& fields->f_dsp_32_s16));
1281       break;
1282     case M32C_OPERAND_IMM_32_QI :
1283       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_32_QI, (long *) (& fields->f_dsp_32_s8));
1284       break;
1285     case M32C_OPERAND_IMM_32_SI :
1286       errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_32_SI, (long *) (& fields->f_dsp_32_s32));
1287       break;
1288     case M32C_OPERAND_IMM_40_HI :
1289       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_40_HI, (long *) (& fields->f_dsp_40_s16));
1290       break;
1291     case M32C_OPERAND_IMM_40_QI :
1292       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_40_QI, (long *) (& fields->f_dsp_40_s8));
1293       break;
1294     case M32C_OPERAND_IMM_40_SI :
1295       errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_40_SI, (long *) (& fields->f_dsp_40_s32));
1296       break;
1297     case M32C_OPERAND_IMM_48_HI :
1298       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_48_HI, (long *) (& fields->f_dsp_48_s16));
1299       break;
1300     case M32C_OPERAND_IMM_48_QI :
1301       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_48_QI, (long *) (& fields->f_dsp_48_s8));
1302       break;
1303     case M32C_OPERAND_IMM_48_SI :
1304       errmsg = parse_signed32 (cd, strp, M32C_OPERAND_IMM_48_SI, (long *) (& fields->f_dsp_48_s32));
1305       break;
1306     case M32C_OPERAND_IMM_56_HI :
1307       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_56_HI, (long *) (& fields->f_dsp_56_s16));
1308       break;
1309     case M32C_OPERAND_IMM_56_QI :
1310       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_56_QI, (long *) (& fields->f_dsp_56_s8));
1311       break;
1312     case M32C_OPERAND_IMM_64_HI :
1313       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_64_HI, (long *) (& fields->f_dsp_64_s16));
1314       break;
1315     case M32C_OPERAND_IMM_8_HI :
1316       errmsg = parse_signed16 (cd, strp, M32C_OPERAND_IMM_8_HI, (long *) (& fields->f_dsp_8_s16));
1317       break;
1318     case M32C_OPERAND_IMM_8_QI :
1319       errmsg = parse_signed8 (cd, strp, M32C_OPERAND_IMM_8_QI, (long *) (& fields->f_dsp_8_s8));
1320       break;
1321     case M32C_OPERAND_IMM_8_S4 :
1322       errmsg = parse_signed4 (cd, strp, M32C_OPERAND_IMM_8_S4, (long *) (& fields->f_imm_8_s4));
1323       break;
1324     case M32C_OPERAND_IMM_8_S4N :
1325       errmsg = parse_signed4n (cd, strp, M32C_OPERAND_IMM_8_S4N, (long *) (& fields->f_imm_8_s4));
1326       break;
1327     case M32C_OPERAND_IMM_SH_12_S4 :
1328       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_shimm, & fields->f_imm_12_s4);
1329       break;
1330     case M32C_OPERAND_IMM_SH_20_S4 :
1331       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_shimm, & fields->f_imm_20_s4);
1332       break;
1333     case M32C_OPERAND_IMM_SH_8_S4 :
1334       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_shimm, & fields->f_imm_8_s4);
1335       break;
1336     case M32C_OPERAND_IMM1_S :
1337       errmsg = parse_imm1_S (cd, strp, M32C_OPERAND_IMM1_S, (long *) (& fields->f_imm1_S));
1338       break;
1339     case M32C_OPERAND_IMM3_S :
1340       errmsg = parse_imm3_S (cd, strp, M32C_OPERAND_IMM3_S, (long *) (& fields->f_imm3_S));
1341       break;
1342     case M32C_OPERAND_LAB_16_8 :
1343       {
1344         bfd_vma value = 0;
1345         errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_16_8, 0, NULL,  & value);
1346         fields->f_lab_16_8 = value;
1347       }
1348       break;
1349     case M32C_OPERAND_LAB_24_8 :
1350       {
1351         bfd_vma value = 0;
1352         errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_24_8, 0, NULL,  & value);
1353         fields->f_lab_24_8 = value;
1354       }
1355       break;
1356     case M32C_OPERAND_LAB_32_8 :
1357       {
1358         bfd_vma value = 0;
1359         errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_32_8, 0, NULL,  & value);
1360         fields->f_lab_32_8 = value;
1361       }
1362       break;
1363     case M32C_OPERAND_LAB_40_8 :
1364       {
1365         bfd_vma value = 0;
1366         errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_40_8, 0, NULL,  & value);
1367         fields->f_lab_40_8 = value;
1368       }
1369       break;
1370     case M32C_OPERAND_LAB_5_3 :
1371       {
1372         bfd_vma value = 0;
1373         errmsg = parse_lab_5_3 (cd, strp, M32C_OPERAND_LAB_5_3, 0, NULL,  & value);
1374         fields->f_lab_5_3 = value;
1375       }
1376       break;
1377     case M32C_OPERAND_LAB_8_16 :
1378       {
1379         bfd_vma value = 0;
1380         errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_8_16, 0, NULL,  & value);
1381         fields->f_lab_8_16 = value;
1382       }
1383       break;
1384     case M32C_OPERAND_LAB_8_24 :
1385       {
1386         bfd_vma value = 0;
1387         errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_8_24, 0, NULL,  & value);
1388         fields->f_lab_8_24 = value;
1389       }
1390       break;
1391     case M32C_OPERAND_LAB_8_8 :
1392       {
1393         bfd_vma value = 0;
1394         errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_8_8, 0, NULL,  & value);
1395         fields->f_lab_8_8 = value;
1396       }
1397       break;
1398     case M32C_OPERAND_LAB32_JMP_S :
1399       {
1400         bfd_vma value = 0;
1401         errmsg = parse_lab_5_3 (cd, strp, M32C_OPERAND_LAB32_JMP_S, 0, NULL,  & value);
1402         fields->f_lab32_jmp_s = value;
1403       }
1404       break;
1405     case M32C_OPERAND_Q :
1406       errmsg = parse_Q (cd, strp, M32C_OPERAND_Q, (long *) (& junk));
1407       break;
1408     case M32C_OPERAND_R0 :
1409       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0, & junk);
1410       break;
1411     case M32C_OPERAND_R0H :
1412       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0h, & junk);
1413       break;
1414     case M32C_OPERAND_R0L :
1415       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r0l, & junk);
1416       break;
1417     case M32C_OPERAND_R1 :
1418       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r1, & junk);
1419       break;
1420     case M32C_OPERAND_R1R2R0 :
1421       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r1r2r0, & junk);
1422       break;
1423     case M32C_OPERAND_R2 :
1424       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r2, & junk);
1425       break;
1426     case M32C_OPERAND_R2R0 :
1427       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r2r0, & junk);
1428       break;
1429     case M32C_OPERAND_R3 :
1430       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r3, & junk);
1431       break;
1432     case M32C_OPERAND_R3R1 :
1433       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_r3r1, & junk);
1434       break;
1435     case M32C_OPERAND_REGSETPOP :
1436       errmsg = parse_pop_regset (cd, strp, M32C_OPERAND_REGSETPOP, (unsigned long *) (& fields->f_8_8));
1437       break;
1438     case M32C_OPERAND_REGSETPUSH :
1439       errmsg = parse_push_regset (cd, strp, M32C_OPERAND_REGSETPUSH, (unsigned long *) (& fields->f_8_8));
1440       break;
1441     case M32C_OPERAND_RN16_PUSH_S :
1442       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_4_1);
1443       break;
1444     case M32C_OPERAND_S :
1445       errmsg = parse_S (cd, strp, M32C_OPERAND_S, (long *) (& junk));
1446       break;
1447     case M32C_OPERAND_SRC16AN :
1448       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src16_an);
1449       break;
1450     case M32C_OPERAND_SRC16ANHI :
1451       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_src16_an);
1452       break;
1453     case M32C_OPERAND_SRC16ANQI :
1454       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_src16_an);
1455       break;
1456     case M32C_OPERAND_SRC16RNHI :
1457       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_src16_rn);
1458       break;
1459     case M32C_OPERAND_SRC16RNQI :
1460       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_src16_rn);
1461       break;
1462     case M32C_OPERAND_SRC32ANPREFIXED :
1463       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src32_an_prefixed);
1464       break;
1465     case M32C_OPERAND_SRC32ANPREFIXEDHI :
1466       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_src32_an_prefixed);
1467       break;
1468     case M32C_OPERAND_SRC32ANPREFIXEDQI :
1469       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_src32_an_prefixed);
1470       break;
1471     case M32C_OPERAND_SRC32ANPREFIXEDSI :
1472       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src32_an_prefixed);
1473       break;
1474     case M32C_OPERAND_SRC32ANUNPREFIXED :
1475       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src32_an_unprefixed);
1476       break;
1477     case M32C_OPERAND_SRC32ANUNPREFIXEDHI :
1478       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_HI, & fields->f_src32_an_unprefixed);
1479       break;
1480     case M32C_OPERAND_SRC32ANUNPREFIXEDQI :
1481       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar_QI, & fields->f_src32_an_unprefixed);
1482       break;
1483     case M32C_OPERAND_SRC32ANUNPREFIXEDSI :
1484       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_ar, & fields->f_src32_an_unprefixed);
1485       break;
1486     case M32C_OPERAND_SRC32RNPREFIXEDHI :
1487       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_src32_rn_prefixed_HI);
1488       break;
1489     case M32C_OPERAND_SRC32RNPREFIXEDQI :
1490       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_src32_rn_prefixed_QI);
1491       break;
1492     case M32C_OPERAND_SRC32RNPREFIXEDSI :
1493       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_src32_rn_prefixed_SI);
1494       break;
1495     case M32C_OPERAND_SRC32RNUNPREFIXEDHI :
1496       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_HI, & fields->f_src32_rn_unprefixed_HI);
1497       break;
1498     case M32C_OPERAND_SRC32RNUNPREFIXEDQI :
1499       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_QI, & fields->f_src32_rn_unprefixed_QI);
1500       break;
1501     case M32C_OPERAND_SRC32RNUNPREFIXEDSI :
1502       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_gr_SI, & fields->f_src32_rn_unprefixed_SI);
1503       break;
1504     case M32C_OPERAND_SRCDST16_R0L_R0H_S_NORMAL :
1505       errmsg = parse_r0l_r0h (cd, strp, M32C_OPERAND_SRCDST16_R0L_R0H_S_NORMAL, (long *) (& fields->f_5_1));
1506       break;
1507     case M32C_OPERAND_X :
1508       errmsg = parse_X (cd, strp, M32C_OPERAND_X, (long *) (& junk));
1509       break;
1510     case M32C_OPERAND_Z :
1511       errmsg = parse_Z (cd, strp, M32C_OPERAND_Z, (long *) (& junk));
1512       break;
1513     case M32C_OPERAND_COND16_16 :
1514       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16, & fields->f_dsp_16_u8);
1515       break;
1516     case M32C_OPERAND_COND16_24 :
1517       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16, & fields->f_dsp_24_u8);
1518       break;
1519     case M32C_OPERAND_COND16_32 :
1520       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16, & fields->f_dsp_32_u8);
1521       break;
1522     case M32C_OPERAND_COND16C :
1523       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16c, & fields->f_cond16);
1524       break;
1525     case M32C_OPERAND_COND16J :
1526       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16j, & fields->f_cond16);
1527       break;
1528     case M32C_OPERAND_COND16J5 :
1529       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond16j_5, & fields->f_cond16j_5);
1530       break;
1531     case M32C_OPERAND_COND32 :
1532       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_cond32);
1533       break;
1534     case M32C_OPERAND_COND32_16 :
1535       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_dsp_16_u8);
1536       break;
1537     case M32C_OPERAND_COND32_24 :
1538       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_dsp_24_u8);
1539       break;
1540     case M32C_OPERAND_COND32_32 :
1541       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_dsp_32_u8);
1542       break;
1543     case M32C_OPERAND_COND32_40 :
1544       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_dsp_40_u8);
1545       break;
1546     case M32C_OPERAND_COND32J :
1547       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_cond32j);
1548       break;
1549     case M32C_OPERAND_CR1_PREFIXED_32 :
1550       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr1_32, & fields->f_21_3);
1551       break;
1552     case M32C_OPERAND_CR1_UNPREFIXED_32 :
1553       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr1_32, & fields->f_13_3);
1554       break;
1555     case M32C_OPERAND_CR16 :
1556       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr_16, & fields->f_9_3);
1557       break;
1558     case M32C_OPERAND_CR2_32 :
1559       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr2_32, & fields->f_13_3);
1560       break;
1561     case M32C_OPERAND_CR3_PREFIXED_32 :
1562       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr3_32, & fields->f_21_3);
1563       break;
1564     case M32C_OPERAND_CR3_UNPREFIXED_32 :
1565       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cr3_32, & fields->f_13_3);
1566       break;
1567     case M32C_OPERAND_FLAGS16 :
1568       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_flags, & fields->f_9_3);
1569       break;
1570     case M32C_OPERAND_FLAGS32 :
1571       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_flags, & fields->f_13_3);
1572       break;
1573     case M32C_OPERAND_SCCOND32 :
1574       errmsg = cgen_parse_keyword (cd, strp, & m32c_cgen_opval_h_cond32, & fields->f_cond16);
1575       break;
1576     case M32C_OPERAND_SIZE :
1577       errmsg = parse_size (cd, strp, M32C_OPERAND_SIZE, (long *) (& junk));
1578       break;
1579
1580     default :
1581       /* xgettext:c-format */
1582       fprintf (stderr, _("Unrecognized field %d while parsing.\n"), opindex);
1583       abort ();
1584   }
1585
1586   return errmsg;
1587 }
1588
1589 cgen_parse_fn * const m32c_cgen_parse_handlers[] =
1590 {
1591   parse_insn_normal,
1592 };
1593
1594 void
1595 m32c_cgen_init_asm (CGEN_CPU_DESC cd)
1596 {
1597   m32c_cgen_init_opcode_table (cd);
1598   m32c_cgen_init_ibld_table (cd);
1599   cd->parse_handlers = & m32c_cgen_parse_handlers[0];
1600   cd->parse_operand = m32c_cgen_parse_operand;
1601 }
1602
1603 \f
1604
1605 /* Regex construction routine.
1606
1607    This translates an opcode syntax string into a regex string,
1608    by replacing any non-character syntax element (such as an
1609    opcode) with the pattern '.*'
1610
1611    It then compiles the regex and stores it in the opcode, for
1612    later use by m32c_cgen_assemble_insn
1613
1614    Returns NULL for success, an error message for failure.  */
1615
1616 char *
1617 m32c_cgen_build_insn_regex (CGEN_INSN *insn)
1618 {
1619   CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
1620   const char *mnem = CGEN_INSN_MNEMONIC (insn);
1621   char rxbuf[CGEN_MAX_RX_ELEMENTS];
1622   char *rx = rxbuf;
1623   const CGEN_SYNTAX_CHAR_TYPE *syn;
1624   int reg_err;
1625
1626   syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
1627
1628   /* Mnemonics come first in the syntax string.  */
1629   if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
1630     return _("missing mnemonic in syntax string");
1631   ++syn;
1632
1633   /* Generate a case sensitive regular expression that emulates case
1634      insensitive matching in the "C" locale.  We cannot generate a case
1635      insensitive regular expression because in Turkish locales, 'i' and 'I'
1636      are not equal modulo case conversion.  */
1637
1638   /* Copy the literal mnemonic out of the insn.  */
1639   for (; *mnem; mnem++)
1640     {
1641       char c = *mnem;
1642
1643       if (ISALPHA (c))
1644         {
1645           *rx++ = '[';
1646           *rx++ = TOLOWER (c);
1647           *rx++ = TOUPPER (c);
1648           *rx++ = ']';
1649         }
1650       else
1651         *rx++ = c;
1652     }
1653
1654   /* Copy any remaining literals from the syntax string into the rx.  */
1655   for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
1656     {
1657       if (CGEN_SYNTAX_CHAR_P (* syn))
1658         {
1659           char c = CGEN_SYNTAX_CHAR (* syn);
1660
1661           switch (c)
1662             {
1663               /* Escape any regex metacharacters in the syntax.  */
1664             case '.': case '[': case '\\':
1665             case '*': case '^': case '$':
1666
1667 #ifdef CGEN_ESCAPE_EXTENDED_REGEX
1668             case '?': case '{': case '}':
1669             case '(': case ')': case '*':
1670             case '|': case '+': case ']':
1671 #endif
1672               *rx++ = '\\';
1673               *rx++ = c;
1674               break;
1675
1676             default:
1677               if (ISALPHA (c))
1678                 {
1679                   *rx++ = '[';
1680                   *rx++ = TOLOWER (c);
1681                   *rx++ = TOUPPER (c);
1682                   *rx++ = ']';
1683                 }
1684               else
1685                 *rx++ = c;
1686               break;
1687             }
1688         }
1689       else
1690         {
1691           /* Replace non-syntax fields with globs.  */
1692           *rx++ = '.';
1693           *rx++ = '*';
1694         }
1695     }
1696
1697   /* Trailing whitespace ok.  */
1698   * rx++ = '[';
1699   * rx++ = ' ';
1700   * rx++ = '\t';
1701   * rx++ = ']';
1702   * rx++ = '*';
1703
1704   /* But anchor it after that.  */
1705   * rx++ = '$';
1706   * rx = '\0';
1707
1708   CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
1709   reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
1710
1711   if (reg_err == 0)
1712     return NULL;
1713   else
1714     {
1715       static char msg[80];
1716
1717       regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
1718       regfree ((regex_t *) CGEN_INSN_RX (insn));
1719       free (CGEN_INSN_RX (insn));
1720       (CGEN_INSN_RX (insn)) = NULL;
1721       return msg;
1722     }
1723 }
1724
1725 \f
1726 /* Default insn parser.
1727
1728    The syntax string is scanned and operands are parsed and stored in FIELDS.
1729    Relocs are queued as we go via other callbacks.
1730
1731    ??? Note that this is currently an all-or-nothing parser.  If we fail to
1732    parse the instruction, we return 0 and the caller will start over from
1733    the beginning.  Backtracking will be necessary in parsing subexpressions,
1734    but that can be handled there.  Not handling backtracking here may get
1735    expensive in the case of the m68k.  Deal with later.
1736
1737    Returns NULL for success, an error message for failure.  */
1738
1739 static const char *
1740 parse_insn_normal (CGEN_CPU_DESC cd,
1741                    const CGEN_INSN *insn,
1742                    const char **strp,
1743                    CGEN_FIELDS *fields)
1744 {
1745   /* ??? Runtime added insns not handled yet.  */
1746   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
1747   const char *str = *strp;
1748   const char *errmsg;
1749   const char *p;
1750   const CGEN_SYNTAX_CHAR_TYPE * syn;
1751 #ifdef CGEN_MNEMONIC_OPERANDS
1752   /* FIXME: wip */
1753   int past_opcode_p;
1754 #endif
1755
1756   /* For now we assume the mnemonic is first (there are no leading operands).
1757      We can parse it without needing to set up operand parsing.
1758      GAS's input scrubber will ensure mnemonics are lowercase, but we may
1759      not be called from GAS.  */
1760   p = CGEN_INSN_MNEMONIC (insn);
1761   while (*p && TOLOWER (*p) == TOLOWER (*str))
1762     ++p, ++str;
1763
1764   if (* p)
1765     return _("unrecognized instruction");
1766
1767 #ifndef CGEN_MNEMONIC_OPERANDS
1768   if (* str && ! ISSPACE (* str))
1769     return _("unrecognized instruction");
1770 #endif
1771
1772   CGEN_INIT_PARSE (cd);
1773   cgen_init_parse_operand (cd);
1774 #ifdef CGEN_MNEMONIC_OPERANDS
1775   past_opcode_p = 0;
1776 #endif
1777
1778   /* We don't check for (*str != '\0') here because we want to parse
1779      any trailing fake arguments in the syntax string.  */
1780   syn = CGEN_SYNTAX_STRING (syntax);
1781
1782   /* Mnemonics come first for now, ensure valid string.  */
1783   if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
1784     abort ();
1785
1786   ++syn;
1787
1788   while (* syn != 0)
1789     {
1790       /* Non operand chars must match exactly.  */
1791       if (CGEN_SYNTAX_CHAR_P (* syn))
1792         {
1793           /* FIXME: While we allow for non-GAS callers above, we assume the
1794              first char after the mnemonic part is a space.  */
1795           /* FIXME: We also take inappropriate advantage of the fact that
1796              GAS's input scrubber will remove extraneous blanks.  */
1797           if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
1798             {
1799 #ifdef CGEN_MNEMONIC_OPERANDS
1800               if (CGEN_SYNTAX_CHAR(* syn) == ' ')
1801                 past_opcode_p = 1;
1802 #endif
1803               ++ syn;
1804               ++ str;
1805             }
1806           else if (*str)
1807             {
1808               /* Syntax char didn't match.  Can't be this insn.  */
1809               static char msg [80];
1810
1811               /* xgettext:c-format */
1812               sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
1813                        CGEN_SYNTAX_CHAR(*syn), *str);
1814               return msg;
1815             }
1816           else
1817             {
1818               /* Ran out of input.  */
1819               static char msg [80];
1820
1821               /* xgettext:c-format */
1822               sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
1823                        CGEN_SYNTAX_CHAR(*syn));
1824               return msg;
1825             }
1826           continue;
1827         }
1828
1829       /* We have an operand of some sort.  */
1830       errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn),
1831                                           &str, fields);
1832       if (errmsg)
1833         return errmsg;
1834
1835       /* Done with this operand, continue with next one.  */
1836       ++ syn;
1837     }
1838
1839   /* If we're at the end of the syntax string, we're done.  */
1840   if (* syn == 0)
1841     {
1842       /* FIXME: For the moment we assume a valid `str' can only contain
1843          blanks now.  IE: We needn't try again with a longer version of
1844          the insn and it is assumed that longer versions of insns appear
1845          before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3).  */
1846       while (ISSPACE (* str))
1847         ++ str;
1848
1849       if (* str != '\0')
1850         return _("junk at end of line"); /* FIXME: would like to include `str' */
1851
1852       return NULL;
1853     }
1854
1855   /* We couldn't parse it.  */
1856   return _("unrecognized instruction");
1857 }
1858 \f
1859 /* Main entry point.
1860    This routine is called for each instruction to be assembled.
1861    STR points to the insn to be assembled.
1862    We assume all necessary tables have been initialized.
1863    The assembled instruction, less any fixups, is stored in BUF.
1864    Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
1865    still needs to be converted to target byte order, otherwise BUF is an array
1866    of bytes in target byte order.
1867    The result is a pointer to the insn's entry in the opcode table,
1868    or NULL if an error occured (an error message will have already been
1869    printed).
1870
1871    Note that when processing (non-alias) macro-insns,
1872    this function recurses.
1873
1874    ??? It's possible to make this cpu-independent.
1875    One would have to deal with a few minor things.
1876    At this point in time doing so would be more of a curiosity than useful
1877    [for example this file isn't _that_ big], but keeping the possibility in
1878    mind helps keep the design clean.  */
1879
1880 const CGEN_INSN *
1881 m32c_cgen_assemble_insn (CGEN_CPU_DESC cd,
1882                            const char *str,
1883                            CGEN_FIELDS *fields,
1884                            CGEN_INSN_BYTES_PTR buf,
1885                            char **errmsg)
1886 {
1887   const char *start;
1888   CGEN_INSN_LIST *ilist;
1889   const char *parse_errmsg = NULL;
1890   const char *insert_errmsg = NULL;
1891   int recognized_mnemonic = 0;
1892
1893   /* Skip leading white space.  */
1894   while (ISSPACE (* str))
1895     ++ str;
1896
1897   /* The instructions are stored in hashed lists.
1898      Get the first in the list.  */
1899   ilist = CGEN_ASM_LOOKUP_INSN (cd, str);
1900
1901   /* Keep looking until we find a match.  */
1902   start = str;
1903   for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
1904     {
1905       const CGEN_INSN *insn = ilist->insn;
1906       recognized_mnemonic = 1;
1907
1908 #ifdef CGEN_VALIDATE_INSN_SUPPORTED
1909       /* Not usually needed as unsupported opcodes
1910          shouldn't be in the hash lists.  */
1911       /* Is this insn supported by the selected cpu?  */
1912       if (! m32c_cgen_insn_supported (cd, insn))
1913         continue;
1914 #endif
1915       /* If the RELAXED attribute is set, this is an insn that shouldn't be
1916          chosen immediately.  Instead, it is used during assembler/linker
1917          relaxation if possible.  */
1918       if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
1919         continue;
1920
1921       str = start;
1922
1923       /* Skip this insn if str doesn't look right lexically.  */
1924       if (CGEN_INSN_RX (insn) != NULL &&
1925           regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
1926         continue;
1927
1928       /* Allow parse/insert handlers to obtain length of insn.  */
1929       CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
1930
1931       parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
1932       if (parse_errmsg != NULL)
1933         continue;
1934
1935       /* ??? 0 is passed for `pc'.  */
1936       insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
1937                                                  (bfd_vma) 0);
1938       if (insert_errmsg != NULL)
1939         continue;
1940
1941       /* It is up to the caller to actually output the insn and any
1942          queued relocs.  */
1943       return insn;
1944     }
1945
1946   {
1947     static char errbuf[150];
1948 #ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
1949     const char *tmp_errmsg;
1950
1951     /* If requesting verbose error messages, use insert_errmsg.
1952        Failing that, use parse_errmsg.  */
1953     tmp_errmsg = (insert_errmsg ? insert_errmsg :
1954                   parse_errmsg ? parse_errmsg :
1955                   recognized_mnemonic ?
1956                   _("unrecognized form of instruction") :
1957                   _("unrecognized instruction"));
1958
1959     if (strlen (start) > 50)
1960       /* xgettext:c-format */
1961       sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
1962     else
1963       /* xgettext:c-format */
1964       sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
1965 #else
1966     if (strlen (start) > 50)
1967       /* xgettext:c-format */
1968       sprintf (errbuf, _("bad instruction `%.50s...'"), start);
1969     else
1970       /* xgettext:c-format */
1971       sprintf (errbuf, _("bad instruction `%.50s'"), start);
1972 #endif
1973
1974     *errmsg = errbuf;
1975     return NULL;
1976   }
1977 }