gcc/gensupport.c

   1 /* Support routines for the various generation passes.
   2    Copyright (C) 2000, 2001, 2002, 2003
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it
   8    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    GCC is distributed in the hope that it will be useful, but WITHOUT
  13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15    License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GCC; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22 #include "bconfig.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "rtl.h"
  27 #include "obstack.h"
  28 #include "errors.h"
  29 #include "hashtab.h"
  30 #include "gensupport.h"
  31
  32
  33 /* In case some macros used by files we include need it, define this here.  */
  34 int target_flags;
  35
  36 int insn_elision = 1;
  37
  38 static struct obstack obstack;
  39 struct obstack *rtl_obstack = &obstack;
  40
  41 static int sequence_num;
  42 static int errors;
  43
  44 static int predicable_default;
  45 static const char *predicable_true;
  46 static const char *predicable_false;
  47
  48 static htab_t condition_table;
  49
  50 static char *base_dir = NULL;
  51
  52 /* We initially queue all patterns, process the define_insn and
  53    define_cond_exec patterns, then return them one at a time.  */
  54
  55 struct queue_elem
  56 {
  57   rtx data;
  58   const char *filename;
  59   int lineno;
  60   struct queue_elem *next;
  61 };
  62
  63 static struct queue_elem *define_attr_queue;
  64 static struct queue_elem **define_attr_tail = &define_attr_queue;
  65 static struct queue_elem *define_insn_queue;
  66 static struct queue_elem **define_insn_tail = &define_insn_queue;
  67 static struct queue_elem *define_cond_exec_queue;
  68 static struct queue_elem **define_cond_exec_tail = &define_cond_exec_queue;
  69 static struct queue_elem *other_queue;
  70 static struct queue_elem **other_tail = &other_queue;
  71
  72 static void queue_pattern (rtx, struct queue_elem ***,
  73                            const char *, int);
  74
  75 /* Current maximum length of directory names in the search path
  76    for include files.  (Altered as we get more of them.)  */
  77
  78 size_t max_include_len;
  79
  80 struct file_name_list
  81   {
  82     struct file_name_list *next;
  83     const char *fname;
  84   };
  85
  86 struct file_name_list *first_dir_md_include = 0;  /* First dir to search */
  87         /* First dir to search for <file> */
  88 struct file_name_list *first_bracket_include = 0;
  89 struct file_name_list *last_dir_md_include = 0;        /* Last in chain */
  90
  91 static void remove_constraints (rtx);
  92 static void process_rtx (rtx, int);
  93
  94 static int is_predicable (struct queue_elem *);
  95 static void identify_predicable_attribute (void);
  96 static int n_alternatives (const char *);
  97 static void collect_insn_data (rtx, int *, int *);
  98 static rtx alter_predicate_for_insn (rtx, int, int, int);
  99 static const char *alter_test_for_insn (struct queue_elem *,
 100                                         struct queue_elem *);
 101 static char *shift_output_template (char *, const char *, int);
 102 static const char *alter_output_for_insn (struct queue_elem *,
 103                                           struct queue_elem *,
 104                                           int, int);
 105 static void process_one_cond_exec (struct queue_elem *);
 106 static void process_define_cond_exec (void);
 107 static void process_include (rtx, int);
 108 static char *save_string (const char *, int);
 109 \f
 110 void
 111 message_with_line (int lineno, const char *msg, ...)
 112 {
 113   va_list ap;
 114
 115   va_start (ap, msg);
 116
 117   fprintf (stderr, "%s:%d: ", read_rtx_filename, lineno);
 118   vfprintf (stderr, msg, ap);
 119   fputc ('\n', stderr);
 120
 121   va_end (ap);
 122 }
 123
 124 /* Make a version of gen_rtx_CONST_INT so that GEN_INT can be used in
 125    the gensupport programs.  */
 126
 127 rtx
 128 gen_rtx_CONST_INT (enum machine_mode mode ATTRIBUTE_UNUSED,
 129                    HOST_WIDE_INT arg)
 130 {
 131   rtx rt = rtx_alloc (CONST_INT);
 132
 133   XWINT (rt, 0) = arg;
 134   return rt;
 135 }
 136 \f
 137 /* Queue PATTERN on LIST_TAIL.  */
 138
 139 static void
 140 queue_pattern (rtx pattern, struct queue_elem ***list_tail,
 141                const char *filename, int lineno)
 142 {
 143   struct queue_elem *e = (struct queue_elem *) xmalloc (sizeof (*e));
 144   e->data = pattern;
 145   e->filename = filename;
 146   e->lineno = lineno;
 147   e->next = NULL;
 148   **list_tail = e;
 149   *list_tail = &e->next;
 150 }
 151
 152 /* Recursively remove constraints from an rtx.  */
 153
 154 static void
 155 remove_constraints (rtx part)
 156 {
 157   int i, j;
 158   const char *format_ptr;
 159
 160   if (part == 0)
 161     return;
 162
 163   if (GET_CODE (part) == MATCH_OPERAND)
 164     XSTR (part, 2) = "";
 165   else if (GET_CODE (part) == MATCH_SCRATCH)
 166     XSTR (part, 1) = "";
 167
 168   format_ptr = GET_RTX_FORMAT (GET_CODE (part));
 169
 170   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
 171     switch (*format_ptr++)
 172       {
 173       case 'e':
 174       case 'u':
 175         remove_constraints (XEXP (part, i));
 176         break;
 177       case 'E':
 178         if (XVEC (part, i) != NULL)
 179           for (j = 0; j < XVECLEN (part, i); j++)
 180             remove_constraints (XVECEXP (part, i, j));
 181         break;
 182       }
 183 }
 184
 185 /* Process an include file assuming that it lives in gcc/config/{target}/
 186    if the include looks like (include "file").  */
 187
 188 static void
 189 process_include (rtx desc, int lineno)
 190 {
 191   const char *filename = XSTR (desc, 0);
 192   const char *old_filename;
 193   int old_lineno;
 194   char *pathname;
 195   FILE *input_file;
 196
 197   /* If specified file name is absolute, skip the include stack.  */
 198   if (! IS_ABSOLUTE_PATHNAME (filename))
 199     {
 200       struct file_name_list *stackp;
 201
 202       /* Search directory path, trying to open the file.  */
 203       for (stackp = first_dir_md_include; stackp; stackp = stackp->next)
 204         {
 205           static const char sep[2] = { DIR_SEPARATOR, '\0' };
 206
 207           pathname = concat (stackp->fname, sep, filename, NULL);
 208           input_file = fopen (pathname, "r");
 209           if (input_file != NULL)
 210             goto success;
 211           free (pathname);
 212         }
 213     }
 214
 215   if (base_dir)
 216     pathname = concat (base_dir, filename, NULL);
 217   else
 218     pathname = xstrdup (filename);
 219   input_file = fopen (pathname, "r");
 220   if (input_file == NULL)
 221     {
 222       free (pathname);
 223       message_with_line (lineno, "include file `%s' not found", filename);
 224       errors = 1;
 225       return;
 226     }
 227  success:
 228
 229   /* Save old cursor; setup new for the new file.  Note that "lineno" the
 230      argument to this function is the beginning of the include statement,
 231      while read_rtx_lineno has already been advanced.  */
 232   old_filename = read_rtx_filename;
 233   old_lineno = read_rtx_lineno;
 234   read_rtx_filename = pathname;
 235   read_rtx_lineno = 1;
 236
 237   /* Read the entire file.  */
 238   while (1)
 239     {
 240       rtx desc;
 241       int c;
 242
 243       c = read_skip_spaces (input_file);
 244       if (c == EOF)
 245         break;
 246
 247       ungetc (c, input_file);
 248       lineno = read_rtx_lineno;
 249       desc = read_rtx (input_file);
 250       process_rtx (desc, lineno);
 251     }
 252
 253   /* Do not free pathname.  It is attached to the various rtx queue
 254      elements.  */
 255
 256   read_rtx_filename = old_filename;
 257   read_rtx_lineno = old_lineno;
 258
 259   fclose (input_file);
 260 }
 261
 262 /* Process a top level rtx in some way, queueing as appropriate.  */
 263
 264 static void
 265 process_rtx (rtx desc, int lineno)
 266 {
 267   switch (GET_CODE (desc))
 268     {
 269     case DEFINE_INSN:
 270       queue_pattern (desc, &define_insn_tail, read_rtx_filename, lineno);
 271       break;
 272
 273     case DEFINE_COND_EXEC:
 274       queue_pattern (desc, &define_cond_exec_tail, read_rtx_filename, lineno);
 275       break;
 276
 277     case DEFINE_ATTR:
 278       queue_pattern (desc, &define_attr_tail, read_rtx_filename, lineno);
 279       break;
 280
 281     case INCLUDE:
 282       process_include (desc, lineno);
 283       break;
 284
 285     case DEFINE_INSN_AND_SPLIT:
 286       {
 287         const char *split_cond;
 288         rtx split;
 289         rtvec attr;
 290         int i;
 291
 292         /* Create a split with values from the insn_and_split.  */
 293         split = rtx_alloc (DEFINE_SPLIT);
 294
 295         i = XVECLEN (desc, 1);
 296         XVEC (split, 0) = rtvec_alloc (i);
 297         while (--i >= 0)
 298           {
 299             XVECEXP (split, 0, i) = copy_rtx (XVECEXP (desc, 1, i));
 300             remove_constraints (XVECEXP (split, 0, i));
 301           }
 302
 303         /* If the split condition starts with "&&", append it to the
 304            insn condition to create the new split condition.  */
 305         split_cond = XSTR (desc, 4);
 306         if (split_cond[0] == '&' && split_cond[1] == '&')
 307           split_cond = concat (XSTR (desc, 2), split_cond, NULL);
 308         XSTR (split, 1) = split_cond;
 309         XVEC (split, 2) = XVEC (desc, 5);
 310         XSTR (split, 3) = XSTR (desc, 6);
 311
 312         /* Fix up the DEFINE_INSN.  */
 313         attr = XVEC (desc, 7);
 314         PUT_CODE (desc, DEFINE_INSN);
 315         XVEC (desc, 4) = attr;
 316
 317         /* Queue them.  */
 318         queue_pattern (desc, &define_insn_tail, read_rtx_filename, lineno);
 319         queue_pattern (split, &other_tail, read_rtx_filename, lineno);
 320         break;
 321       }
 322
 323     default:
 324       queue_pattern (desc, &other_tail, read_rtx_filename, lineno);
 325       break;
 326     }
 327 }
 328 \f
 329 /* Return true if attribute PREDICABLE is true for ELEM, which holds
 330    a DEFINE_INSN.  */
 331
 332 static int
 333 is_predicable (struct queue_elem *elem)
 334 {
 335   rtvec vec = XVEC (elem->data, 4);
 336   const char *value;
 337   int i;
 338
 339   if (! vec)
 340     return predicable_default;
 341
 342   for (i = GET_NUM_ELEM (vec) - 1; i >= 0; --i)
 343     {
 344       rtx sub = RTVEC_ELT (vec, i);
 345       switch (GET_CODE (sub))
 346         {
 347         case SET_ATTR:
 348           if (strcmp (XSTR (sub, 0), "predicable") == 0)
 349             {
 350               value = XSTR (sub, 1);
 351               goto found;
 352             }
 353           break;
 354
 355         case SET_ATTR_ALTERNATIVE:
 356           if (strcmp (XSTR (sub, 0), "predicable") == 0)
 357             {
 358               message_with_line (elem->lineno,
 359                                  "multiple alternatives for `predicable'");
 360               errors = 1;
 361               return 0;
 362             }
 363           break;
 364
 365         case SET:
 366           if (GET_CODE (SET_DEST (sub)) != ATTR
 367               || strcmp (XSTR (SET_DEST (sub), 0), "predicable") != 0)
 368             break;
 369           sub = SET_SRC (sub);
 370           if (GET_CODE (sub) == CONST_STRING)
 371             {
 372               value = XSTR (sub, 0);
 373               goto found;
 374             }
 375
 376           /* ??? It would be possible to handle this if we really tried.
 377              It's not easy though, and I'm not going to bother until it
 378              really proves necessary.  */
 379           message_with_line (elem->lineno,
 380                              "non-constant value for `predicable'");
 381           errors = 1;
 382           return 0;
 383
 384         default:
 385           abort ();
 386         }
 387     }
 388
 389   return predicable_default;
 390
 391  found:
 392   /* Verify that predicability does not vary on the alternative.  */
 393   /* ??? It should be possible to handle this by simply eliminating
 394      the non-predicable alternatives from the insn.  FRV would like
 395      to do this.  Delay this until we've got the basics solid.  */
 396   if (strchr (value, ',') != NULL)
 397     {
 398       message_with_line (elem->lineno,
 399                          "multiple alternatives for `predicable'");
 400       errors = 1;
 401       return 0;
 402     }
 403
 404   /* Find out which value we're looking at.  */
 405   if (strcmp (value, predicable_true) == 0)
 406     return 1;
 407   if (strcmp (value, predicable_false) == 0)
 408     return 0;
 409
 410   message_with_line (elem->lineno,
 411                      "unknown value `%s' for `predicable' attribute",
 412                      value);
 413   errors = 1;
 414   return 0;
 415 }
 416
 417 /* Examine the attribute "predicable"; discover its boolean values
 418    and its default.  */
 419
 420 static void
 421 identify_predicable_attribute (void)
 422 {
 423   struct queue_elem *elem;
 424   char *p_true, *p_false;
 425   const char *value;
 426
 427   /* Look for the DEFINE_ATTR for `predicable', which must exist.  */
 428   for (elem = define_attr_queue; elem ; elem = elem->next)
 429     if (strcmp (XSTR (elem->data, 0), "predicable") == 0)
 430       goto found;
 431
 432   message_with_line (define_cond_exec_queue->lineno,
 433                      "attribute `predicable' not defined");
 434   errors = 1;
 435   return;
 436
 437  found:
 438   value = XSTR (elem->data, 1);
 439   p_false = xstrdup (value);
 440   p_true = strchr (p_false, ',');
 441   if (p_true == NULL || strchr (++p_true, ',') != NULL)
 442     {
 443       message_with_line (elem->lineno,
 444                          "attribute `predicable' is not a boolean");
 445       errors = 1;
 446       return;
 447     }
 448   p_true[-1] = '\0';
 449
 450   predicable_true = p_true;
 451   predicable_false = p_false;
 452
 453   switch (GET_CODE (XEXP (elem->data, 2)))
 454     {
 455     case CONST_STRING:
 456       value = XSTR (XEXP (elem->data, 2), 0);
 457       break;
 458
 459     case CONST:
 460       message_with_line (elem->lineno,
 461                          "attribute `predicable' cannot be const");
 462       errors = 1;
 463       return;
 464
 465     default:
 466       message_with_line (elem->lineno,
 467                          "attribute `predicable' must have a constant default");
 468       errors = 1;
 469       return;
 470     }
 471
 472   if (strcmp (value, p_true) == 0)
 473     predicable_default = 1;
 474   else if (strcmp (value, p_false) == 0)
 475     predicable_default = 0;
 476   else
 477     {
 478       message_with_line (elem->lineno,
 479                          "unknown value `%s' for `predicable' attribute",
 480                          value);
 481       errors = 1;
 482     }
 483 }
 484
 485 /* Return the number of alternatives in constraint S.  */
 486
 487 static int
 488 n_alternatives (const char *s)
 489 {
 490   int n = 1;
 491
 492   if (s)
 493     while (*s)
 494       n += (*s++ == ',');
 495
 496   return n;
 497 }
 498
 499 /* Determine how many alternatives there are in INSN, and how many
 500    operands.  */
 501
 502 static void
 503 collect_insn_data (rtx pattern, int *palt, int *pmax)
 504 {
 505   const char *fmt;
 506   enum rtx_code code;
 507   int i, j, len;
 508
 509   code = GET_CODE (pattern);
 510   switch (code)
 511     {
 512     case MATCH_OPERAND:
 513       i = n_alternatives (XSTR (pattern, 2));
 514       *palt = (i > *palt ? i : *palt);
 515       /* FALLTHRU */
 516
 517     case MATCH_OPERATOR:
 518     case MATCH_SCRATCH:
 519     case MATCH_PARALLEL:
 520     case MATCH_INSN:
 521       i = XINT (pattern, 0);
 522       if (i > *pmax)
 523         *pmax = i;
 524       break;
 525
 526     default:
 527       break;
 528     }
 529
 530   fmt = GET_RTX_FORMAT (code);
 531   len = GET_RTX_LENGTH (code);
 532   for (i = 0; i < len; i++)
 533     {
 534       switch (fmt[i])
 535         {
 536         case 'e': case 'u':
 537           collect_insn_data (XEXP (pattern, i), palt, pmax);
 538           break;
 539
 540         case 'V':
 541           if (XVEC (pattern, i) == NULL)
 542             break;
 543           /* FALLTHRU */
 544         case 'E':
 545           for (j = XVECLEN (pattern, i) - 1; j >= 0; --j)
 546             collect_insn_data (XVECEXP (pattern, i, j), palt, pmax);
 547           break;
 548
 549         case 'i': case 'w': case '0': case 's': case 'S': case 'T':
 550           break;
 551
 552         default:
 553           abort ();
 554         }
 555     }
 556 }
 557
 558 static rtx
 559 alter_predicate_for_insn (rtx pattern, int alt, int max_op, int lineno)
 560 {
 561   const char *fmt;
 562   enum rtx_code code;
 563   int i, j, len;
 564
 565   code = GET_CODE (pattern);
 566   switch (code)
 567     {
 568     case MATCH_OPERAND:
 569       {
 570         const char *c = XSTR (pattern, 2);
 571
 572         if (n_alternatives (c) != 1)
 573           {
 574             message_with_line (lineno,
 575                                "too many alternatives for operand %d",
 576                                XINT (pattern, 0));
 577             errors = 1;
 578             return NULL;
 579           }
 580
 581         /* Replicate C as needed to fill out ALT alternatives.  */
 582         if (c && *c && alt > 1)
 583           {
 584             size_t c_len = strlen (c);
 585             size_t len = alt * (c_len + 1);
 586             char *new_c = (char *) xmalloc (len);
 587
 588             memcpy (new_c, c, c_len);
 589             for (i = 1; i < alt; ++i)
 590               {
 591                 new_c[i * (c_len + 1) - 1] = ',';
 592                 memcpy (&new_c[i * (c_len + 1)], c, c_len);
 593               }
 594             new_c[len - 1] = '\0';
 595             XSTR (pattern, 2) = new_c;
 596           }
 597       }
 598       /* FALLTHRU */
 599
 600     case MATCH_OPERATOR:
 601     case MATCH_SCRATCH:
 602     case MATCH_PARALLEL:
 603     case MATCH_INSN:
 604       XINT (pattern, 0) += max_op;
 605       break;
 606
 607     default:
 608       break;
 609     }
 610
 611   fmt = GET_RTX_FORMAT (code);
 612   len = GET_RTX_LENGTH (code);
 613   for (i = 0; i < len; i++)
 614     {
 615       rtx r;
 616
 617       switch (fmt[i])
 618         {
 619         case 'e': case 'u':
 620           r = alter_predicate_for_insn (XEXP (pattern, i), alt,
 621                                         max_op, lineno);
 622           if (r == NULL)
 623             return r;
 624           break;
 625
 626         case 'E':
 627           for (j = XVECLEN (pattern, i) - 1; j >= 0; --j)
 628             {
 629               r = alter_predicate_for_insn (XVECEXP (pattern, i, j),
 630                                             alt, max_op, lineno);
 631               if (r == NULL)
 632                 return r;
 633             }
 634           break;
 635
 636         case 'i': case 'w': case '0': case 's':
 637           break;
 638
 639         default:
 640           abort ();
 641         }
 642     }
 643
 644   return pattern;
 645 }
 646
 647 static const char *
 648 alter_test_for_insn (struct queue_elem *ce_elem,
 649                      struct queue_elem *insn_elem)
 650 {
 651   const char *ce_test, *insn_test;
 652
 653   ce_test = XSTR (ce_elem->data, 1);
 654   insn_test = XSTR (insn_elem->data, 2);
 655   if (!ce_test || *ce_test == '\0')
 656     return insn_test;
 657   if (!insn_test || *insn_test == '\0')
 658     return ce_test;
 659
 660   return concat ("(", ce_test, ") && (", insn_test, ")", NULL);
 661 }
 662
 663 /* Adjust all of the operand numbers in OLD to match the shift they'll
 664    get from an operand displacement of DISP.  Return a pointer after the
 665    adjusted string.  */
 666
 667 static char *
 668 shift_output_template (char *new, const char *old, int disp)
 669 {
 670   while (*old)
 671     {
 672       char c = *old++;
 673       *new++ = c;
 674       if (c == '%')
 675         {
 676           c = *old++;
 677           if (ISDIGIT ((unsigned char) c))
 678             c += disp;
 679           else if (ISALPHA (c))
 680             {
 681               *new++ = c;
 682               c = *old++ + disp;
 683             }
 684           *new++ = c;
 685         }
 686     }
 687
 688   return new;
 689 }
 690
 691 static const char *
 692 alter_output_for_insn (struct queue_elem *ce_elem,
 693                        struct queue_elem *insn_elem,
 694                        int alt, int max_op)
 695 {
 696   const char *ce_out, *insn_out;
 697   char *new, *p;
 698   size_t len, ce_len, insn_len;
 699
 700   /* ??? Could coordinate with genoutput to not duplicate code here.  */
 701
 702   ce_out = XSTR (ce_elem->data, 2);
 703   insn_out = XTMPL (insn_elem->data, 3);
 704   if (!ce_out || *ce_out == '\0')
 705     return insn_out;
 706
 707   ce_len = strlen (ce_out);
 708   insn_len = strlen (insn_out);
 709
 710   if (*insn_out == '*')
 711     /* You must take care of the predicate yourself.  */
 712     return insn_out;
 713
 714   if (*insn_out == '@')
 715     {
 716       len = (ce_len + 1) * alt + insn_len + 1;
 717       p = new = xmalloc (len);
 718
 719       do
 720         {
 721           do
 722             *p++ = *insn_out++;
 723           while (ISSPACE ((unsigned char) *insn_out));
 724
 725           if (*insn_out != '#')
 726             {
 727               p = shift_output_template (p, ce_out, max_op);
 728               *p++ = ' ';
 729             }
 730
 731           do
 732             *p++ = *insn_out++;
 733           while (*insn_out && *insn_out != '\n');
 734         }
 735       while (*insn_out);
 736       *p = '\0';
 737     }
 738   else
 739     {
 740       len = ce_len + 1 + insn_len + 1;
 741       new = xmalloc (len);
 742
 743       p = shift_output_template (new, ce_out, max_op);
 744       *p++ = ' ';
 745       memcpy (p, insn_out, insn_len + 1);
 746     }
 747
 748   return new;
 749 }
 750
 751 /* Replicate insns as appropriate for the given DEFINE_COND_EXEC.  */
 752
 753 static void
 754 process_one_cond_exec (struct queue_elem *ce_elem)
 755 {
 756   struct queue_elem *insn_elem;
 757   for (insn_elem = define_insn_queue; insn_elem ; insn_elem = insn_elem->next)
 758     {
 759       int alternatives, max_operand;
 760       rtx pred, insn, pattern;
 761
 762       if (! is_predicable (insn_elem))
 763         continue;
 764
 765       alternatives = 1;
 766       max_operand = -1;
 767       collect_insn_data (insn_elem->data, &alternatives, &max_operand);
 768       max_operand += 1;
 769
 770       if (XVECLEN (ce_elem->data, 0) != 1)
 771         {
 772           message_with_line (ce_elem->lineno,
 773                              "too many patterns in predicate");
 774           errors = 1;
 775           return;
 776         }
 777
 778       pred = copy_rtx (XVECEXP (ce_elem->data, 0, 0));
 779       pred = alter_predicate_for_insn (pred, alternatives, max_operand,
 780                                        ce_elem->lineno);
 781       if (pred == NULL)
 782         return;
 783
 784       /* Construct a new pattern for the new insn.  */
 785       insn = copy_rtx (insn_elem->data);
 786       XSTR (insn, 0) = "";
 787       pattern = rtx_alloc (COND_EXEC);
 788       XEXP (pattern, 0) = pred;
 789       if (XVECLEN (insn, 1) == 1)
 790         {
 791           XEXP (pattern, 1) = XVECEXP (insn, 1, 0);
 792           XVECEXP (insn, 1, 0) = pattern;
 793           PUT_NUM_ELEM (XVEC (insn, 1), 1);
 794         }
 795       else
 796         {
 797           XEXP (pattern, 1) = rtx_alloc (PARALLEL);
 798           XVEC (XEXP (pattern, 1), 0) = XVEC (insn, 1);
 799           XVEC (insn, 1) = rtvec_alloc (1);
 800           XVECEXP (insn, 1, 0) = pattern;
 801         }
 802
 803       XSTR (insn, 2) = alter_test_for_insn (ce_elem, insn_elem);
 804       XTMPL (insn, 3) = alter_output_for_insn (ce_elem, insn_elem,
 805                                               alternatives, max_operand);
 806
 807       /* ??? Set `predicable' to false.  Not crucial since it's really
 808          only used here, and we won't reprocess this new pattern.  */
 809
 810       /* Put the new pattern on the `other' list so that it
 811          (a) is not reprocessed by other define_cond_exec patterns
 812          (b) appears after all normal define_insn patterns.
 813
 814          ??? B is debatable.  If one has normal insns that match
 815          cond_exec patterns, they will be preferred over these
 816          generated patterns.  Whether this matters in practice, or if
 817          it's a good thing, or whether we should thread these new
 818          patterns into the define_insn chain just after their generator
 819          is something we'll have to experiment with.  */
 820
 821       queue_pattern (insn, &other_tail, insn_elem->filename,
 822                      insn_elem->lineno);
 823     }
 824 }
 825
 826 /* If we have any DEFINE_COND_EXEC patterns, expand the DEFINE_INSN
 827    patterns appropriately.  */
 828
 829 static void
 830 process_define_cond_exec (void)
 831 {
 832   struct queue_elem *elem;
 833
 834   identify_predicable_attribute ();
 835   if (errors)
 836     return;
 837
 838   for (elem = define_cond_exec_queue; elem ; elem = elem->next)
 839     process_one_cond_exec (elem);
 840 }
 841
 842 static char *
 843 save_string (const char *s, int len)
 844 {
 845   register char *result = xmalloc (len + 1);
 846
 847   memcpy (result, s, len);
 848   result[len] = 0;
 849   return result;
 850 }
 851
 852 \f
 853 /* The entry point for initializing the reader.  */
 854
 855 int
 856 init_md_reader_args (int argc, char **argv)
 857 {
 858   int i;
 859   const char *in_fname;
 860
 861   max_include_len = 0;
 862   in_fname = NULL;
 863   for (i = 1; i < argc; i++)
 864     {
 865       if (argv[i][0] != '-')
 866         {
 867           if (in_fname == NULL)
 868             in_fname = argv[i];
 869         }
 870       else
 871         {
 872           int c = argv[i][1];
 873           switch (c)
 874             {
 875             case 'I':           /* Add directory to path for includes.  */
 876               {
 877                 struct file_name_list *dirtmp;
 878
 879                 dirtmp = (struct file_name_list *)
 880                   xmalloc (sizeof (struct file_name_list));
 881                 dirtmp->next = 0;       /* New one goes on the end */
 882                 if (first_dir_md_include == 0)
 883                   first_dir_md_include = dirtmp;
 884                 else
 885                   last_dir_md_include->next = dirtmp;
 886                 last_dir_md_include = dirtmp;   /* Tail follows the last one */
 887                 if (argv[i][1] == 'I' && argv[i][2] != 0)
 888                   dirtmp->fname = argv[i] + 2;
 889                 else if (i + 1 == argc)
 890                   fatal ("directory name missing after -I option");
 891                 else
 892                   dirtmp->fname = argv[++i];
 893                 if (strlen (dirtmp->fname) > max_include_len)
 894                   max_include_len = strlen (dirtmp->fname);
 895               }
 896               break;
 897             default:
 898               fatal ("invalid option `%s'", argv[i]);
 899
 900             }
 901         }
 902     }
 903     return init_md_reader (in_fname);
 904 }
 905 \f
 906 /* The entry point for initializing the reader.  */
 907
 908 int
 909 init_md_reader (const char *filename)
 910 {
 911   FILE *input_file;
 912   int c;
 913   size_t i;
 914   char *lastsl;
 915
 916   lastsl = strrchr (filename, '/');
 917   if (lastsl != NULL)
 918     base_dir = save_string (filename, lastsl - filename + 1 );
 919
 920   read_rtx_filename = filename;
 921   input_file = fopen (filename, "r");
 922   if (input_file == 0)
 923     {
 924       perror (filename);
 925       return FATAL_EXIT_CODE;
 926     }
 927
 928   /* Initialize the table of insn conditions.  */
 929   condition_table = htab_create (n_insn_conditions,
 930                                  hash_c_test, cmp_c_test, NULL);
 931
 932   for (i = 0; i < n_insn_conditions; i++)
 933     *(htab_find_slot (condition_table, (PTR) &insn_conditions[i], INSERT))
 934       = (PTR) &insn_conditions[i];
 935
 936   obstack_init (rtl_obstack);
 937   errors = 0;
 938   sequence_num = 0;
 939
 940   /* Read the entire file.  */
 941   while (1)
 942     {
 943       rtx desc;
 944       int lineno;
 945
 946       c = read_skip_spaces (input_file);
 947       if (c == EOF)
 948         break;
 949
 950       ungetc (c, input_file);
 951       lineno = read_rtx_lineno;
 952       desc = read_rtx (input_file);
 953       process_rtx (desc, lineno);
 954     }
 955   fclose (input_file);
 956
 957   /* Process define_cond_exec patterns.  */
 958   if (define_cond_exec_queue != NULL)
 959     process_define_cond_exec ();
 960
 961   return errors ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE;
 962 }
 963
 964 /* The entry point for reading a single rtx from an md file.  */
 965
 966 rtx
 967 read_md_rtx (int *lineno, int *seqnr)
 968 {
 969   struct queue_elem **queue, *elem;
 970   rtx desc;
 971
 972  discard:
 973
 974   /* Read all patterns from a given queue before moving on to the next.  */
 975   if (define_attr_queue != NULL)
 976     queue = &define_attr_queue;
 977   else if (define_insn_queue != NULL)
 978     queue = &define_insn_queue;
 979   else if (other_queue != NULL)
 980     queue = &other_queue;
 981   else
 982     return NULL_RTX;
 983
 984   elem = *queue;
 985   *queue = elem->next;
 986   desc = elem->data;
 987   read_rtx_filename = elem->filename;
 988   *lineno = elem->lineno;
 989   *seqnr = sequence_num;
 990
 991   free (elem);
 992
 993   /* Discard insn patterns which we know can never match (because
 994      their C test is provably always false).  If insn_elision is
 995      false, our caller needs to see all the patterns.  Note that the
 996      elided patterns are never counted by the sequence numbering; it
 997      it is the caller's responsibility, when insn_elision is false, not
 998      to use elided pattern numbers for anything.  */
 999   switch (GET_CODE (desc))
1000     {
1001     case DEFINE_INSN:
1002     case DEFINE_EXPAND:
1003       if (maybe_eval_c_test (XSTR (desc, 2)) != 0)
1004         sequence_num++;
1005       else if (insn_elision)
1006         goto discard;
1007       break;
1008
1009     case DEFINE_SPLIT:
1010     case DEFINE_PEEPHOLE:
1011     case DEFINE_PEEPHOLE2:
1012       if (maybe_eval_c_test (XSTR (desc, 1)) != 0)
1013         sequence_num++;
1014       else if (insn_elision)
1015             goto discard;
1016       break;
1017
1018     default:
1019       break;
1020     }
1021
1022   return desc;
1023 }
1024
1025 /* Helper functions for insn elision.  */
1026
1027 /* Compute a hash function of a c_test structure, which is keyed
1028    by its ->expr field.  */
1029 hashval_t
1030 hash_c_test (const void *x)
1031 {
1032   const struct c_test *a = (const struct c_test *) x;
1033   const unsigned char *base, *s = (const unsigned char *) a->expr;
1034   hashval_t hash;
1035   unsigned char c;
1036   unsigned int len;
1037
1038   base = s;
1039   hash = 0;
1040
1041   while ((c = *s++) != '\0')
1042     {
1043       hash += c + (c << 17);
1044       hash ^= hash >> 2;
1045     }
1046
1047   len = s - base;
1048   hash += len + (len << 17);
1049   hash ^= hash >> 2;
1050
1051   return hash;
1052 }
1053
1054 /* Compare two c_test expression structures.  */
1055 int
1056 cmp_c_test (const void *x, const void *y)
1057 {
1058   const struct c_test *a = (const struct c_test *) x;
1059   const struct c_test *b = (const struct c_test *) y;
1060
1061   return !strcmp (a->expr, b->expr);
1062 }
1063
1064 /* Given a string representing a C test expression, look it up in the
1065    condition_table and report whether or not its value is known
1066    at compile time.  Returns a tristate: 1 for known true, 0 for
1067    known false, -1 for unknown.  */
1068 int
1069 maybe_eval_c_test (const char *expr)
1070 {
1071   const struct c_test *test;
1072   struct c_test dummy;
1073
1074   if (expr[0] == 0)
1075     return 1;
1076
1077   if (insn_elision_unavailable)
1078     return -1;
1079
1080   dummy.expr = expr;
1081   test = (const struct c_test *) htab_find (condition_table, &dummy);
1082   if (!test)
1083     abort ();
1084
1085   return test->value;
1086 }
1087
1088 /* Given a string, return the number of comma-separated elements in it.
1089    Return 0 for the null string.  */
1090 int
1091 n_comma_elts (const char *s)
1092 {
1093   int n;
1094
1095   if (*s == '\0')
1096     return 0;
1097
1098   for (n = 1; *s; s++)
1099     if (*s == ',')
1100       n++;
1101
1102   return n;
1103 }
1104
1105 /* Given a pointer to a (char *), return a pointer to the beginning of the
1106    next comma-separated element in the string.  Advance the pointer given
1107    to the end of that element.  Return NULL if at end of string.  Caller
1108    is responsible for copying the string if necessary.  White space between
1109    a comma and an element is ignored.  */
1110
1111 const char *
1112 scan_comma_elt (const char **pstr)
1113 {
1114   const char *start;
1115   const char *p = *pstr;
1116
1117   if (*p == ',')
1118     p++;
1119   while (ISSPACE(*p))
1120     p++;
1121
1122   if (*p == '\0')
1123     return NULL;
1124
1125   start = p;
1126
1127   while (*p != ',' && *p != '\0')
1128     p++;
1129
1130   *pstr = p;
1131   return start;
1132 }