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