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