gcc/gensupport.c

   1 /* Support routines for the various generation passes.
   2    Copyright (C) 2000, 2001, 2002, 2003, 2004
   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 = 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_PATH (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, queuing 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       /* Fall through.  */
 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           /* Fall through.  */
 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 = 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       /* Fall through.  */
 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   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 = xmalloc (sizeof (struct file_name_list));
 880                 dirtmp->next = 0;       /* New one goes on the end */
 881                 if (first_dir_md_include == 0)
 882                   first_dir_md_include = dirtmp;
 883                 else
 884                   last_dir_md_include->next = dirtmp;
 885                 last_dir_md_include = dirtmp;   /* Tail follows the last one */
 886                 if (argv[i][1] == 'I' && argv[i][2] != 0)
 887                   dirtmp->fname = argv[i] + 2;
 888                 else if (i + 1 == argc)
 889                   fatal ("directory name missing after -I option");
 890                 else
 891                   dirtmp->fname = argv[++i];
 892                 if (strlen (dirtmp->fname) > max_include_len)
 893                   max_include_len = strlen (dirtmp->fname);
 894               }
 895               break;
 896             default:
 897               fatal ("invalid option `%s'", argv[i]);
 898
 899             }
 900         }
 901     }
 902     return init_md_reader (in_fname);
 903 }
 904 \f
 905 /* The entry point for initializing the reader.  */
 906
 907 int
 908 init_md_reader (const char *filename)
 909 {
 910   FILE *input_file;
 911   int c;
 912   size_t i;
 913   char *lastsl;
 914
 915   lastsl = strrchr (filename, '/');
 916   if (lastsl != NULL)
 917     base_dir = save_string (filename, lastsl - filename + 1 );
 918
 919   read_rtx_filename = filename;
 920   input_file = fopen (filename, "r");
 921   if (input_file == 0)
 922     {
 923       perror (filename);
 924       return FATAL_EXIT_CODE;
 925     }
 926
 927   /* Initialize the table of insn conditions.  */
 928   condition_table = htab_create (n_insn_conditions,
 929                                  hash_c_test, cmp_c_test, NULL);
 930
 931   for (i = 0; i < n_insn_conditions; i++)
 932     *(htab_find_slot (condition_table, &insn_conditions[i], INSERT))
 933       = (void *) &insn_conditions[i];
 934
 935   obstack_init (rtl_obstack);
 936   errors = 0;
 937   sequence_num = 0;
 938
 939   /* Read the entire file.  */
 940   while (1)
 941     {
 942       rtx desc;
 943       int lineno;
 944
 945       c = read_skip_spaces (input_file);
 946       if (c == EOF)
 947         break;
 948
 949       ungetc (c, input_file);
 950       lineno = read_rtx_lineno;
 951       desc = read_rtx (input_file);
 952       process_rtx (desc, lineno);
 953     }
 954   fclose (input_file);
 955
 956   /* Process define_cond_exec patterns.  */
 957   if (define_cond_exec_queue != NULL)
 958     process_define_cond_exec ();
 959
 960   return errors ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE;
 961 }
 962
 963 /* The entry point for reading a single rtx from an md file.  */
 964
 965 rtx
 966 read_md_rtx (int *lineno, int *seqnr)
 967 {
 968   struct queue_elem **queue, *elem;
 969   rtx desc;
 970
 971  discard:
 972
 973   /* Read all patterns from a given queue before moving on to the next.  */
 974   if (define_attr_queue != NULL)
 975     queue = &define_attr_queue;
 976   else if (define_insn_queue != NULL)
 977     queue = &define_insn_queue;
 978   else if (other_queue != NULL)
 979     queue = &other_queue;
 980   else
 981     return NULL_RTX;
 982
 983   elem = *queue;
 984   *queue = elem->next;
 985   desc = elem->data;
 986   read_rtx_filename = elem->filename;
 987   *lineno = elem->lineno;
 988   *seqnr = sequence_num;
 989
 990   free (elem);
 991
 992   /* Discard insn patterns which we know can never match (because
 993      their C test is provably always false).  If insn_elision is
 994      false, our caller needs to see all the patterns.  Note that the
 995      elided patterns are never counted by the sequence numbering; it
 996      it is the caller's responsibility, when insn_elision is false, not
 997      to use elided pattern numbers for anything.  */
 998   switch (GET_CODE (desc))
 999     {
1000     case DEFINE_INSN:
1001     case DEFINE_EXPAND:
1002       if (maybe_eval_c_test (XSTR (desc, 2)) != 0)
1003         sequence_num++;
1004       else if (insn_elision)
1005         goto discard;
1006       break;
1007
1008     case DEFINE_SPLIT:
1009     case DEFINE_PEEPHOLE:
1010     case DEFINE_PEEPHOLE2:
1011       if (maybe_eval_c_test (XSTR (desc, 1)) != 0)
1012         sequence_num++;
1013       else if (insn_elision)
1014             goto discard;
1015       break;
1016
1017     default:
1018       break;
1019     }
1020
1021   return desc;
1022 }
1023
1024 /* Helper functions for insn elision.  */
1025
1026 /* Compute a hash function of a c_test structure, which is keyed
1027    by its ->expr field.  */
1028 hashval_t
1029 hash_c_test (const void *x)
1030 {
1031   const struct c_test *a = (const struct c_test *) x;
1032   const unsigned char *base, *s = (const unsigned char *) a->expr;
1033   hashval_t hash;
1034   unsigned char c;
1035   unsigned int len;
1036
1037   base = s;
1038   hash = 0;
1039
1040   while ((c = *s++) != '\0')
1041     {
1042       hash += c + (c << 17);
1043       hash ^= hash >> 2;
1044     }
1045
1046   len = s - base;
1047   hash += len + (len << 17);
1048   hash ^= hash >> 2;
1049
1050   return hash;
1051 }
1052
1053 /* Compare two c_test expression structures.  */
1054 int
1055 cmp_c_test (const void *x, const void *y)
1056 {
1057   const struct c_test *a = (const struct c_test *) x;
1058   const struct c_test *b = (const struct c_test *) y;
1059
1060   return !strcmp (a->expr, b->expr);
1061 }
1062
1063 /* Given a string representing a C test expression, look it up in the
1064    condition_table and report whether or not its value is known
1065    at compile time.  Returns a tristate: 1 for known true, 0 for
1066    known false, -1 for unknown.  */
1067 int
1068 maybe_eval_c_test (const char *expr)
1069 {
1070   const struct c_test *test;
1071   struct c_test dummy;
1072
1073   if (expr[0] == 0)
1074     return 1;
1075
1076   if (insn_elision_unavailable)
1077     return -1;
1078
1079   dummy.expr = expr;
1080   test = htab_find (condition_table, &dummy);
1081   if (!test)
1082     abort ();
1083
1084   return test->value;
1085 }
1086
1087 /* Given a string, return the number of comma-separated elements in it.
1088    Return 0 for the null string.  */
1089 int
1090 n_comma_elts (const char *s)
1091 {
1092   int n;
1093
1094   if (*s == '\0')
1095     return 0;
1096
1097   for (n = 1; *s; s++)
1098     if (*s == ',')
1099       n++;
1100
1101   return n;
1102 }
1103
1104 /* Given a pointer to a (char *), return a pointer to the beginning of the
1105    next comma-separated element in the string.  Advance the pointer given
1106    to the end of that element.  Return NULL if at end of string.  Caller
1107    is responsible for copying the string if necessary.  White space between
1108    a comma and an element is ignored.  */
1109
1110 const char *
1111 scan_comma_elt (const char **pstr)
1112 {
1113   const char *start;
1114   const char *p = *pstr;
1115
1116   if (*p == ',')
1117     p++;
1118   while (ISSPACE(*p))
1119     p++;
1120
1121   if (*p == '\0')
1122     return NULL;
1123
1124   start = p;
1125
1126   while (*p != ',' && *p != '\0')
1127     p++;
1128
1129   *pstr = p;
1130   return start;
1131 }