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