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