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