gcc/genoutput.c

   1 /* Generate code from to output assembler insns as recognized from rtl.
   2    Copyright (C) 1987, 1988, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2002,
   3    2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21
  22 /* This program reads the machine description for the compiler target machine
  23    and produces a file containing these things:
  24
  25    1. An array of `struct insn_data', which is indexed by insn code number,
  26    which contains:
  27
  28      a. `name' is the name for that pattern.  Nameless patterns are
  29      given a name.
  30
  31      b. `output' hold either the output template, an array of output
  32      templates, or an output function.
  33
  34      c. `genfun' is the function to generate a body for that pattern,
  35      given operands as arguments.
  36
  37      d. `n_operands' is the number of distinct operands in the pattern
  38      for that insn,
  39
  40      e. `n_dups' is the number of match_dup's that appear in the insn's
  41      pattern.  This says how many elements of `recog_data.dup_loc' are
  42      significant after an insn has been recognized.
  43
  44      f. `n_alternatives' is the number of alternatives in the constraints
  45      of each pattern.
  46
  47      g. `output_format' tells what type of thing `output' is.
  48
  49      h. `operand' is the base of an array of operand data for the insn.
  50
  51    2. An array of `struct insn_operand data', used by `operand' above.
  52
  53      a. `predicate', an int-valued function, is the match_operand predicate
  54      for this operand.
  55
  56      b. `constraint' is the constraint for this operand.
  57
  58      c. `address_p' indicates that the operand appears within ADDRESS
  59      rtx's.
  60
  61      d. `mode' is the machine mode that that operand is supposed to have.
  62
  63      e. `strict_low', is nonzero for operands contained in a STRICT_LOW_PART.
  64
  65      f. `eliminable', is nonzero for operands that are matched normally by
  66      MATCH_OPERAND; it is zero for operands that should not be changed during
  67      register elimination such as MATCH_OPERATORs.
  68
  69   The code number of an insn is simply its position in the machine
  70   description; code numbers are assigned sequentially to entries in
  71   the description, starting with code number 0.
  72
  73   Thus, the following entry in the machine description
  74
  75     (define_insn "clrdf"
  76       [(set (match_operand:DF 0 "general_operand" "")
  77             (const_int 0))]
  78       ""
  79       "clrd %0")
  80
  81   assuming it is the 25th entry present, would cause
  82   insn_data[24].template to be "clrd %0", and
  83   insn_data[24].n_operands to be 1.  */
  84 \f
  85 #include "bconfig.h"
  86 #include "system.h"
  87 #include "coretypes.h"
  88 #include "tm.h"
  89 #include "rtl.h"
  90 #include "errors.h"
  91 #include "gensupport.h"
  92
  93 /* No instruction can have more operands than this.  Sorry for this
  94    arbitrary limit, but what machine will have an instruction with
  95    this many operands?  */
  96
  97 #define MAX_MAX_OPERANDS 40
  98
  99 static int n_occurrences                (int, const char *);
 100 static const char *strip_whitespace     (const char *);
 101
 102 /* insns in the machine description are assigned sequential code numbers
 103    that are used by insn-recog.c (produced by genrecog) to communicate
 104    to insn-output.c (produced by this program).  */
 105
 106 static int next_code_number;
 107
 108 /* This counts all definitions in the md file,
 109    for the sake of error messages.  */
 110
 111 static int next_index_number;
 112
 113 /* This counts all operands used in the md file.  The first is null.  */
 114
 115 static int next_operand_number = 1;
 116
 117 /* Record in this chain all information about the operands we will output.  */
 118
 119 struct operand_data
 120 {
 121   struct operand_data *next;
 122   int index;
 123   const char *predicate;
 124   const char *constraint;
 125   enum machine_mode mode;
 126   unsigned char n_alternatives;
 127   char address_p;
 128   char strict_low;
 129   char eliminable;
 130   char seen;
 131 };
 132
 133 /* Begin with a null operand at index 0.  */
 134
 135 static struct operand_data null_operand =
 136 {
 137   0, 0, "", "", VOIDmode, 0, 0, 0, 0, 0
 138 };
 139
 140 static struct operand_data *odata = &null_operand;
 141 static struct operand_data **odata_end = &null_operand.next;
 142
 143 /* Must match the constants in recog.h.  */
 144
 145 #define INSN_OUTPUT_FORMAT_NONE         0       /* abort */
 146 #define INSN_OUTPUT_FORMAT_SINGLE       1       /* const char * */
 147 #define INSN_OUTPUT_FORMAT_MULTI        2       /* const char * const * */
 148 #define INSN_OUTPUT_FORMAT_FUNCTION     3       /* const char * (*)(...) */
 149
 150 /* Record in this chain all information that we will output,
 151    associated with the code number of the insn.  */
 152
 153 struct data
 154 {
 155   struct data *next;
 156   const char *name;
 157   const char *template_code;
 158   int code_number;
 159   int index_number;
 160   const char *filename;
 161   int lineno;
 162   int n_operands;               /* Number of operands this insn recognizes */
 163   int n_dups;                   /* Number times match_dup appears in pattern */
 164   int n_alternatives;           /* Number of alternatives in each constraint */
 165   int operand_number;           /* Operand index in the big array.  */
 166   int output_format;            /* INSN_OUTPUT_FORMAT_*.  */
 167   struct operand_data operand[MAX_MAX_OPERANDS];
 168 };
 169
 170 /* This variable points to the first link in the insn chain.  */
 171
 172 static struct data *idata, **idata_end = &idata;
 173 \f
 174 static void output_prologue (void);
 175 static void output_operand_data (void);
 176 static void output_insn_data (void);
 177 static void output_get_insn_name (void);
 178 static void scan_operands (struct data *, rtx, int, int);
 179 static int compare_operands (struct operand_data *,
 180                              struct operand_data *);
 181 static void place_operands (struct data *);
 182 static void process_template (struct data *, const char *);
 183 static void validate_insn_alternatives (struct data *);
 184 static void validate_insn_operands (struct data *);
 185 static void gen_insn (rtx, int);
 186 static void gen_peephole (rtx, int);
 187 static void gen_expand (rtx, int);
 188 static void gen_split (rtx, int);
 189
 190 #ifdef USE_MD_CONSTRAINTS
 191
 192 struct constraint_data
 193 {
 194   struct constraint_data *next_this_letter;
 195   int lineno;
 196   unsigned int namelen;
 197   const char name[1];
 198 };
 199
 200 /* This is a complete list (unlike the one in genpreds.c) of constraint
 201    letters and modifiers with machine-independent meaning.  The only
 202    omission is digits, as these are handled specially.  */
 203 static const char indep_constraints[] = ",=+%*?!#&<>EFVXgimnoprs";
 204
 205 static struct constraint_data *
 206 constraints_by_letter_table[1 << CHAR_BIT];
 207
 208 static int mdep_constraint_len (const char *, int, int);
 209 static void note_constraint (rtx, int);
 210
 211 #else  /* !USE_MD_CONSTRAINTS */
 212
 213 static void check_constraint_len (void);
 214 static int constraint_len (const char *, int);
 215
 216 #endif /* !USE_MD_CONSTRAINTS */
 217
 218 \f
 219 static void
 220 output_prologue (void)
 221 {
 222   printf ("/* Generated automatically by the program `genoutput'\n\
 223    from the machine description file `md'.  */\n\n");
 224
 225   printf ("#include \"config.h\"\n");
 226   printf ("#include \"system.h\"\n");
 227   printf ("#include \"coretypes.h\"\n");
 228   printf ("#include \"tm.h\"\n");
 229   printf ("#include \"flags.h\"\n");
 230   printf ("#include \"ggc.h\"\n");
 231   printf ("#include \"rtl.h\"\n");
 232   printf ("#include \"expr.h\"\n");
 233   printf ("#include \"insn-codes.h\"\n");
 234   printf ("#include \"tm_p.h\"\n");
 235   printf ("#include \"function.h\"\n");
 236   printf ("#include \"regs.h\"\n");
 237   printf ("#include \"hard-reg-set.h\"\n");
 238   printf ("#include \"insn-config.h\"\n\n");
 239   printf ("#include \"conditions.h\"\n");
 240   printf ("#include \"insn-attr.h\"\n\n");
 241   printf ("#include \"recog.h\"\n\n");
 242   printf ("#include \"toplev.h\"\n");
 243   printf ("#include \"output.h\"\n");
 244   printf ("#include \"target.h\"\n");
 245   printf ("#include \"tm-constrs.h\"\n");
 246 }
 247
 248 static void
 249 output_operand_data (void)
 250 {
 251   struct operand_data *d;
 252
 253   printf ("\nstatic const struct insn_operand_data operand_data[] = \n{\n");
 254
 255   for (d = odata; d; d = d->next)
 256     {
 257       printf ("  {\n");
 258
 259       printf ("    %s,\n",
 260               d->predicate && d->predicate[0] ? d->predicate : "0");
 261
 262       printf ("    \"%s\",\n", d->constraint ? d->constraint : "");
 263
 264       printf ("    %smode,\n", GET_MODE_NAME (d->mode));
 265
 266       printf ("    %d,\n", d->strict_low);
 267
 268       printf ("    %d,\n", d->constraint == NULL ? 1 : 0);
 269
 270       printf ("    %d\n", d->eliminable);
 271
 272       printf("  },\n");
 273     }
 274   printf("};\n\n\n");
 275 }
 276
 277 static void
 278 output_insn_data (void)
 279 {
 280   struct data *d;
 281   int name_offset = 0;
 282   int next_name_offset;
 283   const char * last_name = 0;
 284   const char * next_name = 0;
 285   struct data *n;
 286
 287   for (n = idata, next_name_offset = 1; n; n = n->next, next_name_offset++)
 288     if (n->name)
 289       {
 290         next_name = n->name;
 291         break;
 292       }
 293
 294   printf ("#if GCC_VERSION >= 2007\n__extension__\n#endif\n");
 295   printf ("\nconst struct insn_data insn_data[] = \n{\n");
 296
 297   for (d = idata; d; d = d->next)
 298     {
 299       printf ("  /* %s:%d */\n", d->filename, d->lineno);
 300       printf ("  {\n");
 301
 302       if (d->name)
 303         {
 304           printf ("    \"%s\",\n", d->name);
 305           name_offset = 0;
 306           last_name = d->name;
 307           next_name = 0;
 308           for (n = d->next, next_name_offset = 1; n;
 309                n = n->next, next_name_offset++)
 310             {
 311               if (n->name)
 312                 {
 313                   next_name = n->name;
 314                   break;
 315                 }
 316             }
 317         }
 318       else
 319         {
 320           name_offset++;
 321           if (next_name && (last_name == 0
 322                             || name_offset > next_name_offset / 2))
 323             printf ("    \"%s-%d\",\n", next_name,
 324                     next_name_offset - name_offset);
 325           else
 326             printf ("    \"%s+%d\",\n", last_name, name_offset);
 327         }
 328
 329       switch (d->output_format)
 330         {
 331         case INSN_OUTPUT_FORMAT_NONE:
 332           printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
 333           printf ("    { 0 },\n");
 334           printf ("#else\n");
 335           printf ("    { 0, 0, 0 },\n");
 336           printf ("#endif\n");
 337           break;
 338         case INSN_OUTPUT_FORMAT_SINGLE:
 339           {
 340             const char *p = d->template_code;
 341             char prev = 0;
 342
 343             printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
 344             printf ("    { .single =\n");
 345             printf ("#else\n");
 346             printf ("    {\n");
 347             printf ("#endif\n");
 348             printf ("    \"");
 349             while (*p)
 350               {
 351                 if (IS_VSPACE (*p) && prev != '\\')
 352                   {
 353                     /* Preserve two consecutive \n's or \r's, but treat \r\n
 354                        as a single newline.  */
 355                     if (*p == '\n' && prev != '\r')
 356                       printf ("\\n\\\n");
 357                   }
 358                 else
 359                   putchar (*p);
 360                 prev = *p;
 361                 ++p;
 362               }
 363             printf ("\",\n");
 364             printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
 365             printf ("    },\n");
 366             printf ("#else\n");
 367             printf ("    0, 0 },\n");
 368             printf ("#endif\n");
 369           }
 370           break;
 371         case INSN_OUTPUT_FORMAT_MULTI:
 372           printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
 373           printf ("    { .multi = output_%d },\n", d->code_number);
 374           printf ("#else\n");
 375           printf ("    { 0, output_%d, 0 },\n", d->code_number);
 376           printf ("#endif\n");
 377           break;
 378         case INSN_OUTPUT_FORMAT_FUNCTION:
 379           printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
 380           printf ("    { .function = output_%d },\n", d->code_number);
 381           printf ("#else\n");
 382           printf ("    { 0, 0, output_%d },\n", d->code_number);
 383           printf ("#endif\n");
 384           break;
 385         default:
 386           gcc_unreachable ();
 387         }
 388
 389       if (d->name && d->name[0] != '*')
 390         printf ("    (insn_gen_fn) gen_%s,\n", d->name);
 391       else
 392         printf ("    0,\n");
 393
 394       printf ("    &operand_data[%d],\n", d->operand_number);
 395       printf ("    %d,\n", d->n_operands);
 396       printf ("    %d,\n", d->n_dups);
 397       printf ("    %d,\n", d->n_alternatives);
 398       printf ("    %d\n", d->output_format);
 399
 400       printf("  },\n");
 401     }
 402   printf ("};\n\n\n");
 403 }
 404
 405 static void
 406 output_get_insn_name (void)
 407 {
 408   printf ("const char *\n");
 409   printf ("get_insn_name (int code)\n");
 410   printf ("{\n");
 411   printf ("  if (code == NOOP_MOVE_INSN_CODE)\n");
 412   printf ("    return \"NOOP_MOVE\";\n");
 413   printf ("  else\n");
 414   printf ("    return insn_data[code].name;\n");
 415   printf ("}\n");
 416 }
 417
 418 \f
 419 /* Stores in max_opno the largest operand number present in `part', if
 420    that is larger than the previous value of max_opno, and the rest of
 421    the operand data into `d->operand[i]'.
 422
 423    THIS_ADDRESS_P is nonzero if the containing rtx was an ADDRESS.
 424    THIS_STRICT_LOW is nonzero if the containing rtx was a STRICT_LOW_PART.  */
 425
 426 static int max_opno;
 427 static int num_dups;
 428
 429 static void
 430 scan_operands (struct data *d, rtx part, int this_address_p,
 431                int this_strict_low)
 432 {
 433   int i, j;
 434   const char *format_ptr;
 435   int opno;
 436
 437   if (part == 0)
 438     return;
 439
 440   switch (GET_CODE (part))
 441     {
 442     case MATCH_OPERAND:
 443       opno = XINT (part, 0);
 444       if (opno > max_opno)
 445         max_opno = opno;
 446       if (max_opno >= MAX_MAX_OPERANDS)
 447         {
 448           message_with_line (d->lineno,
 449                              "maximum number of operands exceeded");
 450           have_error = 1;
 451           return;
 452         }
 453       if (d->operand[opno].seen)
 454         {
 455           message_with_line (d->lineno,
 456                              "repeated operand number %d\n", opno);
 457           have_error = 1;
 458         }
 459
 460       d->operand[opno].seen = 1;
 461       d->operand[opno].mode = GET_MODE (part);
 462       d->operand[opno].strict_low = this_strict_low;
 463       d->operand[opno].predicate = XSTR (part, 1);
 464       d->operand[opno].constraint = strip_whitespace (XSTR (part, 2));
 465       d->operand[opno].n_alternatives
 466         = n_occurrences (',', d->operand[opno].constraint) + 1;
 467       d->operand[opno].address_p = this_address_p;
 468       d->operand[opno].eliminable = 1;
 469       return;
 470
 471     case MATCH_SCRATCH:
 472       opno = XINT (part, 0);
 473       if (opno > max_opno)
 474         max_opno = opno;
 475       if (max_opno >= MAX_MAX_OPERANDS)
 476         {
 477           message_with_line (d->lineno,
 478                              "maximum number of operands exceeded");
 479           have_error = 1;
 480           return;
 481         }
 482       if (d->operand[opno].seen)
 483         {
 484           message_with_line (d->lineno,
 485                              "repeated operand number %d\n", opno);
 486           have_error = 1;
 487         }
 488
 489       d->operand[opno].seen = 1;
 490       d->operand[opno].mode = GET_MODE (part);
 491       d->operand[opno].strict_low = 0;
 492       d->operand[opno].predicate = "scratch_operand";
 493       d->operand[opno].constraint = strip_whitespace (XSTR (part, 1));
 494       d->operand[opno].n_alternatives
 495         = n_occurrences (',', d->operand[opno].constraint) + 1;
 496       d->operand[opno].address_p = 0;
 497       d->operand[opno].eliminable = 0;
 498       return;
 499
 500     case MATCH_OPERATOR:
 501     case MATCH_PARALLEL:
 502       opno = XINT (part, 0);
 503       if (opno > max_opno)
 504         max_opno = opno;
 505       if (max_opno >= MAX_MAX_OPERANDS)
 506         {
 507           message_with_line (d->lineno,
 508                              "maximum number of operands exceeded");
 509           have_error = 1;
 510           return;
 511         }
 512       if (d->operand[opno].seen)
 513         {
 514           message_with_line (d->lineno,
 515                              "repeated operand number %d\n", opno);
 516           have_error = 1;
 517         }
 518
 519       d->operand[opno].seen = 1;
 520       d->operand[opno].mode = GET_MODE (part);
 521       d->operand[opno].strict_low = 0;
 522       d->operand[opno].predicate = XSTR (part, 1);
 523       d->operand[opno].constraint = 0;
 524       d->operand[opno].address_p = 0;
 525       d->operand[opno].eliminable = 0;
 526       for (i = 0; i < XVECLEN (part, 2); i++)
 527         scan_operands (d, XVECEXP (part, 2, i), 0, 0);
 528       return;
 529
 530     case MATCH_DUP:
 531     case MATCH_OP_DUP:
 532     case MATCH_PAR_DUP:
 533       ++num_dups;
 534       break;
 535
 536     case ADDRESS:
 537       scan_operands (d, XEXP (part, 0), 1, 0);
 538       return;
 539
 540     case STRICT_LOW_PART:
 541       scan_operands (d, XEXP (part, 0), 0, 1);
 542       return;
 543
 544     default:
 545       break;
 546     }
 547
 548   format_ptr = GET_RTX_FORMAT (GET_CODE (part));
 549
 550   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
 551     switch (*format_ptr++)
 552       {
 553       case 'e':
 554       case 'u':
 555         scan_operands (d, XEXP (part, i), 0, 0);
 556         break;
 557       case 'E':
 558         if (XVEC (part, i) != NULL)
 559           for (j = 0; j < XVECLEN (part, i); j++)
 560             scan_operands (d, XVECEXP (part, i, j), 0, 0);
 561         break;
 562       }
 563 }
 564
 565 /* Compare two operands for content equality.  */
 566
 567 static int
 568 compare_operands (struct operand_data *d0, struct operand_data *d1)
 569 {
 570   const char *p0, *p1;
 571
 572   p0 = d0->predicate;
 573   if (!p0)
 574     p0 = "";
 575   p1 = d1->predicate;
 576   if (!p1)
 577     p1 = "";
 578   if (strcmp (p0, p1) != 0)
 579     return 0;
 580
 581   p0 = d0->constraint;
 582   if (!p0)
 583     p0 = "";
 584   p1 = d1->constraint;
 585   if (!p1)
 586     p1 = "";
 587   if (strcmp (p0, p1) != 0)
 588     return 0;
 589
 590   if (d0->mode != d1->mode)
 591     return 0;
 592
 593   if (d0->strict_low != d1->strict_low)
 594     return 0;
 595
 596   if (d0->eliminable != d1->eliminable)
 597     return 0;
 598
 599   return 1;
 600 }
 601
 602 /* Scan the list of operands we've already committed to output and either
 603    find a subsequence that is the same, or allocate a new one at the end.  */
 604
 605 static void
 606 place_operands (struct data *d)
 607 {
 608   struct operand_data *od, *od2;
 609   int i;
 610
 611   if (d->n_operands == 0)
 612     {
 613       d->operand_number = 0;
 614       return;
 615     }
 616
 617   /* Brute force substring search.  */
 618   for (od = odata, i = 0; od; od = od->next, i = 0)
 619     if (compare_operands (od, &d->operand[0]))
 620       {
 621         od2 = od->next;
 622         i = 1;
 623         while (1)
 624           {
 625             if (i == d->n_operands)
 626               goto full_match;
 627             if (od2 == NULL)
 628               goto partial_match;
 629             if (! compare_operands (od2, &d->operand[i]))
 630               break;
 631             ++i, od2 = od2->next;
 632           }
 633       }
 634
 635   /* Either partial match at the end of the list, or no match.  In either
 636      case, we tack on what operands are remaining to the end of the list.  */
 637  partial_match:
 638   d->operand_number = next_operand_number - i;
 639   for (; i < d->n_operands; ++i)
 640     {
 641       od2 = &d->operand[i];
 642       *odata_end = od2;
 643       odata_end = &od2->next;
 644       od2->index = next_operand_number++;
 645     }
 646   *odata_end = NULL;
 647   return;
 648
 649  full_match:
 650   d->operand_number = od->index;
 651   return;
 652 }
 653
 654 \f
 655 /* Process an assembler template from a define_insn or a define_peephole.
 656    It is either the assembler code template, a list of assembler code
 657    templates, or C code to generate the assembler code template.  */
 658
 659 static void
 660 process_template (struct data *d, const char *template_code)
 661 {
 662   const char *cp;
 663   int i;
 664
 665   /* Templates starting with * contain straight code to be run.  */
 666   if (template_code[0] == '*')
 667     {
 668       d->template_code = 0;
 669       d->output_format = INSN_OUTPUT_FORMAT_FUNCTION;
 670
 671       puts ("\nstatic const char *");
 672       printf ("output_%d (rtx *operands ATTRIBUTE_UNUSED, rtx insn ATTRIBUTE_UNUSED)\n",
 673               d->code_number);
 674       puts ("{");
 675       print_rtx_ptr_loc (template_code);
 676       puts (template_code + 1);
 677       puts ("}");
 678     }
 679
 680   /* If the assembler code template starts with a @ it is a newline-separated
 681      list of assembler code templates, one for each alternative.  */
 682   else if (template_code[0] == '@')
 683     {
 684       d->template_code = 0;
 685       d->output_format = INSN_OUTPUT_FORMAT_MULTI;
 686
 687       printf ("\nstatic const char * const output_%d[] = {\n", d->code_number);
 688
 689       for (i = 0, cp = &template_code[1]; *cp; )
 690         {
 691           const char *ep, *sp;
 692
 693           while (ISSPACE (*cp))
 694             cp++;
 695
 696           printf ("  \"");
 697
 698           for (ep = sp = cp; !IS_VSPACE (*ep) && *ep != '\0'; ++ep)
 699             if (!ISSPACE (*ep))
 700               sp = ep + 1;
 701
 702           if (sp != ep)
 703             message_with_line (d->lineno,
 704                                "trailing whitespace in output template");
 705
 706           while (cp < sp)
 707             {
 708               putchar (*cp);
 709               cp++;
 710             }
 711
 712           printf ("\",\n");
 713           i++;
 714         }
 715       if (i == 1)
 716         message_with_line (d->lineno,
 717                            "'@' is redundant for output template with single alternative");
 718       if (i != d->n_alternatives)
 719         {
 720           message_with_line (d->lineno,
 721                              "wrong number of alternatives in the output template");
 722           have_error = 1;
 723         }
 724
 725       printf ("};\n");
 726     }
 727   else
 728     {
 729       d->template_code = template_code;
 730       d->output_format = INSN_OUTPUT_FORMAT_SINGLE;
 731     }
 732 }
 733 \f
 734 /* Check insn D for consistency in number of constraint alternatives.  */
 735
 736 static void
 737 validate_insn_alternatives (struct data *d)
 738 {
 739   int n = 0, start;
 740
 741   /* Make sure all the operands have the same number of alternatives
 742      in their constraints.  Let N be that number.  */
 743   for (start = 0; start < d->n_operands; start++)
 744     if (d->operand[start].n_alternatives > 0)
 745       {
 746         int len, i;
 747         const char *p;
 748         char c;
 749         int which_alternative = 0;
 750         int alternative_count_unsure = 0;
 751
 752         for (p = d->operand[start].constraint; (c = *p); p += len)
 753           {
 754 #ifdef USE_MD_CONSTRAINTS
 755             if (ISSPACE (c) || strchr (indep_constraints, c))
 756               len = 1;
 757             else if (ISDIGIT (c))
 758               {
 759                 const char *q = p;
 760                 do
 761                   q++;
 762                 while (ISDIGIT (*q));
 763                 len = q - p;
 764               }
 765             else
 766               len = mdep_constraint_len (p, d->lineno, start);
 767 #else
 768             len = CONSTRAINT_LEN (c, p);
 769
 770             if (len < 1 || (len > 1 && strchr (",#*+=&%!0123456789", c)))
 771               {
 772                 message_with_line (d->lineno,
 773                                    "invalid length %d for char '%c' in alternative %d of operand %d",
 774                                     len, c, which_alternative, start);
 775                 len = 1;
 776                 have_error = 1;
 777               }
 778 #endif
 779
 780             if (c == ',')
 781               {
 782                 which_alternative++;
 783                 continue;
 784               }
 785
 786             for (i = 1; i < len; i++)
 787               if (p[i] == '\0')
 788                 {
 789                   message_with_line (d->lineno,
 790                                      "NUL in alternative %d of operand %d",
 791                                      which_alternative, start);
 792                   alternative_count_unsure = 1;
 793                   break;
 794                 }
 795               else if (strchr (",#*", p[i]))
 796                 {
 797                   message_with_line (d->lineno,
 798                                      "'%c' in alternative %d of operand %d",
 799                                      p[i], which_alternative, start);
 800                   alternative_count_unsure = 1;
 801                 }
 802           }
 803         if (alternative_count_unsure)
 804           have_error = 1;
 805         else if (n == 0)
 806           n = d->operand[start].n_alternatives;
 807         else if (n != d->operand[start].n_alternatives)
 808           {
 809             message_with_line (d->lineno,
 810                                "wrong number of alternatives in operand %d",
 811                                start);
 812             have_error = 1;
 813           }
 814       }
 815
 816   /* Record the insn's overall number of alternatives.  */
 817   d->n_alternatives = n;
 818 }
 819
 820 /* Verify that there are no gaps in operand numbers for INSNs.  */
 821
 822 static void
 823 validate_insn_operands (struct data *d)
 824 {
 825   int i;
 826
 827   for (i = 0; i < d->n_operands; ++i)
 828     if (d->operand[i].seen == 0)
 829       {
 830         message_with_line (d->lineno, "missing operand %d", i);
 831         have_error = 1;
 832       }
 833 }
 834
 835 static void
 836 validate_optab_operands (struct data *d)
 837 {
 838   if (!d->name || d->name[0] == '\0' || d->name[0] == '*')
 839     return;
 840
 841   /* Miscellaneous tests.  */
 842   if (strncmp (d->name, "cstore", 6) == 0
 843       && d->name[strlen (d->name) - 1] == '4'
 844       && d->operand[0].mode == VOIDmode)
 845     {
 846       message_with_line (d->lineno, "missing mode for operand 0 of cstore");
 847       have_error = 1;
 848     }
 849 }
 850 \f
 851 /* Look at a define_insn just read.  Assign its code number.  Record
 852    on idata the template and the number of arguments.  If the insn has
 853    a hairy output action, output a function for now.  */
 854
 855 static void
 856 gen_insn (rtx insn, int lineno)
 857 {
 858   struct data *d = XNEW (struct data);
 859   int i;
 860
 861   d->code_number = next_code_number;
 862   d->index_number = next_index_number;
 863   d->filename = read_rtx_filename;
 864   d->lineno = lineno;
 865   if (XSTR (insn, 0)[0])
 866     d->name = XSTR (insn, 0);
 867   else
 868     d->name = 0;
 869
 870   /* Build up the list in the same order as the insns are seen
 871      in the machine description.  */
 872   d->next = 0;
 873   *idata_end = d;
 874   idata_end = &d->next;
 875
 876   max_opno = -1;
 877   num_dups = 0;
 878   memset (d->operand, 0, sizeof (d->operand));
 879
 880   for (i = 0; i < XVECLEN (insn, 1); i++)
 881     scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
 882
 883   d->n_operands = max_opno + 1;
 884   d->n_dups = num_dups;
 885
 886 #ifndef USE_MD_CONSTRAINTS
 887   check_constraint_len ();
 888 #endif
 889   validate_insn_operands (d);
 890   validate_insn_alternatives (d);
 891   validate_optab_operands (d);
 892   place_operands (d);
 893   process_template (d, XTMPL (insn, 3));
 894 }
 895 \f
 896 /* Look at a define_peephole just read.  Assign its code number.
 897    Record on idata the template and the number of arguments.
 898    If the insn has a hairy output action, output it now.  */
 899
 900 static void
 901 gen_peephole (rtx peep, int lineno)
 902 {
 903   struct data *d = XNEW (struct data);
 904   int i;
 905
 906   d->code_number = next_code_number;
 907   d->index_number = next_index_number;
 908   d->filename = read_rtx_filename;
 909   d->lineno = lineno;
 910   d->name = 0;
 911
 912   /* Build up the list in the same order as the insns are seen
 913      in the machine description.  */
 914   d->next = 0;
 915   *idata_end = d;
 916   idata_end = &d->next;
 917
 918   max_opno = -1;
 919   num_dups = 0;
 920   memset (d->operand, 0, sizeof (d->operand));
 921
 922   /* Get the number of operands by scanning all the patterns of the
 923      peephole optimizer.  But ignore all the rest of the information
 924      thus obtained.  */
 925   for (i = 0; i < XVECLEN (peep, 0); i++)
 926     scan_operands (d, XVECEXP (peep, 0, i), 0, 0);
 927
 928   d->n_operands = max_opno + 1;
 929   d->n_dups = 0;
 930
 931   validate_insn_alternatives (d);
 932   place_operands (d);
 933   process_template (d, XTMPL (peep, 2));
 934 }
 935 \f
 936 /* Process a define_expand just read.  Assign its code number,
 937    only for the purposes of `insn_gen_function'.  */
 938
 939 static void
 940 gen_expand (rtx insn, int lineno)
 941 {
 942   struct data *d = XNEW (struct data);
 943   int i;
 944
 945   d->code_number = next_code_number;
 946   d->index_number = next_index_number;
 947   d->filename = read_rtx_filename;
 948   d->lineno = lineno;
 949   if (XSTR (insn, 0)[0])
 950     d->name = XSTR (insn, 0);
 951   else
 952     d->name = 0;
 953
 954   /* Build up the list in the same order as the insns are seen
 955      in the machine description.  */
 956   d->next = 0;
 957   *idata_end = d;
 958   idata_end = &d->next;
 959
 960   max_opno = -1;
 961   num_dups = 0;
 962   memset (d->operand, 0, sizeof (d->operand));
 963
 964   /* Scan the operands to get the specified predicates and modes,
 965      since expand_binop needs to know them.  */
 966
 967   if (XVEC (insn, 1))
 968     for (i = 0; i < XVECLEN (insn, 1); i++)
 969       scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
 970
 971   d->n_operands = max_opno + 1;
 972   d->n_dups = num_dups;
 973   d->template_code = 0;
 974   d->output_format = INSN_OUTPUT_FORMAT_NONE;
 975
 976   validate_insn_alternatives (d);
 977   validate_optab_operands (d);
 978   place_operands (d);
 979 }
 980 \f
 981 /* Process a define_split just read.  Assign its code number,
 982    only for reasons of consistency and to simplify genrecog.  */
 983
 984 static void
 985 gen_split (rtx split, int lineno)
 986 {
 987   struct data *d = XNEW (struct data);
 988   int i;
 989
 990   d->code_number = next_code_number;
 991   d->index_number = next_index_number;
 992   d->filename = read_rtx_filename;
 993   d->lineno = lineno;
 994   d->name = 0;
 995
 996   /* Build up the list in the same order as the insns are seen
 997      in the machine description.  */
 998   d->next = 0;
 999   *idata_end = d;
1000   idata_end = &d->next;
1001
1002   max_opno = -1;
1003   num_dups = 0;
1004   memset (d->operand, 0, sizeof (d->operand));
1005
1006   /* Get the number of operands by scanning all the patterns of the
1007      split patterns.  But ignore all the rest of the information thus
1008      obtained.  */
1009   for (i = 0; i < XVECLEN (split, 0); i++)
1010     scan_operands (d, XVECEXP (split, 0, i), 0, 0);
1011
1012   d->n_operands = max_opno + 1;
1013   d->n_dups = 0;
1014   d->n_alternatives = 0;
1015   d->template_code = 0;
1016   d->output_format = INSN_OUTPUT_FORMAT_NONE;
1017
1018   place_operands (d);
1019 }
1020
1021 extern int main (int, char **);
1022
1023 int
1024 main (int argc, char **argv)
1025 {
1026   rtx desc;
1027
1028   progname = "genoutput";
1029
1030   if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
1031     return (FATAL_EXIT_CODE);
1032
1033   output_prologue ();
1034   next_code_number = 0;
1035   next_index_number = 0;
1036
1037   /* Read the machine description.  */
1038
1039   while (1)
1040     {
1041       int line_no;
1042
1043       desc = read_md_rtx (&line_no, &next_code_number);
1044       if (desc == NULL)
1045         break;
1046
1047       switch (GET_CODE (desc))
1048         {
1049         case DEFINE_INSN:
1050           gen_insn (desc, line_no);
1051           break;
1052
1053         case DEFINE_PEEPHOLE:
1054           gen_peephole (desc, line_no);
1055           break;
1056
1057         case DEFINE_EXPAND:
1058           gen_expand (desc, line_no);
1059           break;
1060
1061         case DEFINE_SPLIT:
1062         case DEFINE_PEEPHOLE2:
1063           gen_split (desc, line_no);
1064           break;
1065
1066 #ifdef USE_MD_CONSTRAINTS
1067         case DEFINE_CONSTRAINT:
1068         case DEFINE_REGISTER_CONSTRAINT:
1069         case DEFINE_ADDRESS_CONSTRAINT:
1070         case DEFINE_MEMORY_CONSTRAINT:
1071           note_constraint (desc, line_no);
1072           break;
1073 #endif
1074
1075         default:
1076           break;
1077         }
1078       next_index_number++;
1079     }
1080
1081   printf("\n\n");
1082   output_operand_data ();
1083   output_insn_data ();
1084   output_get_insn_name ();
1085
1086   fflush (stdout);
1087   return (ferror (stdout) != 0 || have_error
1088         ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
1089 }
1090
1091 /* Return the number of occurrences of character C in string S or
1092    -1 if S is the null string.  */
1093
1094 static int
1095 n_occurrences (int c, const char *s)
1096 {
1097   int n = 0;
1098
1099   if (s == 0 || *s == '\0')
1100     return -1;
1101
1102   while (*s)
1103     n += (*s++ == c);
1104
1105   return n;
1106 }
1107
1108 /* Remove whitespace in `s' by moving up characters until the end.
1109    Return a new string.  */
1110
1111 static const char *
1112 strip_whitespace (const char *s)
1113 {
1114   char *p, *q;
1115   char ch;
1116
1117   if (s == 0)
1118     return 0;
1119
1120   p = q = XNEWVEC (char, strlen (s) + 1);
1121   while ((ch = *s++) != '\0')
1122     if (! ISSPACE (ch))
1123       *p++ = ch;
1124
1125   *p = '\0';
1126   return q;
1127 }
1128
1129 #ifdef USE_MD_CONSTRAINTS
1130
1131 /* Record just enough information about a constraint to allow checking
1132    of operand constraint strings above, in validate_insn_alternatives.
1133    Does not validate most properties of the constraint itself; does
1134    enforce no duplicate names, no overlap with MI constraints, and no
1135    prefixes.  EXP is the define_*constraint form, LINENO the line number
1136    reported by the reader.  */
1137 static void
1138 note_constraint (rtx exp, int lineno)
1139 {
1140   const char *name = XSTR (exp, 0);
1141   unsigned int namelen = strlen (name);
1142   struct constraint_data **iter, **slot, *new_cdata;
1143
1144   /* The 'm' constraint is special here since that constraint letter
1145      can be overridden by the back end by defining the
1146      TARGET_MEM_CONSTRAINT macro.  */
1147   if (strchr (indep_constraints, name[0]) && name[0] != 'm')
1148     {
1149       if (name[1] == '\0')
1150         message_with_line (lineno, "constraint letter '%s' cannot be "
1151                            "redefined by the machine description", name);
1152       else
1153         message_with_line (lineno, "constraint name '%s' cannot be defined by "
1154                            "the machine description, as it begins with '%c'",
1155                            name, name[0]);
1156       have_error = 1;
1157       return;
1158     }
1159
1160   slot = &constraints_by_letter_table[(unsigned int)name[0]];
1161   for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
1162     {
1163       /* This causes slot to end up pointing to the
1164          next_this_letter field of the last constraint with a name
1165          of equal or greater length than the new constraint; hence
1166          the new constraint will be inserted after all previous
1167          constraints with names of the same length.  */
1168       if ((*iter)->namelen >= namelen)
1169         slot = iter;
1170
1171       if (!strcmp ((*iter)->name, name))
1172         {
1173           message_with_line (lineno, "redefinition of constraint '%s'", name);
1174           message_with_line ((*iter)->lineno, "previous definition is here");
1175           have_error = 1;
1176           return;
1177         }
1178       else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
1179         {
1180           message_with_line (lineno, "defining constraint '%s' here", name);
1181           message_with_line ((*iter)->lineno, "renders constraint '%s' "
1182                              "(defined here) a prefix", (*iter)->name);
1183           have_error = 1;
1184           return;
1185         }
1186       else if (!strncmp ((*iter)->name, name, namelen))
1187         {
1188           message_with_line (lineno, "constraint '%s' is a prefix", name);
1189           message_with_line ((*iter)->lineno, "of constraint '%s' "
1190                              "(defined here)", (*iter)->name);
1191           have_error = 1;
1192           return;
1193         }
1194     }
1195   new_cdata = XNEWVAR (struct constraint_data, sizeof (struct constraint_data) + namelen);
1196   strcpy ((char *)new_cdata + offsetof(struct constraint_data, name), name);
1197   new_cdata->namelen = namelen;
1198   new_cdata->lineno = lineno;
1199   new_cdata->next_this_letter = *slot;
1200   *slot = new_cdata;
1201 }
1202
1203 /* Return the length of the constraint name beginning at position S
1204    of an operand constraint string, or issue an error message if there
1205    is no such constraint.  Does not expect to be called for generic
1206    constraints.  */
1207 static int
1208 mdep_constraint_len (const char *s, int lineno, int opno)
1209 {
1210   struct constraint_data *p;
1211
1212   p = constraints_by_letter_table[(unsigned int)s[0]];
1213
1214   if (p)
1215     for (; p; p = p->next_this_letter)
1216       if (!strncmp (s, p->name, p->namelen))
1217         return p->namelen;
1218
1219   message_with_line (lineno,
1220                      "error: undefined machine-specific constraint "
1221                      "at this point: \"%s\"", s);
1222   message_with_line (lineno, "note:  in operand %d", opno);
1223   have_error = 1;
1224   return 1; /* safe */
1225 }
1226
1227 #else
1228 /* Verify that DEFAULT_CONSTRAINT_LEN is used properly and not
1229    tampered with.  This isn't bullet-proof, but it should catch
1230    most genuine mistakes.  */
1231 static void
1232 check_constraint_len (void)
1233 {
1234   const char *p;
1235   int d;
1236
1237   for (p = ",#*+=&%!1234567890"; *p; p++)
1238     for (d = -9; d < 9; d++)
1239       gcc_assert (constraint_len (p, d) == d);
1240 }
1241
1242 static int
1243 constraint_len (const char *p, int genoutput_default_constraint_len)
1244 {
1245   /* Check that we still match defaults.h .  First we do a generation-time
1246      check that fails if the value is not the expected one...  */
1247   gcc_assert (DEFAULT_CONSTRAINT_LEN (*p, p) == 1);
1248   /* And now a compile-time check that should give a diagnostic if the
1249      definition doesn't exactly match.  */
1250 #define DEFAULT_CONSTRAINT_LEN(C,STR) 1
1251   /* Now re-define DEFAULT_CONSTRAINT_LEN so that we can verify it is
1252      being used.  */
1253 #undef DEFAULT_CONSTRAINT_LEN
1254 #define DEFAULT_CONSTRAINT_LEN(C,STR) \
1255   ((C) != *p || STR != p ? -1 : genoutput_default_constraint_len)
1256   return CONSTRAINT_LEN (*p, p);
1257   /* And set it back.  */
1258 #undef DEFAULT_CONSTRAINT_LEN
1259 #define DEFAULT_CONSTRAINT_LEN(C,STR) 1
1260 }
1261 #endif