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