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