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