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 ("  if (code == NOOP_MOVE_INSN_CODE)\n");
 423   printf ("    return \"NOOP_MOVE\";\n");
 424   printf ("  else\n");
 425   printf ("    return insn_data[code].name;\n");
 426   printf ("}\n");
 427 }
 428
 429 \f
 430 /* Stores in max_opno the largest operand number present in `part', if
 431    that is larger than the previous value of max_opno, and the rest of
 432    the operand data into `d->operand[i]'.
 433
 434    THIS_ADDRESS_P is nonzero if the containing rtx was an ADDRESS.
 435    THIS_STRICT_LOW is nonzero if the containing rtx was a STRICT_LOW_PART.  */
 436
 437 static int max_opno;
 438 static int num_dups;
 439
 440 static void
 441 scan_operands (d, part, this_address_p, this_strict_low)
 442      struct data *d;
 443      rtx part;
 444      int this_address_p;
 445      int this_strict_low;
 446 {
 447   int i, j;
 448   const char *format_ptr;
 449   int opno;
 450
 451   if (part == 0)
 452     return;
 453
 454   switch (GET_CODE (part))
 455     {
 456     case MATCH_OPERAND:
 457       opno = XINT (part, 0);
 458       if (opno > max_opno)
 459         max_opno = opno;
 460       if (max_opno >= MAX_MAX_OPERANDS)
 461         {
 462           message_with_line (d->lineno,
 463                              "maximum number of operands exceeded");
 464           have_error = 1;
 465           return;
 466         }
 467       if (d->operand[opno].seen)
 468         {
 469           message_with_line (d->lineno,
 470                              "repeated operand number %d\n", opno);
 471           have_error = 1;
 472         }
 473
 474       d->operand[opno].seen = 1;
 475       d->operand[opno].mode = GET_MODE (part);
 476       d->operand[opno].strict_low = this_strict_low;
 477       d->operand[opno].predicate = XSTR (part, 1);
 478       d->operand[opno].constraint = strip_whitespace (XSTR (part, 2));
 479       d->operand[opno].n_alternatives
 480         = n_occurrences (',', d->operand[opno].constraint) + 1;
 481       d->operand[opno].address_p = this_address_p;
 482       d->operand[opno].eliminable = 1;
 483       return;
 484
 485     case MATCH_SCRATCH:
 486       opno = XINT (part, 0);
 487       if (opno > max_opno)
 488         max_opno = opno;
 489       if (max_opno >= MAX_MAX_OPERANDS)
 490         {
 491           message_with_line (d->lineno,
 492                              "maximum number of operands exceeded");
 493           have_error = 1;
 494           return;
 495         }
 496       if (d->operand[opno].seen)
 497         {
 498           message_with_line (d->lineno,
 499                              "repeated operand number %d\n", opno);
 500           have_error = 1;
 501         }
 502
 503       d->operand[opno].seen = 1;
 504       d->operand[opno].mode = GET_MODE (part);
 505       d->operand[opno].strict_low = 0;
 506       d->operand[opno].predicate = "scratch_operand";
 507       d->operand[opno].constraint = strip_whitespace (XSTR (part, 1));
 508       d->operand[opno].n_alternatives
 509         = n_occurrences (',', d->operand[opno].constraint) + 1;
 510       d->operand[opno].address_p = 0;
 511       d->operand[opno].eliminable = 0;
 512       return;
 513
 514     case MATCH_OPERATOR:
 515     case MATCH_PARALLEL:
 516       opno = XINT (part, 0);
 517       if (opno > max_opno)
 518         max_opno = opno;
 519       if (max_opno >= MAX_MAX_OPERANDS)
 520         {
 521           message_with_line (d->lineno,
 522                              "maximum number of operands exceeded");
 523           have_error = 1;
 524           return;
 525         }
 526       if (d->operand[opno].seen)
 527         {
 528           message_with_line (d->lineno,
 529                              "repeated operand number %d\n", opno);
 530           have_error = 1;
 531         }
 532
 533       d->operand[opno].seen = 1;
 534       d->operand[opno].mode = GET_MODE (part);
 535       d->operand[opno].strict_low = 0;
 536       d->operand[opno].predicate = XSTR (part, 1);
 537       d->operand[opno].constraint = 0;
 538       d->operand[opno].address_p = 0;
 539       d->operand[opno].eliminable = 0;
 540       for (i = 0; i < XVECLEN (part, 2); i++)
 541         scan_operands (d, XVECEXP (part, 2, i), 0, 0);
 542       return;
 543
 544     case MATCH_DUP:
 545     case MATCH_OP_DUP:
 546     case MATCH_PAR_DUP:
 547       ++num_dups;
 548       break;
 549
 550     case ADDRESS:
 551       scan_operands (d, XEXP (part, 0), 1, 0);
 552       return;
 553
 554     case STRICT_LOW_PART:
 555       scan_operands (d, XEXP (part, 0), 0, 1);
 556       return;
 557
 558     default:
 559       break;
 560     }
 561
 562   format_ptr = GET_RTX_FORMAT (GET_CODE (part));
 563
 564   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
 565     switch (*format_ptr++)
 566       {
 567       case 'e':
 568       case 'u':
 569         scan_operands (d, XEXP (part, i), 0, 0);
 570         break;
 571       case 'E':
 572         if (XVEC (part, i) != NULL)
 573           for (j = 0; j < XVECLEN (part, i); j++)
 574             scan_operands (d, XVECEXP (part, i, j), 0, 0);
 575         break;
 576       }
 577 }
 578
 579 /* Compare two operands for content equality.  */
 580
 581 static int
 582 compare_operands (d0, d1)
 583      struct operand_data *d0, *d1;
 584 {
 585   const char *p0, *p1;
 586
 587   p0 = d0->predicate;
 588   if (!p0)
 589     p0 = "";
 590   p1 = d1->predicate;
 591   if (!p1)
 592     p1 = "";
 593   if (strcmp (p0, p1) != 0)
 594     return 0;
 595
 596   p0 = d0->constraint;
 597   if (!p0)
 598     p0 = "";
 599   p1 = d1->constraint;
 600   if (!p1)
 601     p1 = "";
 602   if (strcmp (p0, p1) != 0)
 603     return 0;
 604
 605   if (d0->mode != d1->mode)
 606     return 0;
 607
 608   if (d0->strict_low != d1->strict_low)
 609     return 0;
 610
 611   if (d0->eliminable != d1->eliminable)
 612     return 0;
 613
 614   return 1;
 615 }
 616
 617 /* Scan the list of operands we've already committed to output and either
 618    find a subsequence that is the same, or allocate a new one at the end.  */
 619
 620 static void
 621 place_operands (d)
 622      struct data *d;
 623 {
 624   struct operand_data *od, *od2;
 625   int i;
 626
 627   if (d->n_operands == 0)
 628     {
 629       d->operand_number = 0;
 630       return;
 631     }
 632
 633   /* Brute force substring search.  */
 634   for (od = odata, i = 0; od; od = od->next, i = 0)
 635     if (compare_operands (od, &d->operand[0]))
 636       {
 637         od2 = od->next;
 638         i = 1;
 639         while (1)
 640           {
 641             if (i == d->n_operands)
 642               goto full_match;
 643             if (od2 == NULL)
 644               goto partial_match;
 645             if (! compare_operands (od2, &d->operand[i]))
 646               break;
 647             ++i, od2 = od2->next;
 648           }
 649       }
 650
 651   /* Either partial match at the end of the list, or no match.  In either
 652      case, we tack on what operands are remaining to the end of the list.  */
 653  partial_match:
 654   d->operand_number = next_operand_number - i;
 655   for (; i < d->n_operands; ++i)
 656     {
 657       od2 = &d->operand[i];
 658       *odata_end = od2;
 659       odata_end = &od2->next;
 660       od2->index = next_operand_number++;
 661     }
 662   *odata_end = NULL;
 663   return;
 664
 665  full_match:
 666   d->operand_number = od->index;
 667   return;
 668 }
 669
 670 \f
 671 /* Process an assembler template from a define_insn or a define_peephole.
 672    It is either the assembler code template, a list of assembler code
 673    templates, or C code to generate the assembler code template.  */
 674
 675 static void
 676 process_template (d, template)
 677     struct data *d;
 678     const char *template;
 679 {
 680   const char *cp;
 681   int i;
 682
 683   /* Templates starting with * contain straight code to be run.  */
 684   if (template[0] == '*')
 685     {
 686       d->template = 0;
 687       d->output_format = INSN_OUTPUT_FORMAT_FUNCTION;
 688
 689       printf ("\nstatic const char *output_%d PARAMS ((rtx *, rtx));\n",
 690               d->code_number);
 691       puts ("\nstatic const char *");
 692       printf ("output_%d (operands, insn)\n", d->code_number);
 693       puts ("     rtx *operands ATTRIBUTE_UNUSED;");
 694       puts ("     rtx insn ATTRIBUTE_UNUSED;");
 695       puts ("{");
 696
 697       puts (template + 1);
 698       puts ("}");
 699     }
 700
 701   /* If the assembler code template starts with a @ it is a newline-separated
 702      list of assembler code templates, one for each alternative.  */
 703   else if (template[0] == '@')
 704     {
 705       d->template = 0;
 706       d->output_format = INSN_OUTPUT_FORMAT_MULTI;
 707
 708       printf ("\nstatic const char * const output_%d[] = {\n", d->code_number);
 709
 710       for (i = 0, cp = &template[1]; *cp; )
 711         {
 712           while (ISSPACE (*cp))
 713             cp++;
 714
 715           printf ("  \"");
 716           while (!IS_VSPACE (*cp) && *cp != '\0')
 717             {
 718               putchar (*cp);
 719               cp++;
 720             }
 721
 722           printf ("\",\n");
 723           i++;
 724         }
 725       if (i == 1)
 726         message_with_line (d->lineno,
 727                            "'@' is redundant for output template with single alternative");
 728       if (i != d->n_alternatives)
 729         {
 730           message_with_line (d->lineno,
 731                              "wrong number of alternatives in the output template");
 732           have_error = 1;
 733         }
 734
 735       printf ("};\n");
 736     }
 737   else
 738     {
 739       d->template = template;
 740       d->output_format = INSN_OUTPUT_FORMAT_SINGLE;
 741     }
 742 }
 743 \f
 744 /* Check insn D for consistency in number of constraint alternatives.  */
 745
 746 static void
 747 validate_insn_alternatives (d)
 748      struct data *d;
 749 {
 750   int n = 0, start;
 751
 752   /* Make sure all the operands have the same number of alternatives
 753      in their constraints.  Let N be that number.  */
 754   for (start = 0; start < d->n_operands; start++)
 755     if (d->operand[start].n_alternatives > 0)
 756       {
 757         int len, i;
 758         const char *p;
 759         char c;
 760         int which_alternative = 0;
 761         int alternative_count_unsure = 0;
 762
 763         for (p = d->operand[start].constraint; (c = *p); p += len)
 764           {
 765             len = CONSTRAINT_LEN (c, p);
 766
 767             if (len < 1 || (len > 1 && strchr (",#*+=&%!0123456789", c)))
 768               {
 769                 message_with_line (d->lineno,
 770                                    "invalid length %d for char '%c' in alternative %d of operand %d",
 771                                     len, c, which_alternative, start);
 772                 len = 1;
 773                 have_error = 1;
 774               }
 775
 776             if (c == ',')
 777               {
 778                 which_alternative++;
 779                 continue;
 780               }
 781
 782             for (i = 1; i < len; i++)
 783               if (p[i] == '\0')
 784                 {
 785                   message_with_line (d->lineno,
 786                                      "NUL in alternative %d of operand %d",
 787                                      which_alternative, start);
 788                   alternative_count_unsure = 1;
 789                   break;
 790                 }
 791               else if (strchr (",#*", p[i]))
 792                 {
 793                   message_with_line (d->lineno,
 794                                      "'%c' in alternative %d of operand %d",
 795                                      p[i], which_alternative, start);
 796                   alternative_count_unsure = 1;
 797                 }
 798           }
 799         if (alternative_count_unsure)
 800           have_error = 1;
 801         else if (n == 0)
 802           n = d->operand[start].n_alternatives;
 803         else if (n != d->operand[start].n_alternatives)
 804           {
 805             message_with_line (d->lineno,
 806                                "wrong number of alternatives in operand %d",
 807                                start);
 808             have_error = 1;
 809           }
 810       }
 811
 812   /* Record the insn's overall number of alternatives.  */
 813   d->n_alternatives = n;
 814 }
 815
 816 /* Verify that there are no gaps in operand numbers for INSNs.  */
 817
 818 static void
 819 validate_insn_operands (d)
 820      struct data *d;
 821 {
 822   int i;
 823
 824   for (i = 0; i < d->n_operands; ++i)
 825     if (d->operand[i].seen == 0)
 826       {
 827         message_with_line (d->lineno, "missing operand %d", i);
 828         have_error = 1;
 829       }
 830 }
 831 \f
 832 /* Look at a define_insn just read.  Assign its code number.  Record
 833    on idata the template and the number of arguments.  If the insn has
 834    a hairy output action, output a function for now.  */
 835
 836 static void
 837 gen_insn (insn, lineno)
 838      rtx insn;
 839      int lineno;
 840 {
 841   struct data *d = (struct data *) xmalloc (sizeof (struct data));
 842   int i;
 843
 844   d->code_number = next_code_number;
 845   d->index_number = next_index_number;
 846   d->lineno = lineno;
 847   if (XSTR (insn, 0)[0])
 848     d->name = XSTR (insn, 0);
 849   else
 850     d->name = 0;
 851
 852   /* Build up the list in the same order as the insns are seen
 853      in the machine description.  */
 854   d->next = 0;
 855   *idata_end = d;
 856   idata_end = &d->next;
 857
 858   max_opno = -1;
 859   num_dups = 0;
 860   memset (d->operand, 0, sizeof (d->operand));
 861
 862   for (i = 0; i < XVECLEN (insn, 1); i++)
 863     scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
 864
 865   d->n_operands = max_opno + 1;
 866   d->n_dups = num_dups;
 867
 868   check_constraint_len ();
 869   validate_insn_operands (d);
 870   validate_insn_alternatives (d);
 871   place_operands (d);
 872   process_template (d, XTMPL (insn, 3));
 873 }
 874 \f
 875 /* Look at a define_peephole just read.  Assign its code number.
 876    Record on idata the template and the number of arguments.
 877    If the insn has a hairy output action, output it now.  */
 878
 879 static void
 880 gen_peephole (peep, lineno)
 881      rtx peep;
 882      int lineno;
 883 {
 884   struct data *d = (struct data *) xmalloc (sizeof (struct data));
 885   int i;
 886
 887   d->code_number = next_code_number;
 888   d->index_number = next_index_number;
 889   d->lineno = lineno;
 890   d->name = 0;
 891
 892   /* Build up the list in the same order as the insns are seen
 893      in the machine description.  */
 894   d->next = 0;
 895   *idata_end = d;
 896   idata_end = &d->next;
 897
 898   max_opno = -1;
 899   num_dups = 0;
 900   memset (d->operand, 0, sizeof (d->operand));
 901
 902   /* Get the number of operands by scanning all the patterns of the
 903      peephole optimizer.  But ignore all the rest of the information
 904      thus obtained.  */
 905   for (i = 0; i < XVECLEN (peep, 0); i++)
 906     scan_operands (d, XVECEXP (peep, 0, i), 0, 0);
 907
 908   d->n_operands = max_opno + 1;
 909   d->n_dups = 0;
 910
 911   validate_insn_alternatives (d);
 912   place_operands (d);
 913   process_template (d, XTMPL (peep, 2));
 914 }
 915 \f
 916 /* Process a define_expand just read.  Assign its code number,
 917    only for the purposes of `insn_gen_function'.  */
 918
 919 static void
 920 gen_expand (insn, lineno)
 921      rtx insn;
 922      int lineno;
 923 {
 924   struct data *d = (struct data *) xmalloc (sizeof (struct data));
 925   int i;
 926
 927   d->code_number = next_code_number;
 928   d->index_number = next_index_number;
 929   d->lineno = lineno;
 930   if (XSTR (insn, 0)[0])
 931     d->name = XSTR (insn, 0);
 932   else
 933     d->name = 0;
 934
 935   /* Build up the list in the same order as the insns are seen
 936      in the machine description.  */
 937   d->next = 0;
 938   *idata_end = d;
 939   idata_end = &d->next;
 940
 941   max_opno = -1;
 942   num_dups = 0;
 943   memset (d->operand, 0, sizeof (d->operand));
 944
 945   /* Scan the operands to get the specified predicates and modes,
 946      since expand_binop needs to know them.  */
 947
 948   if (XVEC (insn, 1))
 949     for (i = 0; i < XVECLEN (insn, 1); i++)
 950       scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
 951
 952   d->n_operands = max_opno + 1;
 953   d->n_dups = num_dups;
 954   d->template = 0;
 955   d->output_format = INSN_OUTPUT_FORMAT_NONE;
 956
 957   validate_insn_alternatives (d);
 958   place_operands (d);
 959 }
 960 \f
 961 /* Process a define_split just read.  Assign its code number,
 962    only for reasons of consistency and to simplify genrecog.  */
 963
 964 static void
 965 gen_split (split, lineno)
 966      rtx split;
 967      int lineno;
 968 {
 969   struct data *d = (struct data *) xmalloc (sizeof (struct data));
 970   int i;
 971
 972   d->code_number = next_code_number;
 973   d->index_number = next_index_number;
 974   d->lineno = lineno;
 975   d->name = 0;
 976
 977   /* Build up the list in the same order as the insns are seen
 978      in the machine description.  */
 979   d->next = 0;
 980   *idata_end = d;
 981   idata_end = &d->next;
 982
 983   max_opno = -1;
 984   num_dups = 0;
 985   memset (d->operand, 0, sizeof (d->operand));
 986
 987   /* Get the number of operands by scanning all the patterns of the
 988      split patterns.  But ignore all the rest of the information thus
 989      obtained.  */
 990   for (i = 0; i < XVECLEN (split, 0); i++)
 991     scan_operands (d, XVECEXP (split, 0, i), 0, 0);
 992
 993   d->n_operands = max_opno + 1;
 994   d->n_dups = 0;
 995   d->n_alternatives = 0;
 996   d->template = 0;
 997   d->output_format = INSN_OUTPUT_FORMAT_NONE;
 998
 999   place_operands (d);
1000 }
1001
1002 extern int main PARAMS ((int, char **));
1003
1004 int
1005 main (argc, argv)
1006      int argc;
1007      char **argv;
1008 {
1009   rtx desc;
1010
1011   progname = "genoutput";
1012
1013   if (argc <= 1)
1014     fatal ("no input file name");
1015
1016   if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
1017     return (FATAL_EXIT_CODE);
1018
1019   output_prologue ();
1020   next_code_number = 0;
1021   next_index_number = 0;
1022
1023   /* Read the machine description.  */
1024
1025   while (1)
1026     {
1027       int line_no;
1028
1029       desc = read_md_rtx (&line_no, &next_code_number);
1030       if (desc == NULL)
1031         break;
1032
1033       if (GET_CODE (desc) == DEFINE_INSN)
1034         gen_insn (desc, line_no);
1035       if (GET_CODE (desc) == DEFINE_PEEPHOLE)
1036         gen_peephole (desc, line_no);
1037       if (GET_CODE (desc) == DEFINE_EXPAND)
1038         gen_expand (desc, line_no);
1039       if (GET_CODE (desc) == DEFINE_SPLIT
1040           || GET_CODE (desc) == DEFINE_PEEPHOLE2)
1041         gen_split (desc, line_no);
1042       next_index_number++;
1043     }
1044
1045   printf("\n\n");
1046   output_predicate_decls ();
1047   output_operand_data ();
1048   output_insn_data ();
1049   output_get_insn_name ();
1050
1051   fflush (stdout);
1052   return (ferror (stdout) != 0 || have_error
1053         ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
1054 }
1055
1056 /* Return the number of occurrences of character C in string S or
1057    -1 if S is the null string.  */
1058
1059 static int
1060 n_occurrences (c, s)
1061      int c;
1062      const char *s;
1063 {
1064   int n = 0;
1065
1066   if (s == 0 || *s == '\0')
1067     return -1;
1068
1069   while (*s)
1070     n += (*s++ == c);
1071
1072   return n;
1073 }
1074
1075 /* Remove whitespace in `s' by moving up characters until the end.
1076    Return a new string.  */
1077
1078 static const char *
1079 strip_whitespace (s)
1080      const char *s;
1081 {
1082   char *p, *q;
1083   char ch;
1084
1085   if (s == 0)
1086     return 0;
1087
1088   p = q = xmalloc (strlen (s) + 1);
1089   while ((ch = *s++) != '\0')
1090     if (! ISSPACE (ch))
1091       *p++ = ch;
1092
1093   *p = '\0';
1094   return q;
1095 }
1096
1097 /* Verify that DEFAULT_CONSTRAINT_LEN is used properly and not
1098    tampered with.  This isn't bullet-proof, but it should catch
1099    most genuine mistakes.  */
1100 static void
1101 check_constraint_len ()
1102 {
1103   const char *p;
1104   int d;
1105
1106   for (p = ",#*+=&%!1234567890"; *p; p++)
1107     for (d = -9; d < 9; d++)
1108       if (constraint_len (p, d) != d)
1109         abort ();
1110 }
1111
1112 static int
1113 constraint_len (p, genoutput_default_constraint_len)
1114      const char *p;
1115      int genoutput_default_constraint_len;
1116 {
1117   /* Check that we still match defaults.h .  First we do a generation-time
1118      check that fails if the value is not the expected one...  */
1119   if (DEFAULT_CONSTRAINT_LEN (*p, p) != 1)
1120     abort ();
1121   /* And now a comile-time check that should give a diagnostic if the
1122      definition doesn't exactly match.  */
1123 #define DEFAULT_CONSTRAINT_LEN(C,STR) 1
1124   /* Now re-define DEFAULT_CONSTRAINT_LEN so that we can verify it is
1125      being used.  */
1126 #undef DEFAULT_CONSTRAINT_LEN
1127 #define DEFAULT_CONSTRAINT_LEN(C,STR) \
1128   ((C) != *p || STR != p ? -1 : genoutput_default_constraint_len)
1129   return CONSTRAINT_LEN (*p, p);
1130   /* And set it back.  */
1131 #undef DEFAULT_CONSTRAINT_LEN
1132 #define DEFAULT_CONSTRAINT_LEN(C,STR) 1
1133 }