opcodes/or1k-asm.c

   1 /* DO NOT EDIT!  -*- buffer-read-only: t -*- vi:set ro:  */
   2 /* Assembler interface for targets using CGEN. -*- C -*-
   3    CGEN: Cpu tools GENerator
   4
   5    THIS FILE IS MACHINE GENERATED WITH CGEN.
   6    - the resultant file is machine generated, cgen-asm.in isn't
   7
   8    Copyright (C) 1996-2023 Free Software Foundation, Inc.
   9
  10    This file is part of libopcodes.
  11
  12    This library is free software; you can redistribute it and/or modify
  13    it under the terms of the GNU General Public License as published by
  14    the Free Software Foundation; either version 3, or (at your option)
  15    any later version.
  16
  17    It is distributed in the hope that it will be useful, but WITHOUT
  18    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  19    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  20    License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program; if not, write to the Free Software Foundation, Inc.,
  24    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  25
  26
  27 /* ??? Eventually more and more of this stuff can go to cpu-independent files.
  28    Keep that in mind.  */
  29
  30 #include "sysdep.h"
  31 #include <stdio.h>
  32 #include "ansidecl.h"
  33 #include "bfd.h"
  34 #include "symcat.h"
  35 #include "or1k-desc.h"
  36 #include "or1k-opc.h"
  37 #include "opintl.h"
  38 #include "xregex.h"
  39 #include "libiberty.h"
  40 #include "safe-ctype.h"
  41
  42 #undef  min
  43 #define min(a,b) ((a) < (b) ? (a) : (b))
  44 #undef  max
  45 #define max(a,b) ((a) > (b) ? (a) : (b))
  46
  47 static const char * parse_insn_normal
  48   (CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *);
  49 \f
  50 /* -- assembler routines inserted here.  */
  51
  52 /* -- asm.c */
  53
  54 static const char * MISSING_CLOSING_PARENTHESIS = N_("missing `)'");
  55 static const char * INVALID_STORE_RELOC = N_("relocation invalid for store");
  56 static const char * INVALID_RELOC_TYPE = N_("internal relocation type invalid");
  57
  58 #define CGEN_VERBOSE_ASSEMBLER_ERRORS
  59
  60 static const char *
  61 parse_disp26 (CGEN_CPU_DESC cd,
  62               const char ** strp,
  63               int opindex,
  64               int opinfo ATTRIBUTE_UNUSED,
  65               enum cgen_parse_operand_result * resultp,
  66               bfd_vma * valuep)
  67 {
  68   const char *str = *strp;
  69   const char *errmsg = NULL;
  70   bfd_reloc_code_real_type reloc = BFD_RELOC_OR1K_REL_26;
  71
  72   if (strncasecmp (str, "plta(", 5) == 0)
  73     {
  74       *strp = str + 5;
  75       reloc = BFD_RELOC_OR1K_PLTA26;
  76     }
  77   else if (strncasecmp (str, "plt(", 4) == 0)
  78     {
  79       *strp = str + 4;
  80       reloc = BFD_RELOC_OR1K_PLT26;
  81     }
  82
  83   errmsg = cgen_parse_address (cd, strp, opindex, reloc, resultp, valuep);
  84
  85   if (reloc != BFD_RELOC_OR1K_REL_26)
  86     {
  87       if (**strp != ')')
  88         errmsg = MISSING_CLOSING_PARENTHESIS;
  89       else
  90         ++*strp;
  91     }
  92
  93   return errmsg;
  94 }
  95
  96 static const char *
  97 parse_disp21 (CGEN_CPU_DESC cd,
  98               const char ** strp,
  99               int opindex,
 100               int opinfo ATTRIBUTE_UNUSED,
 101               enum cgen_parse_operand_result * resultp,
 102               bfd_vma * valuep)
 103 {
 104   const char *str = *strp;
 105   const char *errmsg = NULL;
 106   bfd_reloc_code_real_type reloc = BFD_RELOC_OR1K_PCREL_PG21;
 107
 108   if (strncasecmp (str, "got(", 4) == 0)
 109     {
 110       *strp = str + 4;
 111       reloc = BFD_RELOC_OR1K_GOT_PG21;
 112     }
 113   else if (strncasecmp (str, "tlsgd(", 6) == 0)
 114     {
 115       *strp = str + 6;
 116       reloc = BFD_RELOC_OR1K_TLS_GD_PG21;
 117     }
 118   else if (strncasecmp (str, "tlsldm(", 7) == 0)
 119     {
 120       *strp = str + 7;
 121       reloc = BFD_RELOC_OR1K_TLS_LDM_PG21;
 122     }
 123   else if (strncasecmp (str, "gottp(", 6) == 0)
 124     {
 125       *strp = str + 6;
 126       reloc = BFD_RELOC_OR1K_TLS_IE_PG21;
 127     }
 128
 129   errmsg = cgen_parse_address (cd, strp, opindex, reloc, resultp, valuep);
 130
 131   if (reloc != BFD_RELOC_OR1K_PCREL_PG21)
 132     {
 133       if (**strp != ')')
 134         errmsg = MISSING_CLOSING_PARENTHESIS;
 135       else
 136         ++*strp;
 137     }
 138
 139   return errmsg;
 140 }
 141
 142 enum or1k_rclass
 143 {
 144   RCLASS_DIRECT   = 0,
 145   RCLASS_GOT      = 1,
 146   RCLASS_GOTPC    = 2,
 147   RCLASS_GOTOFF   = 3,
 148   RCLASS_TLSGD    = 4,
 149   RCLASS_TLSLDM   = 5,
 150   RCLASS_DTPOFF   = 6,
 151   RCLASS_GOTTPOFF = 7,
 152   RCLASS_TPOFF    = 8,
 153 };
 154
 155 enum or1k_rtype
 156 {
 157   RTYPE_LO = 0,
 158   RTYPE_SLO = 1,
 159   RTYPE_PO = 2,
 160   RTYPE_SPO = 3,
 161   RTYPE_HI = 4,
 162   RTYPE_AHI = 5,
 163 };
 164
 165 #define RCLASS_SHIFT 3
 166 #define RTYPE_MASK   7
 167
 168 static const bfd_reloc_code_real_type or1k_imm16_relocs[][6] = {
 169   { BFD_RELOC_LO16,
 170     BFD_RELOC_OR1K_SLO16,
 171     BFD_RELOC_OR1K_LO13,
 172     BFD_RELOC_OR1K_SLO13,
 173     BFD_RELOC_HI16,
 174     BFD_RELOC_HI16_S, },
 175   { BFD_RELOC_OR1K_GOT16,
 176     BFD_RELOC_UNUSED,
 177     BFD_RELOC_OR1K_GOT_LO13,
 178     BFD_RELOC_UNUSED,
 179     BFD_RELOC_UNUSED,
 180     BFD_RELOC_OR1K_GOT_AHI16 },
 181   { BFD_RELOC_OR1K_GOTPC_LO16,
 182     BFD_RELOC_UNUSED,
 183     BFD_RELOC_UNUSED,
 184     BFD_RELOC_UNUSED,
 185     BFD_RELOC_OR1K_GOTPC_HI16,
 186     BFD_RELOC_UNUSED },
 187   { BFD_RELOC_LO16_GOTOFF,
 188     BFD_RELOC_OR1K_GOTOFF_SLO16,
 189     BFD_RELOC_UNUSED,
 190     BFD_RELOC_UNUSED,
 191     BFD_RELOC_HI16_GOTOFF,
 192     BFD_RELOC_HI16_S_GOTOFF },
 193   { BFD_RELOC_OR1K_TLS_GD_LO16,
 194     BFD_RELOC_UNUSED,
 195     BFD_RELOC_OR1K_TLS_GD_LO13,
 196     BFD_RELOC_UNUSED,
 197     BFD_RELOC_OR1K_TLS_GD_HI16,
 198     BFD_RELOC_UNUSED },
 199   { BFD_RELOC_OR1K_TLS_LDM_LO16,
 200     BFD_RELOC_UNUSED,
 201     BFD_RELOC_OR1K_TLS_LDM_LO13,
 202     BFD_RELOC_UNUSED,
 203     BFD_RELOC_OR1K_TLS_LDM_HI16,
 204     BFD_RELOC_UNUSED },
 205   { BFD_RELOC_OR1K_TLS_LDO_LO16,
 206     BFD_RELOC_UNUSED,
 207     BFD_RELOC_UNUSED,
 208     BFD_RELOC_UNUSED,
 209     BFD_RELOC_OR1K_TLS_LDO_HI16,
 210     BFD_RELOC_UNUSED },
 211   { BFD_RELOC_OR1K_TLS_IE_LO16,
 212     BFD_RELOC_UNUSED,
 213     BFD_RELOC_OR1K_TLS_IE_LO13,
 214     BFD_RELOC_UNUSED,
 215     BFD_RELOC_OR1K_TLS_IE_HI16,
 216     BFD_RELOC_OR1K_TLS_IE_AHI16 },
 217   { BFD_RELOC_OR1K_TLS_LE_LO16,
 218     BFD_RELOC_OR1K_TLS_LE_SLO16,
 219     BFD_RELOC_UNUSED,
 220     BFD_RELOC_UNUSED,
 221     BFD_RELOC_OR1K_TLS_LE_HI16,
 222     BFD_RELOC_OR1K_TLS_LE_AHI16 },
 223 };
 224
 225 static int
 226 parse_reloc (const char **strp)
 227 {
 228     const char *str = *strp;
 229     enum or1k_rclass cls = RCLASS_DIRECT;
 230     enum or1k_rtype typ;
 231
 232     if (strncasecmp (str, "got(", 4) == 0)
 233       {
 234         *strp = str + 4;
 235         return (RCLASS_GOT << RCLASS_SHIFT) | RTYPE_LO;
 236       }
 237     if (strncasecmp (str, "gotpo(", 6) == 0)
 238       {
 239         *strp = str + 6;
 240         return (RCLASS_GOT << RCLASS_SHIFT) | RTYPE_PO;
 241       }
 242     if (strncasecmp (str, "gottppo(", 8) == 0)
 243       {
 244         *strp = str + 8;
 245         return (RCLASS_GOTTPOFF << RCLASS_SHIFT) | RTYPE_PO;
 246       }
 247
 248     if (strncasecmp (str, "gotpc", 5) == 0)
 249       {
 250         str += 5;
 251         cls = RCLASS_GOTPC;
 252       }
 253     else if (strncasecmp (str, "gotoff", 6) == 0)
 254       {
 255         str += 6;
 256         cls = RCLASS_GOTOFF;
 257       }
 258     else if (strncasecmp (str, "tlsgd", 5) == 0)
 259       {
 260         str += 5;
 261         cls = RCLASS_TLSGD;
 262       }
 263     else if (strncasecmp (str, "tlsldm", 6) == 0)
 264       {
 265         str += 6;
 266         cls = RCLASS_TLSLDM;
 267       }
 268     else if (strncasecmp (str, "dtpoff", 6) == 0)
 269       {
 270         str += 6;
 271         cls = RCLASS_DTPOFF;
 272       }
 273     else if (strncasecmp (str, "gottpoff", 8) == 0)
 274       {
 275         str += 8;
 276         cls = RCLASS_GOTTPOFF;
 277       }
 278     else if (strncasecmp (str, "tpoff", 5) == 0)
 279       {
 280         str += 5;
 281         cls = RCLASS_TPOFF;
 282       }
 283     else if (strncasecmp (str, "got", 3) == 0)
 284       {
 285         str += 3;
 286         cls = RCLASS_GOT;
 287       }
 288
 289     if (strncasecmp (str, "hi(", 3) == 0)
 290       {
 291         str += 3;
 292         typ = RTYPE_HI;
 293       }
 294     else if (strncasecmp (str, "lo(", 3) == 0)
 295       {
 296         str += 3;
 297         typ = RTYPE_LO;
 298       }
 299     else if (strncasecmp (str, "ha(", 3) == 0)
 300       {
 301         str += 3;
 302         typ = RTYPE_AHI;
 303       }
 304     else if (strncasecmp (str, "po(", 3) == 0 && cls != RCLASS_GOTTPOFF)
 305       {
 306         str += 3;
 307         typ = RTYPE_PO;
 308       }
 309     else
 310       return -1;
 311
 312     *strp = str;
 313     return (cls << RCLASS_SHIFT) | typ;
 314 }
 315
 316 static const char *
 317 parse_imm16 (CGEN_CPU_DESC cd, const char **strp, int opindex,
 318              long *valuep, int splitp)
 319 {
 320   const char *errmsg;
 321   enum cgen_parse_operand_result result_type;
 322   bfd_reloc_code_real_type reloc = BFD_RELOC_UNUSED;
 323   enum or1k_rtype reloc_type;
 324   int reloc_code;
 325   bfd_vma ret;
 326
 327   if (**strp == '#')
 328     ++*strp;
 329
 330   reloc_code = parse_reloc (strp);
 331   reloc_type = reloc_code & RTYPE_MASK;
 332   if (reloc_code >= 0)
 333     {
 334       enum or1k_rclass reloc_class = reloc_code >> RCLASS_SHIFT;
 335       if (splitp)
 336         {
 337           if ((reloc_type == RTYPE_LO || reloc_type == RTYPE_PO)
 338               && reloc_class != RCLASS_GOT)
 339             /* If split we or up the type to RTYPE_SLO or RTYPE_SPO.  */
 340             reloc_type |= 1;
 341           else
 342             return INVALID_STORE_RELOC;
 343         }
 344       reloc = or1k_imm16_relocs[reloc_class][reloc_type];
 345     }
 346
 347   if (reloc != BFD_RELOC_UNUSED)
 348     {
 349       bfd_vma value;
 350
 351       errmsg = cgen_parse_address (cd, strp, opindex, reloc,
 352                                    &result_type, &value);
 353       if (**strp != ')')
 354         errmsg = MISSING_CLOSING_PARENTHESIS;
 355       ++*strp;
 356
 357       ret = value;
 358
 359       if (errmsg == NULL && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
 360         switch (reloc_type)
 361           {
 362           case RTYPE_AHI:
 363             ret += 0x8000;
 364             /* FALLTHRU */
 365           case RTYPE_HI:
 366             ret >>= 16;
 367             /* FALLTHRU */
 368           case RTYPE_LO:
 369           case RTYPE_SLO:
 370             ret &= 0xffff;
 371             ret = (ret ^ 0x8000) - 0x8000;
 372             break;
 373           case RTYPE_PO:
 374           case RTYPE_SPO:
 375             ret &= 0x1fff;
 376             break;
 377           default:
 378             errmsg = INVALID_RELOC_TYPE;
 379           }
 380     }
 381   else
 382     {
 383       long value;
 384       errmsg = cgen_parse_signed_integer (cd, strp, opindex, &value);
 385       ret = value;
 386     }
 387
 388   if (errmsg == NULL)
 389     *valuep = ret;
 390
 391   return errmsg;
 392 }
 393
 394 static const char *
 395 parse_simm16 (CGEN_CPU_DESC cd, const char **strp, int opindex, long *valuep)
 396 {
 397   return parse_imm16(cd, strp, opindex, (long *) valuep, 0);
 398 }
 399
 400 static const char *
 401 parse_simm16_split (CGEN_CPU_DESC cd, const char **strp, int opindex,
 402                     long *valuep)
 403 {
 404   return parse_imm16(cd, strp, opindex, (long *) valuep, 1);
 405 }
 406
 407 static const char *
 408 parse_uimm16 (CGEN_CPU_DESC cd, const char **strp, int opindex,
 409               unsigned long *valuep)
 410 {
 411   const char *errmsg = parse_imm16(cd, strp, opindex, (long *) valuep, 0);
 412   if (errmsg == NULL)
 413     *valuep &= 0xffff;
 414   return errmsg;
 415 }
 416
 417 static const char *
 418 parse_uimm16_split (CGEN_CPU_DESC cd, const char **strp, int opindex,
 419                     unsigned long *valuep)
 420 {
 421   const char *errmsg = parse_imm16(cd, strp, opindex, (long *) valuep, 1);
 422   if (errmsg == NULL)
 423     *valuep &= 0xffff;
 424   return errmsg;
 425 }
 426
 427 /* Parse register pairs with syntax rA,rB to a flag + rA value.  */
 428
 429 static const char *
 430 parse_regpair (CGEN_CPU_DESC cd, const char **strp,
 431                int opindex ATTRIBUTE_UNUSED, unsigned long *valuep)
 432 {
 433   long reg1_index;
 434   long reg2_index;
 435   const char *errmsg;
 436
 437   /* The first part should just be a register.  */
 438   errmsg = cgen_parse_keyword (cd, strp, &or1k_cgen_opval_h_gpr,
 439                                &reg1_index);
 440
 441   /* If that worked skip the comma separator.  */
 442   if (errmsg == NULL)
 443     {
 444       if (**strp == ',')
 445         ++*strp;
 446       else
 447         errmsg = "Unexpected character, expected ','";
 448     }
 449
 450   /* If that worked the next part is just another register.  */
 451   if (errmsg == NULL)
 452     errmsg = cgen_parse_keyword (cd, strp, &or1k_cgen_opval_h_gpr,
 453                                  &reg2_index);
 454
 455   /* Validate the register pair is valid and create the output value.  */
 456   if (errmsg == NULL)
 457     {
 458       int regoffset = reg2_index - reg1_index;
 459
 460       if (regoffset == 1 || regoffset == 2)
 461         {
 462           unsigned short offsetmask;
 463           unsigned short value;
 464
 465           offsetmask = ((regoffset == 2 ? 1 : 0) << 5);
 466           value = offsetmask | reg1_index;
 467
 468           *valuep = value;
 469         }
 470       else
 471         errmsg = "Invalid register pair, offset not 1 or 2.";
 472     }
 473
 474   return errmsg;
 475 }
 476
 477 /* -- */
 478
 479 const char * or1k_cgen_parse_operand
 480   (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
 481
 482 /* Main entry point for operand parsing.
 483
 484    This function is basically just a big switch statement.  Earlier versions
 485    used tables to look up the function to use, but
 486    - if the table contains both assembler and disassembler functions then
 487      the disassembler contains much of the assembler and vice-versa,
 488    - there's a lot of inlining possibilities as things grow,
 489    - using a switch statement avoids the function call overhead.
 490
 491    This function could be moved into `parse_insn_normal', but keeping it
 492    separate makes clear the interface between `parse_insn_normal' and each of
 493    the handlers.  */
 494
 495 const char *
 496 or1k_cgen_parse_operand (CGEN_CPU_DESC cd,
 497                            int opindex,
 498                            const char ** strp,
 499                            CGEN_FIELDS * fields)
 500 {
 501   const char * errmsg = NULL;
 502   /* Used by scalar operands that still need to be parsed.  */
 503   long junk ATTRIBUTE_UNUSED;
 504
 505   switch (opindex)
 506     {
 507     case OR1K_OPERAND_DISP21 :
 508       {
 509         bfd_vma value = 0;
 510         errmsg = parse_disp21 (cd, strp, OR1K_OPERAND_DISP21, 0, NULL,  & value);
 511         fields->f_disp21 = value;
 512       }
 513       break;
 514     case OR1K_OPERAND_DISP26 :
 515       {
 516         bfd_vma value = 0;
 517         errmsg = parse_disp26 (cd, strp, OR1K_OPERAND_DISP26, 0, NULL,  & value);
 518         fields->f_disp26 = value;
 519       }
 520       break;
 521     case OR1K_OPERAND_RA :
 522       errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_gpr, & fields->f_r2);
 523       break;
 524     case OR1K_OPERAND_RAD32F :
 525       errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RAD32F, (unsigned long *) (& fields->f_rad32));
 526       break;
 527     case OR1K_OPERAND_RADI :
 528       errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RADI, (unsigned long *) (& fields->f_rad32));
 529       break;
 530     case OR1K_OPERAND_RASF :
 531       errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_fsr, & fields->f_r2);
 532       break;
 533     case OR1K_OPERAND_RB :
 534       errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_gpr, & fields->f_r3);
 535       break;
 536     case OR1K_OPERAND_RBD32F :
 537       errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RBD32F, (unsigned long *) (& fields->f_rbd32));
 538       break;
 539     case OR1K_OPERAND_RBDI :
 540       errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RBDI, (unsigned long *) (& fields->f_rbd32));
 541       break;
 542     case OR1K_OPERAND_RBSF :
 543       errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_fsr, & fields->f_r3);
 544       break;
 545     case OR1K_OPERAND_RD :
 546       errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_gpr, & fields->f_r1);
 547       break;
 548     case OR1K_OPERAND_RDD32F :
 549       errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RDD32F, (unsigned long *) (& fields->f_rdd32));
 550       break;
 551     case OR1K_OPERAND_RDDI :
 552       errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RDDI, (unsigned long *) (& fields->f_rdd32));
 553       break;
 554     case OR1K_OPERAND_RDSF :
 555       errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_fsr, & fields->f_r1);
 556       break;
 557     case OR1K_OPERAND_SIMM16 :
 558       errmsg = parse_simm16 (cd, strp, OR1K_OPERAND_SIMM16, (long *) (& fields->f_simm16));
 559       break;
 560     case OR1K_OPERAND_SIMM16_SPLIT :
 561       errmsg = parse_simm16_split (cd, strp, OR1K_OPERAND_SIMM16_SPLIT, (long *) (& fields->f_simm16_split));
 562       break;
 563     case OR1K_OPERAND_UIMM16 :
 564       errmsg = parse_uimm16 (cd, strp, OR1K_OPERAND_UIMM16, (unsigned long *) (& fields->f_uimm16));
 565       break;
 566     case OR1K_OPERAND_UIMM16_SPLIT :
 567       errmsg = parse_uimm16_split (cd, strp, OR1K_OPERAND_UIMM16_SPLIT, (unsigned long *) (& fields->f_uimm16_split));
 568       break;
 569     case OR1K_OPERAND_UIMM6 :
 570       errmsg = cgen_parse_unsigned_integer (cd, strp, OR1K_OPERAND_UIMM6, (unsigned long *) (& fields->f_uimm6));
 571       break;
 572
 573     default :
 574       /* xgettext:c-format */
 575       opcodes_error_handler
 576         (_("internal error: unrecognized field %d while parsing"),
 577          opindex);
 578       abort ();
 579   }
 580
 581   return errmsg;
 582 }
 583
 584 cgen_parse_fn * const or1k_cgen_parse_handlers[] =
 585 {
 586   parse_insn_normal,
 587 };
 588
 589 void
 590 or1k_cgen_init_asm (CGEN_CPU_DESC cd)
 591 {
 592   or1k_cgen_init_opcode_table (cd);
 593   or1k_cgen_init_ibld_table (cd);
 594   cd->parse_handlers = & or1k_cgen_parse_handlers[0];
 595   cd->parse_operand = or1k_cgen_parse_operand;
 596 #ifdef CGEN_ASM_INIT_HOOK
 597 CGEN_ASM_INIT_HOOK
 598 #endif
 599 }
 600
 601 \f
 602
 603 /* Regex construction routine.
 604
 605    This translates an opcode syntax string into a regex string,
 606    by replacing any non-character syntax element (such as an
 607    opcode) with the pattern '.*'
 608
 609    It then compiles the regex and stores it in the opcode, for
 610    later use by or1k_cgen_assemble_insn
 611
 612    Returns NULL for success, an error message for failure.  */
 613
 614 char *
 615 or1k_cgen_build_insn_regex (CGEN_INSN *insn)
 616 {
 617   CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
 618   const char *mnem = CGEN_INSN_MNEMONIC (insn);
 619   char rxbuf[CGEN_MAX_RX_ELEMENTS];
 620   char *rx = rxbuf;
 621   const CGEN_SYNTAX_CHAR_TYPE *syn;
 622   int reg_err;
 623
 624   syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
 625
 626   /* Mnemonics come first in the syntax string.  */
 627   if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
 628     return _("missing mnemonic in syntax string");
 629   ++syn;
 630
 631   /* Generate a case sensitive regular expression that emulates case
 632      insensitive matching in the "C" locale.  We cannot generate a case
 633      insensitive regular expression because in Turkish locales, 'i' and 'I'
 634      are not equal modulo case conversion.  */
 635
 636   /* Copy the literal mnemonic out of the insn.  */
 637   for (; *mnem; mnem++)
 638     {
 639       char c = *mnem;
 640
 641       if (ISALPHA (c))
 642         {
 643           *rx++ = '[';
 644           *rx++ = TOLOWER (c);
 645           *rx++ = TOUPPER (c);
 646           *rx++ = ']';
 647         }
 648       else
 649         *rx++ = c;
 650     }
 651
 652   /* Copy any remaining literals from the syntax string into the rx.  */
 653   for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
 654     {
 655       if (CGEN_SYNTAX_CHAR_P (* syn))
 656         {
 657           char c = CGEN_SYNTAX_CHAR (* syn);
 658
 659           switch (c)
 660             {
 661               /* Escape any regex metacharacters in the syntax.  */
 662             case '.': case '[': case '\\':
 663             case '*': case '^': case '$':
 664
 665 #ifdef CGEN_ESCAPE_EXTENDED_REGEX
 666             case '?': case '{': case '}':
 667             case '(': case ')': case '*':
 668             case '|': case '+': case ']':
 669 #endif
 670               *rx++ = '\\';
 671               *rx++ = c;
 672               break;
 673
 674             default:
 675               if (ISALPHA (c))
 676                 {
 677                   *rx++ = '[';
 678                   *rx++ = TOLOWER (c);
 679                   *rx++ = TOUPPER (c);
 680                   *rx++ = ']';
 681                 }
 682               else
 683                 *rx++ = c;
 684               break;
 685             }
 686         }
 687       else
 688         {
 689           /* Replace non-syntax fields with globs.  */
 690           *rx++ = '.';
 691           *rx++ = '*';
 692         }
 693     }
 694
 695   /* Trailing whitespace ok.  */
 696   * rx++ = '[';
 697   * rx++ = ' ';
 698   * rx++ = '\t';
 699   * rx++ = ']';
 700   * rx++ = '*';
 701
 702   /* But anchor it after that.  */
 703   * rx++ = '$';
 704   * rx = '\0';
 705
 706   CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
 707   reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
 708
 709   if (reg_err == 0)
 710     return NULL;
 711   else
 712     {
 713       static char msg[80];
 714
 715       regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
 716       regfree ((regex_t *) CGEN_INSN_RX (insn));
 717       free (CGEN_INSN_RX (insn));
 718       (CGEN_INSN_RX (insn)) = NULL;
 719       return msg;
 720     }
 721 }
 722
 723 \f
 724 /* Default insn parser.
 725
 726    The syntax string is scanned and operands are parsed and stored in FIELDS.
 727    Relocs are queued as we go via other callbacks.
 728
 729    ??? Note that this is currently an all-or-nothing parser.  If we fail to
 730    parse the instruction, we return 0 and the caller will start over from
 731    the beginning.  Backtracking will be necessary in parsing subexpressions,
 732    but that can be handled there.  Not handling backtracking here may get
 733    expensive in the case of the m68k.  Deal with later.
 734
 735    Returns NULL for success, an error message for failure.  */
 736
 737 static const char *
 738 parse_insn_normal (CGEN_CPU_DESC cd,
 739                    const CGEN_INSN *insn,
 740                    const char **strp,
 741                    CGEN_FIELDS *fields)
 742 {
 743   /* ??? Runtime added insns not handled yet.  */
 744   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
 745   const char *str = *strp;
 746   const char *errmsg;
 747   const char *p;
 748   const CGEN_SYNTAX_CHAR_TYPE * syn;
 749 #ifdef CGEN_MNEMONIC_OPERANDS
 750   /* FIXME: wip */
 751   int past_opcode_p;
 752 #endif
 753
 754   /* For now we assume the mnemonic is first (there are no leading operands).
 755      We can parse it without needing to set up operand parsing.
 756      GAS's input scrubber will ensure mnemonics are lowercase, but we may
 757      not be called from GAS.  */
 758   p = CGEN_INSN_MNEMONIC (insn);
 759   while (*p && TOLOWER (*p) == TOLOWER (*str))
 760     ++p, ++str;
 761
 762   if (* p)
 763     return _("unrecognized instruction");
 764
 765 #ifndef CGEN_MNEMONIC_OPERANDS
 766   if (* str && ! ISSPACE (* str))
 767     return _("unrecognized instruction");
 768 #endif
 769
 770   CGEN_INIT_PARSE (cd);
 771   cgen_init_parse_operand (cd);
 772 #ifdef CGEN_MNEMONIC_OPERANDS
 773   past_opcode_p = 0;
 774 #endif
 775
 776   /* We don't check for (*str != '\0') here because we want to parse
 777      any trailing fake arguments in the syntax string.  */
 778   syn = CGEN_SYNTAX_STRING (syntax);
 779
 780   /* Mnemonics come first for now, ensure valid string.  */
 781   if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
 782     abort ();
 783
 784   ++syn;
 785
 786   while (* syn != 0)
 787     {
 788       /* Non operand chars must match exactly.  */
 789       if (CGEN_SYNTAX_CHAR_P (* syn))
 790         {
 791           /* FIXME: While we allow for non-GAS callers above, we assume the
 792              first char after the mnemonic part is a space.  */
 793           /* FIXME: We also take inappropriate advantage of the fact that
 794              GAS's input scrubber will remove extraneous blanks.  */
 795           if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
 796             {
 797 #ifdef CGEN_MNEMONIC_OPERANDS
 798               if (CGEN_SYNTAX_CHAR(* syn) == ' ')
 799                 past_opcode_p = 1;
 800 #endif
 801               ++ syn;
 802               ++ str;
 803             }
 804           else if (*str)
 805             {
 806               /* Syntax char didn't match.  Can't be this insn.  */
 807               static char msg [80];
 808
 809               /* xgettext:c-format */
 810               sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
 811                        CGEN_SYNTAX_CHAR(*syn), *str);
 812               return msg;
 813             }
 814           else
 815             {
 816               /* Ran out of input.  */
 817               static char msg [80];
 818
 819               /* xgettext:c-format */
 820               sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
 821                        CGEN_SYNTAX_CHAR(*syn));
 822               return msg;
 823             }
 824           continue;
 825         }
 826
 827 #ifdef CGEN_MNEMONIC_OPERANDS
 828       (void) past_opcode_p;
 829 #endif
 830       /* We have an operand of some sort.  */
 831       errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
 832       if (errmsg)
 833         return errmsg;
 834
 835       /* Done with this operand, continue with next one.  */
 836       ++ syn;
 837     }
 838
 839   /* If we're at the end of the syntax string, we're done.  */
 840   if (* syn == 0)
 841     {
 842       /* FIXME: For the moment we assume a valid `str' can only contain
 843          blanks now.  IE: We needn't try again with a longer version of
 844          the insn and it is assumed that longer versions of insns appear
 845          before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3).  */
 846       while (ISSPACE (* str))
 847         ++ str;
 848
 849       if (* str != '\0')
 850         return _("junk at end of line"); /* FIXME: would like to include `str' */
 851
 852       return NULL;
 853     }
 854
 855   /* We couldn't parse it.  */
 856   return _("unrecognized instruction");
 857 }
 858 \f
 859 /* Main entry point.
 860    This routine is called for each instruction to be assembled.
 861    STR points to the insn to be assembled.
 862    We assume all necessary tables have been initialized.
 863    The assembled instruction, less any fixups, is stored in BUF.
 864    Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
 865    still needs to be converted to target byte order, otherwise BUF is an array
 866    of bytes in target byte order.
 867    The result is a pointer to the insn's entry in the opcode table,
 868    or NULL if an error occured (an error message will have already been
 869    printed).
 870
 871    Note that when processing (non-alias) macro-insns,
 872    this function recurses.
 873
 874    ??? It's possible to make this cpu-independent.
 875    One would have to deal with a few minor things.
 876    At this point in time doing so would be more of a curiosity than useful
 877    [for example this file isn't _that_ big], but keeping the possibility in
 878    mind helps keep the design clean.  */
 879
 880 const CGEN_INSN *
 881 or1k_cgen_assemble_insn (CGEN_CPU_DESC cd,
 882                            const char *str,
 883                            CGEN_FIELDS *fields,
 884                            CGEN_INSN_BYTES_PTR buf,
 885                            char **errmsg)
 886 {
 887   const char *start;
 888   CGEN_INSN_LIST *ilist;
 889   const char *parse_errmsg = NULL;
 890   const char *insert_errmsg = NULL;
 891   int recognized_mnemonic = 0;
 892
 893   /* Skip leading white space.  */
 894   while (ISSPACE (* str))
 895     ++ str;
 896
 897   /* The instructions are stored in hashed lists.
 898      Get the first in the list.  */
 899   ilist = CGEN_ASM_LOOKUP_INSN (cd, str);
 900
 901   /* Keep looking until we find a match.  */
 902   start = str;
 903   for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
 904     {
 905       const CGEN_INSN *insn = ilist->insn;
 906       recognized_mnemonic = 1;
 907
 908 #ifdef CGEN_VALIDATE_INSN_SUPPORTED
 909       /* Not usually needed as unsupported opcodes
 910          shouldn't be in the hash lists.  */
 911       /* Is this insn supported by the selected cpu?  */
 912       if (! or1k_cgen_insn_supported (cd, insn))
 913         continue;
 914 #endif
 915       /* If the RELAXED attribute is set, this is an insn that shouldn't be
 916          chosen immediately.  Instead, it is used during assembler/linker
 917          relaxation if possible.  */
 918       if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
 919         continue;
 920
 921       str = start;
 922
 923       /* Skip this insn if str doesn't look right lexically.  */
 924       if (CGEN_INSN_RX (insn) != NULL &&
 925           regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
 926         continue;
 927
 928       /* Allow parse/insert handlers to obtain length of insn.  */
 929       CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
 930
 931       parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
 932       if (parse_errmsg != NULL)
 933         continue;
 934
 935       /* ??? 0 is passed for `pc'.  */
 936       insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
 937                                                  (bfd_vma) 0);
 938       if (insert_errmsg != NULL)
 939         continue;
 940
 941       /* It is up to the caller to actually output the insn and any
 942          queued relocs.  */
 943       return insn;
 944     }
 945
 946   {
 947     static char errbuf[150];
 948     const char *tmp_errmsg;
 949 #ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
 950 #define be_verbose 1
 951 #else
 952 #define be_verbose 0
 953 #endif
 954
 955     if (be_verbose)
 956       {
 957         /* If requesting verbose error messages, use insert_errmsg.
 958            Failing that, use parse_errmsg.  */
 959         tmp_errmsg = (insert_errmsg ? insert_errmsg :
 960                       parse_errmsg ? parse_errmsg :
 961                       recognized_mnemonic ?
 962                       _("unrecognized form of instruction") :
 963                       _("unrecognized instruction"));
 964
 965         if (strlen (start) > 50)
 966           /* xgettext:c-format */
 967           sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
 968         else
 969           /* xgettext:c-format */
 970           sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
 971       }
 972     else
 973       {
 974         if (strlen (start) > 50)
 975           /* xgettext:c-format */
 976           sprintf (errbuf, _("bad instruction `%.50s...'"), start);
 977         else
 978           /* xgettext:c-format */
 979           sprintf (errbuf, _("bad instruction `%.50s'"), start);
 980       }
 981
 982     *errmsg = errbuf;
 983     return NULL;
 984   }
 985 }