gcc/genoutput.c

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