gcc/genoutput.c

   1 /* Generate code from to output assembler insns as recognized from rtl.
   2    Copyright (C) 1987, 88, 92, 94-95, 97-98, 1999
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 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 "hconfig.h"
  89 #include "system.h"
  90 #include "rtl.h"
  91 #include "obstack.h"
  92 #include "errors.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 struct obstack obstack;
 101 struct obstack *rtl_obstack = &obstack;
 102
 103 #define obstack_chunk_alloc xmalloc
 104 #define obstack_chunk_free free
 105
 106 static int n_occurrences PROTO((int, char *));
 107
 108 /* insns in the machine description are assigned sequential code numbers
 109    that are used by insn-recog.c (produced by genrecog) to communicate
 110    to insn-output.c (produced by this program).  */
 111
 112 static int next_code_number;
 113
 114 /* This counts all definitions in the md file,
 115    for the sake of error messages.  */
 116
 117 static int next_index_number;
 118
 119 /* This counts all operands used in the md file.  The first is null.  */
 120
 121 static int next_operand_number = 1;
 122
 123 /* Record in this chain all information about the operands we will output.  */
 124
 125 struct operand_data
 126 {
 127   struct operand_data *next;
 128   int index;
 129   const char *predicate;
 130   const char *constraint;
 131   enum machine_mode mode;
 132   unsigned char n_alternatives;
 133   char address_p;
 134   char strict_low;
 135   char eliminable;
 136   char seen;
 137 };
 138
 139 /* Begin with a null operand at index 0.  */
 140
 141 static struct operand_data null_operand =
 142 {
 143   0, 0, "", "", VOIDmode, 0, 0, 0, 0, 0
 144 };
 145
 146 static struct operand_data *odata = &null_operand;
 147 static struct operand_data **odata_end = &null_operand.next;
 148
 149 /* Must match the constants in recog.h.  */
 150
 151 #define INSN_OUTPUT_FORMAT_NONE         0       /* abort */
 152 #define INSN_OUTPUT_FORMAT_SINGLE       1       /* const char * */
 153 #define INSN_OUTPUT_FORMAT_MULTI        2       /* const char * const * */
 154 #define INSN_OUTPUT_FORMAT_FUNCTION     3       /* const char * (*)(...) */
 155
 156 /* Record in this chain all information that we will output,
 157    associated with the code number of the insn.  */
 158
 159 struct data
 160 {
 161   struct data *next;
 162   const char *name;
 163   const char *template;
 164   int code_number;
 165   int index_number;
 166   int n_operands;               /* Number of operands this insn recognizes */
 167   int n_dups;                   /* Number times match_dup appears in pattern */
 168   int n_alternatives;           /* Number of alternatives in each constraint */
 169   int operand_number;           /* Operand index in the big array.  */
 170   int output_format;            /* INSN_OUTPUT_FORMAT_*.  */
 171   struct operand_data operand[MAX_MAX_OPERANDS];
 172 };
 173
 174 /* This variable points to the first link in the insn chain.  */
 175
 176 static struct data *idata, **idata_end = &idata;
 177 \f
 178 static void output_prologue PROTO((void));
 179 static void output_predicate_decls PROTO((void));
 180 static void output_operand_data PROTO((void));
 181 static void output_insn_data PROTO((void));
 182 static void output_get_insn_name PROTO((void));
 183 static void scan_operands PROTO((struct data *, rtx, int, int));
 184 static int compare_operands PROTO((struct operand_data *,
 185                                    struct operand_data *));
 186 static void place_operands PROTO((struct data *));
 187 static void process_template PROTO((struct data *, char *));
 188 static void validate_insn_alternatives PROTO((struct data *));
 189 static void gen_insn PROTO((rtx));
 190 static void gen_peephole PROTO((rtx));
 191 static void gen_expand PROTO((rtx));
 192 static void gen_split PROTO((rtx));
 193 static int n_occurrences PROTO((int, char *));
 194 \f
 195 const char *
 196 get_insn_name (index)
 197      int index;
 198 {
 199   static char buf[100];
 200
 201   struct data *i, *last_named = NULL;
 202   for (i = idata; i ; i = i->next)
 203     {
 204       if (i->index_number == index)
 205         return i->name;
 206       if (i->name)
 207         last_named = i;
 208     }
 209
 210   if (last_named)
 211     sprintf(buf, "%s+%d", last_named->name, index - last_named->index_number);
 212   else
 213     sprintf(buf, "insn %d", index);
 214
 215   return buf;
 216 }
 217
 218 static void
 219 output_prologue ()
 220 {
 221   printf ("/* Generated automatically by the program `genoutput'\n\
 222 from the machine description file `md'.  */\n\n");
 223
 224   printf ("#define NO_MD_PROTOTYPES\n");
 225   printf ("#include \"config.h\"\n");
 226   printf ("#include \"system.h\"\n");
 227   printf ("#include \"flags.h\"\n");
 228   printf ("#include \"rtl.h\"\n");
 229   printf ("#include \"tm_p.h\"\n");
 230   printf ("#include \"function.h\"\n");
 231   printf ("#include \"regs.h\"\n");
 232   printf ("#include \"hard-reg-set.h\"\n");
 233   printf ("#include \"real.h\"\n");
 234   printf ("#include \"insn-config.h\"\n\n");
 235   printf ("#include \"conditions.h\"\n");
 236   printf ("#include \"insn-flags.h\"\n");
 237   printf ("#include \"insn-attr.h\"\n\n");
 238   printf ("#include \"insn-codes.h\"\n\n");
 239   printf ("#include \"recog.h\"\n\n");
 240   printf ("#include \"toplev.h\"\n");
 241   printf ("#include \"output.h\"\n");
 242 }
 243
 244
 245 /* We need to define all predicates used.  Keep a list of those we
 246    have defined so far.  There normally aren't very many predicates
 247    used, so a linked list should be fast enough.  */
 248
 249 static void
 250 output_predicate_decls ()
 251 {
 252   struct predicate { const char *name; struct predicate *next; } *predicates = 0;
 253   register struct operand_data *d;
 254   struct predicate *p;
 255
 256   for (d = odata; d; d = d->next)
 257     if (d->predicate && d->predicate[0])
 258       {
 259         for (p = predicates; p; p = p->next)
 260           if (strcmp (p->name, d->predicate) == 0)
 261             break;
 262
 263         if (p == 0)
 264           {
 265             printf ("extern int %s PROTO ((rtx, enum machine_mode));\n",
 266                     d->predicate);
 267             p = (struct predicate *) alloca (sizeof (struct predicate));
 268             p->name = d->predicate;
 269             p->next = predicates;
 270             predicates = p;
 271           }
 272       }
 273
 274   printf ("\n\n");
 275 }
 276
 277 static void
 278 output_operand_data ()
 279 {
 280   register struct operand_data *d;
 281
 282   printf ("\nstatic const struct insn_operand_data operand_data[] = \n{\n");
 283
 284   for (d = odata; d; d = d->next)
 285     {
 286       printf ("  {\n");
 287
 288       printf ("    %s,\n",
 289               d->predicate && d->predicate[0] ? d->predicate : "0");
 290
 291       printf ("    \"%s\",\n", d->constraint ? d->constraint : "");
 292
 293       printf ("    %smode,\n", GET_MODE_NAME (d->mode));
 294
 295       printf ("    %d,\n", d->strict_low);
 296
 297       printf ("    %d\n", d->eliminable);
 298
 299       printf("  },\n");
 300     }
 301   printf("};\n\n\n");
 302 }
 303
 304 static void
 305 output_insn_data ()
 306 {
 307   register struct data *d;
 308   int name_offset = 0;
 309   int next_name_offset;
 310   const char * last_name = 0;
 311   const char * next_name = 0;
 312   register struct data *n;
 313
 314   for (n = idata, next_name_offset = 1; n; n = n->next, next_name_offset++)
 315     if (n->name)
 316       {
 317         next_name = n->name;
 318         break;
 319       }
 320
 321   printf ("\nconst struct insn_data insn_data[] = \n{\n");
 322
 323   for (d = idata; d; d = d->next)
 324     {
 325       printf ("  {\n");
 326
 327       if (d->name)
 328         {
 329           printf ("    \"%s\",\n", d->name);
 330           name_offset = 0;
 331           last_name = d->name;
 332           next_name = 0;
 333           for (n = d->next, next_name_offset = 1; n;
 334                n = n->next, next_name_offset++)
 335             {
 336               if (n->name)
 337                 {
 338                   next_name = n->name;
 339                   break;
 340                 }
 341             }
 342         }
 343       else
 344         {
 345           name_offset++;
 346           if (next_name && (last_name == 0
 347                             || name_offset > next_name_offset / 2))
 348             printf ("    \"%s-%d\",\n", next_name,
 349                     next_name_offset - name_offset);
 350           else
 351             printf ("    \"%s+%d\",\n", last_name, name_offset);
 352         }
 353
 354       switch (d->output_format)
 355         {
 356         case INSN_OUTPUT_FORMAT_NONE:
 357           printf ("    0,\n");
 358           break;
 359         case INSN_OUTPUT_FORMAT_SINGLE:
 360           printf ("    \"%s\",\n", d->template);
 361           break;
 362         case INSN_OUTPUT_FORMAT_MULTI:
 363         case INSN_OUTPUT_FORMAT_FUNCTION:
 364           printf ("    (const PTR) output_%d,\n", d->code_number);
 365           break;
 366         default:
 367           abort ();
 368         }
 369
 370       if (d->name && d->name[0] != '*')
 371         printf ("    gen_%s,\n", d->name);
 372       else
 373         printf ("    0,\n");
 374
 375       printf ("    &operand_data[%d],\n", d->operand_number);
 376       printf ("    %d,\n", d->n_operands);
 377       printf ("    %d,\n", d->n_dups);
 378       printf ("    %d,\n", d->n_alternatives);
 379       printf ("    %d\n", d->output_format);
 380
 381       printf("  },\n");
 382     }
 383   printf ("};\n\n\n");
 384 }
 385
 386 static void
 387 output_get_insn_name ()
 388 {
 389   printf ("const char *\n");
 390   printf ("get_insn_name (code)\n");
 391   printf ("     int code;\n");
 392   printf ("{\n");
 393   printf ("  return insn_data[code].name;\n");
 394   printf ("}\n");
 395 }
 396
 397 \f
 398 /* Stores in max_opno the largest operand number present in `part', if
 399    that is larger than the previous value of max_opno, and the rest of
 400    the operand data into `d->operand[i]'.
 401
 402    THIS_ADDRESS_P is nonzero if the containing rtx was an ADDRESS.
 403    THIS_STRICT_LOW is nonzero if the containing rtx was a STRICT_LOW_PART.  */
 404
 405 static int max_opno;
 406 static int num_dups;
 407
 408 static void
 409 scan_operands (d, part, this_address_p, this_strict_low)
 410      struct data *d;
 411      rtx part;
 412      int this_address_p;
 413      int this_strict_low;
 414 {
 415   register int i, j;
 416   register const char *format_ptr;
 417   int opno;
 418
 419   if (part == 0)
 420     return;
 421
 422   switch (GET_CODE (part))
 423     {
 424     case MATCH_OPERAND:
 425       opno = XINT (part, 0);
 426       if (opno > max_opno)
 427         max_opno = opno;
 428       if (max_opno >= MAX_MAX_OPERANDS)
 429         {
 430           error ("Too many operands (%d) in definition %s.\n",
 431                  max_opno + 1, get_insn_name (next_index_number));
 432           return;
 433         }
 434       if (d->operand[opno].seen)
 435         error ("Definition %s specified operand number %d more than once.\n",
 436                get_insn_name (next_index_number), opno);
 437       d->operand[opno].seen = 1;
 438       d->operand[opno].mode = GET_MODE (part);
 439       d->operand[opno].strict_low = this_strict_low;
 440       d->operand[opno].predicate = XSTR (part, 1);
 441       d->operand[opno].constraint = XSTR (part, 2);
 442       if (XSTR (part, 2) != 0 && *XSTR (part, 2) != 0)
 443         d->operand[opno].n_alternatives
 444           = n_occurrences (',', XSTR (part, 2)) + 1;
 445       d->operand[opno].address_p = this_address_p;
 446       d->operand[opno].eliminable = 1;
 447       return;
 448
 449     case MATCH_SCRATCH:
 450       opno = XINT (part, 0);
 451       if (opno > max_opno)
 452         max_opno = opno;
 453       if (max_opno >= MAX_MAX_OPERANDS)
 454         {
 455           error ("Too many operands (%d) in definition %s.\n",
 456                  max_opno + 1, get_insn_name (next_index_number));
 457           return;
 458         }
 459       if (d->operand[opno].seen)
 460         error ("Definition %s specified operand number %d more than once.\n",
 461                get_insn_name (next_index_number), opno);
 462       d->operand[opno].seen = 1;
 463       d->operand[opno].mode = GET_MODE (part);
 464       d->operand[opno].strict_low = 0;
 465       d->operand[opno].predicate = "scratch_operand";
 466       d->operand[opno].constraint = XSTR (part, 1);
 467       if (XSTR (part, 1) != 0 && *XSTR (part, 1) != 0)
 468         d->operand[opno].n_alternatives
 469           = n_occurrences (',', XSTR (part, 1)) + 1;
 470       d->operand[opno].address_p = 0;
 471       d->operand[opno].eliminable = 0;
 472       return;
 473
 474     case MATCH_OPERATOR:
 475     case MATCH_PARALLEL:
 476       opno = XINT (part, 0);
 477       if (opno > max_opno)
 478         max_opno = opno;
 479       if (max_opno >= MAX_MAX_OPERANDS)
 480         {
 481           error ("Too many operands (%d) in definition %s.\n",
 482                  max_opno + 1, get_insn_name (next_index_number));
 483           return;
 484         }
 485       if (d->operand[opno].seen)
 486         error ("Definition %s specified operand number %d more than once.\n",
 487                get_insn_name (next_index_number), opno);
 488       d->operand[opno].seen = 1;
 489       d->operand[opno].mode = GET_MODE (part);
 490       d->operand[opno].strict_low = 0;
 491       d->operand[opno].predicate = XSTR (part, 1);
 492       d->operand[opno].constraint = 0;
 493       d->operand[opno].address_p = 0;
 494       d->operand[opno].eliminable = 0;
 495       for (i = 0; i < XVECLEN (part, 2); i++)
 496         scan_operands (d, XVECEXP (part, 2, i), 0, 0);
 497       return;
 498
 499     case MATCH_DUP:
 500     case MATCH_OP_DUP:
 501     case MATCH_PAR_DUP:
 502       ++num_dups;
 503       return;
 504
 505     case ADDRESS:
 506       scan_operands (d, XEXP (part, 0), 1, 0);
 507       return;
 508
 509     case STRICT_LOW_PART:
 510       scan_operands (d, XEXP (part, 0), 0, 1);
 511       return;
 512
 513     default:
 514       break;
 515     }
 516
 517   format_ptr = GET_RTX_FORMAT (GET_CODE (part));
 518
 519   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
 520     switch (*format_ptr++)
 521       {
 522       case 'e':
 523       case 'u':
 524         scan_operands (d, XEXP (part, i), 0, 0);
 525         break;
 526       case 'E':
 527         if (XVEC (part, i) != NULL)
 528           for (j = 0; j < XVECLEN (part, i); j++)
 529             scan_operands (d, XVECEXP (part, i, j), 0, 0);
 530         break;
 531       }
 532 }
 533
 534 /* Compare two operands for content equality.  */
 535
 536 static int
 537 compare_operands (d0, d1)
 538      struct operand_data *d0, *d1;
 539 {
 540   const char *p0, *p1;
 541
 542   p0 = d0->predicate;
 543   if (!p0)
 544     p0 = "";
 545   p1 = d1->predicate;
 546   if (!p1)
 547     p1 = "";
 548   if (strcmp (p0, p1) != 0)
 549     return 0;
 550
 551   p0 = d0->constraint;
 552   if (!p0)
 553     p0 = "";
 554   p1 = d1->constraint;
 555   if (!p1)
 556     p1 = "";
 557   if (strcmp (p0, p1) != 0)
 558     return 0;
 559
 560   if (d0->mode != d1->mode)
 561     return 0;
 562
 563   if (d0->strict_low != d1->strict_low)
 564     return 0;
 565
 566   if (d0->eliminable != d1->eliminable)
 567     return 0;
 568
 569   return 1;
 570 }
 571
 572 /* Scan the list of operands we've already committed to output and either
 573    find a subsequence that is the same, or allocate a new one at the end.  */
 574
 575 static void
 576 place_operands (d)
 577      struct data *d;
 578 {
 579   struct operand_data *od, *od2;
 580   int i;
 581
 582   if (d->n_operands == 0)
 583     {
 584       d->operand_number = 0;
 585       return;
 586     }
 587
 588   /* Brute force substring search.  */
 589   for (od = odata, i = 0; od; od = od->next, i = 0)
 590     if (compare_operands (od, &d->operand[0]))
 591       {
 592         od2 = od->next;
 593         i = 1;
 594         while (1)
 595           {
 596             if (i == d->n_operands)
 597               goto full_match;
 598             if (od2 == NULL)
 599               goto partial_match;
 600             if (! compare_operands (od2, &d->operand[i]))
 601               break;
 602             ++i, od2 = od2->next;
 603           }
 604       }
 605
 606   /* Either partial match at the end of the list, or no match.  In either
 607      case, we tack on what operands are remaining to the end of the list.  */
 608  partial_match:
 609   d->operand_number = next_operand_number - i;
 610   for (; i < d->n_operands; ++i)
 611     {
 612       od2 = &d->operand[i];
 613       *odata_end = od2;
 614       odata_end = &od2->next;
 615       od2->index = next_operand_number++;
 616     }
 617   *odata_end = NULL;
 618   return;
 619
 620  full_match:
 621   d->operand_number = od->index;
 622   return;
 623 }
 624
 625 \f
 626 /* Process an assembler template from a define_insn or a define_peephole.
 627    It is either the assembler code template, a list of assembler code
 628    templates, or C code to generate the assembler code template.  */
 629
 630 static void
 631 process_template (d, template)
 632     struct data *d;
 633     char *template;
 634 {
 635   register char *cp;
 636   register int i;
 637
 638   /* Templates starting with * contain straight code to be run.  */
 639   if (template[0] == '*')
 640     {
 641       d->template = 0;
 642       d->output_format = INSN_OUTPUT_FORMAT_FUNCTION;
 643
 644       printf ("\nstatic const char *output_%d PROTO ((rtx *, rtx));\n",
 645               d->code_number);
 646       puts ("\nstatic const char *");
 647       printf ("output_%d (operands, insn)\n", d->code_number);
 648       puts ("     rtx *operands ATTRIBUTE_UNUSED;");
 649       puts ("     rtx insn ATTRIBUTE_UNUSED;");
 650       puts ("{");
 651
 652       puts (template + 1);
 653       puts ("}");
 654     }
 655
 656   /* If the assembler code template starts with a @ it is a newline-separated
 657      list of assembler code templates, one for each alternative.  */
 658   else if (template[0] == '@')
 659     {
 660       d->template = 0;
 661       d->output_format = INSN_OUTPUT_FORMAT_MULTI;
 662
 663       printf ("\nstatic const char * const output_%d[] = {\n", d->code_number);
 664
 665       for (i = 0, cp = &template[1]; *cp; )
 666         {
 667           while (*cp == '\n' || *cp == ' ' || *cp== '\t')
 668             cp++;
 669
 670           printf ("  \"");
 671           while (*cp != '\n' && *cp != '\0')
 672             {
 673               putchar (*cp);
 674               cp++;
 675             }
 676
 677           printf ("\",\n");
 678           i++;
 679         }
 680
 681       printf ("};\n");
 682     }
 683   else
 684     {
 685       d->template = template;
 686       d->output_format = INSN_OUTPUT_FORMAT_SINGLE;
 687     }
 688 }
 689 \f
 690 /* Check insn D for consistency in number of constraint alternatives.  */
 691
 692 static void
 693 validate_insn_alternatives (d)
 694      struct data *d;
 695 {
 696   register int n = 0, start;
 697
 698   /* Make sure all the operands have the same number of alternatives
 699      in their constraints.  Let N be that number.  */
 700   for (start = 0; start < d->n_operands; start++)
 701     if (d->operand[start].n_alternatives > 0)
 702       {
 703         if (n == 0)
 704           n = d->operand[start].n_alternatives;
 705         else if (n != d->operand[start].n_alternatives)
 706           error ("wrong number of alternatives in operand %d of insn %s",
 707                  start, get_insn_name (d->index_number));
 708       }
 709
 710   /* Record the insn's overall number of alternatives.  */
 711   d->n_alternatives = n;
 712 }
 713 \f
 714 /* Look at a define_insn just read.  Assign its code number.  Record
 715    on idata the template and the number of arguments.  If the insn has
 716    a hairy output action, output a function for now.  */
 717
 718 static void
 719 gen_insn (insn)
 720      rtx insn;
 721 {
 722   register struct data *d = (struct data *) xmalloc (sizeof (struct data));
 723   register int i;
 724
 725   d->code_number = next_code_number++;
 726   d->index_number = next_index_number;
 727   if (XSTR (insn, 0)[0])
 728     d->name = XSTR (insn, 0);
 729   else
 730     d->name = 0;
 731
 732   /* Build up the list in the same order as the insns are seen
 733      in the machine description.  */
 734   d->next = 0;
 735   *idata_end = d;
 736   idata_end = &d->next;
 737
 738   max_opno = -1;
 739   num_dups = 0;
 740   memset (d->operand, 0, sizeof (d->operand));
 741
 742   for (i = 0; i < XVECLEN (insn, 1); i++)
 743     scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
 744
 745   d->n_operands = max_opno + 1;
 746   d->n_dups = num_dups;
 747
 748   validate_insn_alternatives (d);
 749   place_operands (d);
 750   process_template (d, XSTR (insn, 3));
 751 }
 752 \f
 753 /* Look at a define_peephole just read.  Assign its code number.
 754    Record on idata the template and the number of arguments.
 755    If the insn has a hairy output action, output it now.  */
 756
 757 static void
 758 gen_peephole (peep)
 759      rtx peep;
 760 {
 761   register struct data *d = (struct data *) xmalloc (sizeof (struct data));
 762   register int i;
 763
 764   d->code_number = next_code_number++;
 765   d->index_number = next_index_number;
 766   d->name = 0;
 767
 768   /* Build up the list in the same order as the insns are seen
 769      in the machine description.  */
 770   d->next = 0;
 771   *idata_end = d;
 772   idata_end = &d->next;
 773
 774   max_opno = -1;
 775   num_dups = 0;
 776   memset (d->operand, 0, sizeof (d->operand));
 777
 778   /* Get the number of operands by scanning all the patterns of the
 779      peephole optimizer.  But ignore all the rest of the information
 780      thus obtained.  */
 781   for (i = 0; i < XVECLEN (peep, 0); i++)
 782     scan_operands (d, XVECEXP (peep, 0, i), 0, 0);
 783
 784   d->n_operands = max_opno + 1;
 785   d->n_dups = 0;
 786
 787   validate_insn_alternatives (d);
 788   place_operands (d);
 789   process_template (d, XSTR (peep, 2));
 790 }
 791 \f
 792 /* Process a define_expand just read.  Assign its code number,
 793    only for the purposes of `insn_gen_function'.  */
 794
 795 static void
 796 gen_expand (insn)
 797      rtx insn;
 798 {
 799   register struct data *d = (struct data *) xmalloc (sizeof (struct data));
 800   register int i;
 801
 802   d->code_number = next_code_number++;
 803   d->index_number = next_index_number;
 804   if (XSTR (insn, 0)[0])
 805     d->name = XSTR (insn, 0);
 806   else
 807     d->name = 0;
 808
 809   /* Build up the list in the same order as the insns are seen
 810      in the machine description.  */
 811   d->next = 0;
 812   *idata_end = d;
 813   idata_end = &d->next;
 814
 815   max_opno = -1;
 816   num_dups = 0;
 817   memset (d->operand, 0, sizeof (d->operand));
 818
 819   /* Scan the operands to get the specified predicates and modes,
 820      since expand_binop needs to know them.  */
 821
 822   if (XVEC (insn, 1))
 823     for (i = 0; i < XVECLEN (insn, 1); i++)
 824       scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
 825
 826   d->n_operands = max_opno + 1;
 827   d->n_dups = num_dups;
 828   d->template = 0;
 829   d->output_format = INSN_OUTPUT_FORMAT_NONE;
 830
 831   validate_insn_alternatives (d);
 832   place_operands (d);
 833 }
 834 \f
 835 /* Process a define_split just read.  Assign its code number,
 836    only for reasons of consistency and to simplify genrecog.  */
 837
 838 static void
 839 gen_split (split)
 840      rtx split;
 841 {
 842   register struct data *d = (struct data *) xmalloc (sizeof (struct data));
 843   register int i;
 844
 845   d->code_number = next_code_number++;
 846   d->index_number = next_index_number;
 847   d->name = 0;
 848
 849   /* Build up the list in the same order as the insns are seen
 850      in the machine description.  */
 851   d->next = 0;
 852   *idata_end = d;
 853   idata_end = &d->next;
 854
 855   max_opno = -1;
 856   num_dups = 0;
 857   memset (d->operand, 0, sizeof (d->operand));
 858
 859   /* Get the number of operands by scanning all the patterns of the
 860      split patterns.  But ignore all the rest of the information thus
 861      obtained.  */
 862   for (i = 0; i < XVECLEN (split, 0); i++)
 863     scan_operands (d, XVECEXP (split, 0, i), 0, 0);
 864
 865   d->n_operands = max_opno + 1;
 866   d->n_dups = 0;
 867   d->n_alternatives = 0;
 868   d->template = 0;
 869   d->output_format = INSN_OUTPUT_FORMAT_NONE;
 870
 871   place_operands (d);
 872 }
 873 \f
 874 PTR
 875 xmalloc (size)
 876   size_t size;
 877 {
 878   register PTR val = (PTR) malloc (size);
 879
 880   if (val == 0)
 881     fatal ("virtual memory exhausted");
 882   return val;
 883 }
 884
 885 PTR
 886 xrealloc (old, size)
 887   PTR old;
 888   size_t size;
 889 {
 890   register PTR ptr;
 891   if (old)
 892     ptr = (PTR) realloc (old, size);
 893   else
 894     ptr = (PTR) malloc (size);
 895   if (!ptr)
 896     fatal ("virtual memory exhausted");
 897   return ptr;
 898 }
 899
 900 extern int main PROTO ((int, char **));
 901
 902 int
 903 main (argc, argv)
 904      int argc;
 905      char **argv;
 906 {
 907   rtx desc;
 908   FILE *infile;
 909   register int c;
 910
 911   progname = "genoutput";
 912   obstack_init (rtl_obstack);
 913
 914   if (argc <= 1)
 915     fatal ("No input file name.");
 916
 917   infile = fopen (argv[1], "r");
 918   if (infile == 0)
 919     {
 920       perror (argv[1]);
 921       return (FATAL_EXIT_CODE);
 922     }
 923   read_rtx_filename = argv[1];
 924
 925   output_prologue ();
 926   next_code_number = 0;
 927   next_index_number = 0;
 928
 929   /* Read the machine description.  */
 930
 931   while (1)
 932     {
 933       c = read_skip_spaces (infile);
 934       if (c == EOF)
 935         break;
 936       ungetc (c, infile);
 937
 938       desc = read_rtx (infile);
 939       if (GET_CODE (desc) == DEFINE_INSN)
 940         gen_insn (desc);
 941       if (GET_CODE (desc) == DEFINE_PEEPHOLE)
 942         gen_peephole (desc);
 943       if (GET_CODE (desc) == DEFINE_EXPAND)
 944         gen_expand (desc);
 945       if (GET_CODE (desc) == DEFINE_SPLIT
 946           || GET_CODE (desc) == DEFINE_PEEPHOLE2)
 947         gen_split (desc);
 948       next_index_number++;
 949     }
 950
 951   printf("\n\n");
 952   output_predicate_decls ();
 953   output_operand_data ();
 954   output_insn_data ();
 955   output_get_insn_name ();
 956
 957   fflush (stdout);
 958   return (ferror (stdout) != 0 || have_error
 959         ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 960 }
 961
 962 static int
 963 n_occurrences (c, s)
 964      int c;
 965      char *s;
 966 {
 967   int n = 0;
 968   while (*s)
 969     n += (*s++ == c);
 970   return n;
 971 }